/*
* pminit.c - program manager
*
* Copyright (c) 1991, Microsoft Corporation
*
* DESCRIPTION
*
* This file is for support of program manager under NT Windows.
* This file is/was ported from pminit.c (program manager).
*
* MODIFICATION HISTORY
* Initial Version: x/x/90 Author Unknown, since he didn't feel
* like commenting the code...
*
* NT 32b Version: 1/25/91 Jeff Pack
* Intitial port to begin.
*
*
*/
#include "progman.h"
#include "util.h"
#include "commdlg.h"
//#ifdef FE_IME
#include "winnls32.h"
//#endif
#include "uniconv.h"
#include "security.h"
#define MAX_USERNAME_LENGTH 256
#define PROGMAN_KEY L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Program Manager"
#define WINDOWS_KEY L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
//#define MYDEBUG 1
SECURITY_ATTRIBUTES SecurityAttributes;
SECURITY_ATTRIBUTES AdminSecAttr; // security attributes for common groups
BOOL bInitialArrange;
BOOL bInNtSetup;
TCHAR szProgramGroups[] = TEXT("UNICODE Program Groups"); // registry key for groups
TCHAR szRestrict[] = TEXT("Restrictions");
TCHAR szNoRun[] = TEXT("NoRun");
TCHAR szNoClose[] = TEXT("NoClose");
TCHAR szEditLevel[] = TEXT("EditLevel");
TCHAR szNoFileMenu[] = TEXT("NoFileMenu");
TCHAR szNoSave[] = TEXT("NoSaveSettings");
TCHAR szShowCommonGroups[]= TEXT("ShowCommonGroups");
TCHAR szSettings[] = TEXT("Settings");
TCHAR szGroups[] = TEXT("UNICODE Groups");
TCHAR szAnsiGroups[] = TEXT("Groups");
TCHAR szCommonGroups[] = TEXT("Common Groups");
TCHAR szSystemBoot[] = TEXT("Boot");
TCHAR szSystemDisplay[] = TEXT("display.drv");
TCHAR szDefPrograms[] = TEXT("EXE COM BAT PIF");
TCHAR szSystemIni[] = TEXT("system.ini");
TCHAR szWindows[] = TEXT("Windows");
TCHAR szCheckBinaryType[] = TEXT("CheckBinaryType");
TCHAR szCheckBinaryTimeout[] = TEXT("CheckBinaryTimeout");
TCHAR szMigrateAnsi[] = TEXT("Migrate ANSI");
BOOL bDisableDDE = FALSE;
/* in hotkey.c */
BOOL APIENTRY RegisterHotKeyClass(HANDLE hInstance);
/* in pmgseg.c */
HWND NEAR PASCAL IsGroupAlreadyLoaded(LPTSTR lpGroupKey, BOOL bCommonGroup);
/*---------------------------------------------------------------------------
*
* A fixed buffer case and space insensative compare...
* Returns true if they compare the same.
*
*--------------------------------------------------------------------------*/
BOOL NEAR PASCAL StartupCmp(LPTSTR szSrc1, LPTSTR szSrc2)
{
TCHAR sz1[MAXGROUPNAMELEN+1];
TCHAR sz2[MAXMESSAGELEN+1];
LPTSTR lp1, lp2;
lstrcpy(sz1, szSrc1);
CharUpper(sz1);
lstrcpy(sz2, szSrc2);
CharUpper(sz2);
lp1 = sz1;
lp2 = sz2;
for (;;) {
while(*lp1 == TEXT(' '))
lp1++;
while(*lp2 == TEXT(' '))
lp2++;
if (*lp1 != *lp2)
return FALSE;
if (!*lp1)
break;
while (*lp1 == *lp2 && *lp1)
lp1++, lp2++;
}
return TRUE;
}
/*---------------------------------------------------------------------------
*
* Handles finding and execing the items in the startup group.
*
*--------------------------------------------------------------------------*/
VOID NEAR PASCAL HandleStartupGroup(int nCmdShow)
{
TCHAR szGroupTitle[MAXGROUPNAMELEN+1];
HWND hwndT;
DWORD cbData = sizeof(TCHAR)*(MAXGROUPNAMELEN+1);
PGROUP pGroup;
LPGROUPDEF lpgd;
TCHAR szCommonStartupGroup[MAXGROUPNAMELEN+1];
TCHAR szDefaultStartup[MAXGROUPNAMELEN+1] = TEXT("startup");
TCHAR szStartupKana[] = TEXT("^?X^?^^?[^?g^?A^?b^?v");
if (nCmdShow != SW_SHOWMINNOACTIVE) {
//
// Daytona security weenies decreed that GetAsyncKeyState only work
// if threads window is foreground, so make it so.
//
hwndT = GetForegroundWindow();
if (hwndProgman != hwndT)
SetForegroundWindow( hwndProgman );
if (GetAsyncKeyState(VK_SHIFT) < 0) // SHIFT will cancel the startup group
return;
}
//
// The Default startup group name is "Startup", for personal and common
// groups.
//
LoadString(hAppInstance,IDS_DEFAULTSTARTUP,szDefaultStartup,CharSizeOf(szDefaultStartup));
lstrcpy(szGroupTitle, szDefaultStartup);
lstrcpy(szCommonStartupGroup, szDefaultStartup);
//
// Get the Personal startup group name.
//
if (hkeyPMSettings) {
if ( RegQueryValueEx(hkeyPMSettings, szStartup, 0, 0, (LPBYTE)szGroupTitle, &cbData) != ERROR_SUCCESS ) {
lstrcpy(szGroupTitle, szDefaultStartup);
}
}
// Search for the startup group.
hwndT = GetWindow(hwndMDIClient, GW_CHILD);
while (hwndT) {
//
// Skip icon titles.
//
if (!GetWindow(hwndT, GW_OWNER)) {
/* Compare the group name with the startup. */
pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
if (lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup)) {
// ToddB: We want to check for three things here:
// 1.) A common group with the name szCommonStartupGroup
// 2.) Any group with the name szGroupTitle (which is a copy of szDefaultStartup)
// 3.) If we are in Japan then we also search for two hardcoded strings,
// szStartupKana AND szStartup. I think this special Japanese
// check is a bug and should be removed.
if (pGroup->fCommon) {
if (StartupCmp(szCommonStartupGroup, (LPTSTR) PTR(lpgd, lpgd->pName)))
StartupGroup(hwndT);
}
else if (StartupCmp(szGroupTitle, (LPTSTR) PTR(lpgd, lpgd->pName))) {
StartupGroup(hwndT);
}
#ifdef JAPAN_HACK_WHICH_TODDB_THINKS_IS_A_BUG
else if (PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale())) == LANG_JAPANESE)
{
if (StartupCmp(szStartupKana,(LPTSTR)PTR(lpgd,lpgd->pName)) || // search for hardcoded localized startup
StartupCmp(szStartup,(LPTSTR)PTR(lpgd,lpgd->pName))) // search for hardcoded non-localized "startup"
{
StartupGroup( hwndT );
}
}
#endif
GlobalUnlock(pGroup->hGroup);
}
}
hwndT = GetWindow(hwndT, GW_HWNDNEXT);
}
}
/*** BoilThatDustSpec -- strips string to program name
*
*
* VOID APIENTRY BoilThatDustSpec(PSTR pStart, BOOL bLoadIt)
*
* ENTRY - PSTR pStart - Program to exec, and possible parameters
* BOOL LoadIt -
*
* EXIT - VOID
*
* SYNOPSIS - strips everything after program name, then exec's program.
*
* WARNINGS -
* EFFECTS -
*
*/
VOID APIENTRY BoilThatDustSpec(LPTSTR pStart, BOOL bLoadIt)
{
register LPTSTR pEnd;
WORD ret;
BOOL bFinished;
TCHAR szText[MAXMESSAGELEN+1];
TCHAR szExtra[MAXMESSAGELEN+1];
TCHAR szFilename[MAXITEMPATHLEN+1];
TCHAR szWindowsDirectory2[MAXITEMPATHLEN+1];
if (*pStart == TEXT('\0')) { /*test for null string*/
return;
}
// Used to massage any errors.
LoadString(hAppInstance,IDS_WININIERR,szExtra, CharSizeOf(szExtra));
// skip first spaces
while (*pStart == ' ') {
pStart = CharNext(pStart);
}
bFinished = !*pStart;
GetWindowsDirectory(szWindowsDirectory2, CharSizeOf(szWindowsDirectory2));
while (!bFinished){
pEnd = pStart;
/* strip anything after execprogram name*/
while ((*pEnd) && (*pEnd != TEXT(' ')) && (*pEnd != TEXT(','))){
pEnd = CharNext(pEnd);
}
if (*pEnd == TEXT('\0'))
bFinished = TRUE;
else
*pEnd = TEXT('\0');
if (!*pStart) {
pStart = pEnd+1;
continue;
}
if (GetFreeSpace(GMEM_NOT_BANKED) < 65535L)
break;
GetDirectoryFromPath(pStart, szDirField);
// Load and Run lines are done relative to windows directory.
SetCurrentDirectory(szWindowsDirectory2);
GetFilenameFromPath(pStart, szFilename);
ret = ExecProgram(szFilename, szDirField, NULL, bLoadIt, 0, 0, 0);
if (ret) {
// Insert a phrase mentioning win.ini after the file name.
szText[0] = TEXT('\'');
lstrcpy(&szText[1], pStart);
lstrcat(szText, szExtra);
MyMessageBox(NULL, IDS_APPTITLE, ret, szText, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
}
pStart = pEnd+1;
}
SetCurrentDirectory(szWindowsDirectory); // in fact system32 directory
}
/*** DoRunEquals --
*
*
* VOID APIENTRY DoRunEquals(PINT pnCmdShow)
*
* ENTRY - PINT pnCmdShow - point to cmdshow
*
* EXIT - VOID
*
* SYNOPSIS - ???
*
* WARNINGS -
* EFFECTS -
*
*/
VOID APIENTRY DoRunEquals(PINT pnCmdShow)
{
TCHAR szBuffer[MAX_PATH];
DWORD dwType;
DWORD cbData;
HKEY hkeyWindows;
/* "Load" apps before "Run"ning any. */
if (RegOpenKeyEx(HKEY_CURRENT_USER,
WINDOWS_KEY,
0,
KEY_READ,
&hkeyWindows) != ERROR_SUCCESS) {
return;
}
*szBuffer = 0;
cbData = sizeof(szBuffer);
RegQueryValueEx(hkeyWindows,
L"Load",
0,
&dwType,
(LPBYTE)szBuffer, &cbData);
if (*szBuffer)
BoilThatDustSpec(szBuffer, TRUE);
*szBuffer = 0;
cbData = sizeof(szBuffer);
RegQueryValueEx(hkeyWindows,
L"Run",
0,
&dwType,
(LPBYTE)szBuffer, &cbData);
if (*szBuffer) {
BoilThatDustSpec(szBuffer, FALSE);
*pnCmdShow = SW_SHOWMINNOACTIVE;
}
RegCloseKey(hkeyWindows);
}
/*** GetSettings --
*
*
* PSTR APIENTRY GetSettings(VOID)
*
* ENTRY - VOID
*
* EXIT - PSTR - if NULL then error.
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
LPTSTR APIENTRY GetSettings()
{
LPTSTR pszT;
TCHAR szGroups[32];
TCHAR szAppTitle[MAXKEYLEN + 1];
DWORD cbData;
DWORD dwType;
DWORD rc;
DWORD dwBinaryInfo;
#define SETTING_SIZE 160
/* Get the flags out of the INI file. */
LoadString(hAppInstance, IDS_GROUPS, szGroups, CharSizeOf(szGroups));
LoadString(hAppInstance, IDS_APPTITLE, szAppTitle, CharSizeOf(szAppTitle));
/*
* Use direct registry call.
*/
if (hkeyPMSettings) {
cbData = sizeof(bMinOnRun);
RegQueryValueEx(hkeyPMSettings, szMinOnRun, 0, &dwType, (LPBYTE)&bMinOnRun, &cbData);
cbData = sizeof(bAutoArrange);
RegQueryValueEx(hkeyPMSettings, szAutoArrange, 0, &dwType, (LPBYTE)&bAutoArrange, &cbData);
cbData = sizeof(bSaveSettings);
RegQueryValueEx(hkeyPMSettings, szSaveSettings, 0, &dwType, (LPBYTE)&bSaveSettings, &cbData);
cbData = sizeof(bInitialArrange);
bInitialArrange = FALSE;
rc = RegQueryValueEx(hkeyPMSettings, TEXT("InitialArrange"), 0, &dwType, (LPBYTE)&bInitialArrange, &cbData);
if (bInitialArrange) {
RegDeleteValue(hkeyPMSettings, TEXT("InitialArrange"));
}
//
// Check if the binary type checking information exists. If not,
// add it.
//
// First check for the enabled / disabled entry.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryType, 0, &dwType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_FILE_NOT_FOUND) {
//
// Key doesn't exist, so create the default case.
//
dwBinaryInfo = BINARY_TYPE_DEFAULT;
RegSetValueEx (hkeyPMSettings, szCheckBinaryType, 0, REG_DWORD,
(LPBYTE) &dwBinaryInfo, cbData);
}
//
// Now check for the timeout value. This is the number of milliseconds
// of delay after the lastkeystroke and before the background thread
// is signaled to check the type.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryTimeout, 0, &dwType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_FILE_NOT_FOUND) {
//
// Key doesn't exist, so create the default case.
//
dwBinaryInfo = BINARY_TIMEOUT_DEFAULT;
RegSetValueEx (hkeyPMSettings, szCheckBinaryTimeout, 0, REG_DWORD,
(LPBYTE) &dwBinaryInfo, cbData);
}
}
if (hkeyPMRestrict && !UserIsAdmin) {
cbData = sizeof(fNoRun);
RegQueryValueEx(hkeyPMRestrict, szNoRun, 0, &dwType, (LPBYTE)&fNoRun, &cbData);
cbData = sizeof(fNoClose);
RegQueryValueEx(hkeyPMRestrict, szNoClose, 0, &dwType, (LPBYTE)&fNoClose, &cbData);
cbData = sizeof(fNoSave);
RegQueryValueEx(hkeyPMRestrict, szNoSave, 0, &dwType, (LPBYTE)&fNoSave, &cbData);
cbData = sizeof(dwEditLevel);
RegQueryValueEx(hkeyPMRestrict, szEditLevel, 0, &dwType, (LPBYTE)&dwEditLevel, &cbData);
}
pszT = (LPTSTR)LocalAlloc(LPTR, SETTING_SIZE);
if (!pszT)
return(NULL);
/*
* Use direct registry call.
*/
if (hkeyPMSettings) {
cbData = SETTING_SIZE;
if (RegQueryValueEx(hkeyPMSettings, szWindow, 0, &dwType, (LPBYTE)pszT, &cbData)) {
LocalFree((HANDLE)pszT);
return NULL;
}
}
else {
return(NULL);
}
return pszT;
}
//#if 0
BOOL GetUserAndDomainName(LPTSTR lpBuffer, DWORD cb)
{
HANDLE hToken;
DWORD cbTokenBuffer = 0;
PTOKEN_USER pUserToken;
LPTSTR lpUserName = NULL;
LPTSTR lpUserDomain = NULL;
DWORD cbAccountName = 0;
DWORD cbUserDomain = 0;
SID_NAME_USE SidNameUse;
if (!OpenProcessToken(GetCurrentProcess(),
TOKEN_QUERY,
&hToken) ){
return(FALSE);
}
//
// Get space needed for token information
//
if (!GetTokenInformation(hToken,
TokenUser,
NULL,
0,
&cbTokenBuffer) ) {
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
return(FALSE);
}
}
//
// Get the actual token information
//
pUserToken = (PTOKEN_USER)Alloc(cbTokenBuffer);
if (pUserToken == NULL) {
return(FALSE);
}
if (!GetTokenInformation(hToken,
TokenUser,
pUserToken,
cbTokenBuffer,
&cbTokenBuffer) ) {
Free(pUserToken);
return(FALSE);
}
//
// Get the space needed for the User name and the Domain name
//
if (!LookupAccountSid(NULL,
pUserToken->User.Sid,
NULL, &cbAccountName,
NULL, &cbUserDomain,
&SidNameUse
) ) {
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
Free(pUserToken);
return(FALSE);
}
}
lpUserName = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(cbAccountName+1));
if (!lpUserName) {
Free(pUserToken);
return(FALSE);
}
lpUserDomain = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(1+cbUserDomain));
if (!lpUserDomain) {
LocalFree(lpUserName);
Free(pUserToken);
return(FALSE);
}
//
// Now get the user name and domain name
//
if (!LookupAccountSid(NULL,
pUserToken->User.Sid,
lpUserName, &cbAccountName,
lpUserDomain, &cbUserDomain,
&SidNameUse
) ) {
LocalFree(lpUserName);
LocalFree(lpUserDomain);
Free(pUserToken);
return(FALSE);
}
if (*lpUserName &&
((int)sizeof(TCHAR)*(lstrlen(lpBuffer) + lstrlen(lpUserName) + lstrlen(lpUserDomain)) < (int)(cb+4)) ) {
lstrcat(lpBuffer, TEXT(" - "));
lstrcat(lpBuffer, lpUserDomain);
lstrcat(lpBuffer, TEXT("\\"));
lstrcat(lpBuffer, lpUserName);
}
Free(pUserToken);
LocalFree(lpUserName);
LocalFree(lpUserDomain);
return(TRUE);
}
//#endif
/*** CreateFrameWindow --
*
*
* HWND APIENTRY CreateFrameWindow(register PRECT prc, WORD nCmdShow)
*
* ENTRY - PRECT prc -
* WORD nCmdShow -
*
* EXIT - HWND - (NULL = Error)
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
HWND APIENTRY CreateFrameWindow(register PRECT prc, WORD nCmdShow)
{
HDC hdc;
HBRUSH hbr;
HMENU hMenu;
HMENU hSystemMenu;
TCHAR szBuffer[40 + MAX_USERNAME_LENGTH];
TCHAR szProgmanClass[16];
TCHAR szUserName[MAX_USERNAME_LENGTH + 1] = TEXT("");
TCHAR szUserDomain[MAX_USERNAME_LENGTH + 1] = TEXT("");
DWORD dwType, cbData;
/* Create the Desktop Manager window. */
LoadString(hAppInstance, IDS_APPTITLE, szBuffer, CharSizeOf(szBuffer));
LoadString(hAppInstance, IDS_PMCLASS, szProgmanClass, CharSizeOf(szProgmanClass));
#if 1
GetUserAndDomainName(szBuffer,sizeof(szBuffer));
#else
cbData = CharSizeOf(szUserName);
GetUserName(szUserName, &cbData) ;
cbData = CharSizeOf(szUserDomain);
GetEnvironmentVariable(TEXT("USERDOMAIN"), szUserDomain, cbData);
if (*szUserName){
lstrcat(szBuffer, TEXT(" - "));
lstrcat(szBuffer, szUserDomain);
lstrcat(szBuffer, TEXT("\\"));
lstrcat(szBuffer, szUserName);
}
#endif
hwndProgman = CreateWindow(szProgmanClass,
szBuffer,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
prc->left, prc->top,
prc->right-prc->left,
prc->bottom-prc->top,
NULL, /* No Parent */
NULL, /* Use Class Menu */
hAppInstance,
NULL);
if (!hwndProgman)
return NULL;
SetWindowLong (hwndProgman, GWL_EXITING, 0);
hMenu = GetMenu(hwndProgman);
hSystemMenu = GetSystemMenu(hwndProgman, FALSE);
if (!bExitWindows) {
LoadString(hAppInstance,IDS_EXIT,szBuffer,CharSizeOf(szBuffer));
ModifyMenu(hMenu,IDM_EXIT,MF_BYCOMMAND|MF_STRING,IDM_EXIT,szBuffer);
DeleteMenu(hMenu,IDM_SHUTDOWN,MF_BYCOMMAND);
}
else {
// replace Close menu item with Logoff and Shutdown
LoadString(hAppInstance,IDS_LOGOFF,szBuffer,CharSizeOf(szBuffer));
InsertMenu(hSystemMenu, SC_CLOSE, MF_BYCOMMAND|MF_STRING, SC_CLOSE, szBuffer);
LoadString(hAppInstance,IDS_SHUTDOWN,szBuffer,CharSizeOf(szBuffer));
ModifyMenu(hSystemMenu, SC_CLOSE, MF_BYCOMMAND|MF_STRING, IDM_SHUTDOWN, szBuffer);
}
if (hkeyPMRestrict && !UserIsAdmin) {
cbData = sizeof(fNoFileMenu);
RegQueryValueEx(hkeyPMRestrict, szNoFileMenu, 0, &dwType, (LPBYTE)&fNoFileMenu, &cbData);
}
if (fNoFileMenu) {
DeleteMenu(hMenu, IDM_FILE, MF_BYPOSITION);
}
if (fNoSave) {
bSaveSettings = FALSE;
EnableMenuItem(hMenu, IDM_SAVESETTINGS, MF_BYCOMMAND|MF_GRAYED|MF_DISABLED);
EnableMenuItem(hMenu, IDM_SAVENOW, MF_BYCOMMAND|MF_GRAYED|MF_DISABLED);
}
/* Update the menu items here (no maximized kids to deal with). */
if (bMinOnRun)
CheckMenuItem(hMenu, IDM_MINONRUN, MF_CHECKED);
if (bAutoArrange)
CheckMenuItem(hMenu, IDM_AUTOARRANGE, MF_CHECKED);
if (bSaveSettings)
CheckMenuItem(hMenu, IDM_SAVESETTINGS, MF_CHECKED);
if (bInNtSetup) {
EnableWindow(hwndProgman, FALSE);
}
ShowWindow(hwndProgman, nCmdShow);
UpdateWindow(hwndProgman);
/* fake-paint the client area with the color of the MDI client so users
* have something pleasent to stare at while we hit the disk for the
* group files
*/
hdc = GetDC(hwndProgman);
GetClientRect(hwndProgman, prc);
hbr = CreateSolidBrush(GetSysColor(COLOR_APPWORKSPACE));
if (hbr) {
FillRect(hdc, prc, hbr);
DeleteObject(hbr);
}
ReleaseDC(hwndProgman, hdc);
return hwndProgman;
}
/*** IsGroup --
*
*
* BOOL APIENTRY IsGroup(PSTR p)
*
* ENTRY - PSTR p -
*
* EXIT - BOOL - (FALSE == ERROR)
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
BOOL PASCAL IsGroup(LPTSTR p)
{
if (_wcsnicmp(p, TEXT("GROUP"), CCHGROUP) != 0) {
return FALSE;
}
/*
* Can't have 0 for first digit
*/
if (p[5] == TEXT('0')) {
return FALSE;
}
/*
* Everything else must be a number
*/
for (p += CCHGROUP; *p; p++) {
if (*p != TEXT('C') && (*p < TEXT('0') || *p > TEXT('9'))) {
return FALSE;
}
}
return TRUE;
}
/*** RemoveString --
*
*
* VOID APIENTRY RemoveString(PSTR pString)
*
* ENTRY - PSTR pString -
*
* EXIT - VOID
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
VOID APIENTRY RemoveString(LPTSTR pString)
{
LPTSTR pT = pString + lstrlen(pString) + 1;
while (*pT) {
while (*pString++ = *pT++)
;
}
*pString = 0;
}
/*** StringToEnd --
*
*
* VOID APIENTRY StringToEnd(PSTR pString)
*
* ENTRY - PSTR pString -
*
* EXIT - VOID
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
VOID PASCAL StringToEnd(LPTSTR pString)
{
TCHAR *pT,*pTT;
for (pT = pString; *pT; ) //go to end of strings
while (*pT++)
;
for (pTT = pString; *pT++ = *pTT++;) // copy first string to the end
;
*pT = 0;
RemoveString(pString); // remove first string
}
/*** GetGroupList --
*
*
* VOID APIENTRY GetGroupList(PSTR szList)
*
* ENTRY - PSTR szList -
*
* EXIT - VOID
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
VOID PASCAL GetGroupList(LPTSTR szList, HKEY hkeyPMGroups)
{
TCHAR szOrd[CGROUPSMAX*8+7];
TCHAR szT[20];
LPTSTR pT, pTT, pS;
INT cGroups; // The number of Groups= lines.
LPTSTR lpList;
DWORD dwType;
DWORD dwIndex = 0;
DWORD cbValueName = 8;
DWORD cbData;
INT cbList = (CGROUPSMAX+1)*18;
LPTSTR lpOrder;
lpList = szList;
//
// Get the user's list of personal groups.
//
if (hkeyPMGroups) {
cbValueName = cbList;
while (!RegEnumValue(hkeyPMGroups, dwIndex, lpList, &cbValueName, 0, 0,
0, 0)) {
dwIndex++; cbValueName++;
lpList += cbValueName;
cbList -= cbValueName;
cbValueName = cbList;
}
}
//
// Now get the user's list of common groups.
//
if (hkeyPMCommonGroups) {
cbValueName = cbList;
dwIndex = 0;
while (!RegEnumValue(hkeyPMCommonGroups, dwIndex, lpList, &cbValueName, 0, 0,
0, 0)) {
dwIndex++; cbValueName++;
lpList += cbValueName;
cbList -= cbValueName;
cbValueName = cbList;
}
}
*lpList = TEXT('\0');
cbData = sizeof(szOrd);
if (bUseANSIGroups)
lpOrder = szAnsiOrder;
else
lpOrder = szOrder;
if (!hkeyPMSettings || RegQueryValueEx(hkeyPMSettings, lpOrder, 0, &dwType, (LPBYTE)szOrd, &cbData))
*szOrd = TEXT('\0');
cGroups = 0;
/*
* Filter out anything that isn't group#.
*/
for (pT = szList; *pT; ) {
CharUpper(pT);
if (IsGroup(pT)) {
pT += lstrlen(pT) + 1;
cGroups++;
} else {
RemoveString(pT);
}
}
/*
* Sort the groups
*/
lstrcpy(szT, TEXT("Group"));
for (pT = szOrd; *pT; ) {
while (*pT == TEXT(' ')) {
pT++;
}
if ((*pT == TEXT('C') && (*(pT+1) < TEXT('0') || *(pT+1) > TEXT('9'))) ||
(*pT != TEXT('C') && (*pT < TEXT('0') || *pT > TEXT('9'))) ) {
break;
}
pTT = szT + CCHGROUP;
while (*pT == TEXT('C') || (*pT >= TEXT('0') && *pT <= TEXT('9'))) {
*pTT++ = *pT++;
}
*pTT=0;
for (pS = szList; *pS; pS += lstrlen(pS) + 1) {
if (!lstrcmpi(pS,szT)) {
StringToEnd(pS);
cGroups--;
break;
}
}
}
/*
* Move any remaining groups to the end of the list so that they load
* last and appear on top of everything else - keeps DOS based install
* programs happy.
* If bInitialArrange is set then the remaining groups come from the
* Windows 3.1 migration and we want these groups to be loaded before
* the remaining groups so they appear below the regular groups.
* 10-15-93 johannec
*/
if (!bInitialArrange) {
while (cGroups>0) {
StringToEnd(szList);
cGroups--;
}
}
}
/*** LoadCommonGroups --
*
*
* VOID APIENTRY LoadCommonGroups(LPTSTR)
*
* ENTRY - LPTSTR the key name of the common group that should have the focus.
*
* EXIT - HWND hwnd of the common group which should have the focus.
*
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
*/
HWND LoadCommonGroups(LPTSTR lpFocusGroup)
{
int i = 0;
TCHAR szGroupKey[MAXKEYLEN];
DWORD cchGroupKey = CharSizeOf(szGroupKey);
BOOL bRealArrange;
FILETIME ft;
HWND hwnd;
if (!hkeyCommonGroups) { // cannot access registry.
return(NULL);
}
/*
* Set global to note that we haven't run out of memory yet.
*/
fLowMemErrYet = FALSE;
/*
* Flag for extraction problems.
*/
fErrorOnExtract = FALSE;
// REVIEW - Why stop AutoArrange on load ? Switch it off for now.
bRealArrange = bAutoArrange;
//
// For mow, just load the groups in whatever order they are enumerated
// in the registry.
//
while (!RegEnumKeyEx(hkeyCommonGroups, i, szGroupKey, &cchGroupKey, 0, 0, 0, &ft)) {
if (cchGroupKey) {
hwnd = LoadGroupWindow(szGroupKey, 0, TRUE);
}
cchGroupKey = CharSizeOf(szGroupKey);
i++;
}
bAutoArrange = bRealArrange;
/*
* Check to see if there was any trouble.
*/
if (fErrorOnExtract) {
/*
* On observed problem with icon extraction has been to do
* with a low memory.
*/
MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXTRACT,
NULL, MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
}
return(hwnd);
}
/*** LoadAllGroups --
*
*
* VOID APIENTRY LoadAllGroups(VOID)
*
* ENTRY - VOID
*
* EXIT - VOID
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
VOID PASCAL LoadAllGroups()
{
LPTSTR pT, pszT;
TCHAR szGroupList[(CGROUPSMAX+1)*18];
WORD wIndex;
TCHAR szPath[120];
TCHAR szGroupKey[MAXKEYLEN];
BOOL bRealArrange;
DWORD cbData;
DWORD dwType;
BOOL fShowCommonGrps = TRUE;
HKEY hkeyPMAnsiGroups = NULL;
HKEY hkeyGroups;
TCHAR szCommonGrpInfo[MAXKEYLEN];
INT i;
BOOL bDefaultPosition = FALSE;
INT rgiPos[7];
HWND hwndGroup;
if (bUseANSIGroups) {
RegCreateKeyEx(hkeyProgramManager, szAnsiGroups, 0, szProgman, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyPMAnsiGroups, NULL);
hkeyGroups = hkeyPMAnsiGroups;
}
else {
hkeyGroups = hkeyPMGroups;
}
if (!hkeyGroups) { // cannot access registry.
return;
}
/*
* Set global to note that we haven't run out of memory yet.
*/
fLowMemErrYet = FALSE;
/*
* Flag for extraction problems.
*/
fErrorOnExtract = FALSE;
// REVIEW - Why stop AutoArrange on load ? Switch it off for now.
bRealArrange = bAutoArrange;
//
// If the user is allowed to see the common program groups, load them.
//
if (hkeyPMRestrict) {
cbData = sizeof(fShowCommonGrps);
RegQueryValueEx(hkeyPMRestrict, szShowCommonGroups, 0, &dwType, (LPBYTE)&fShowCommonGrps, &cbData);
}
if (fShowCommonGrps || AccessToCommonGroups) {
RegCreateKeyEx(hkeyProgramManager, szCommonGroups, 0, szProgman, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyPMCommonGroups, NULL);
//
// Load all common program groups
//
LoadCommonGroups(szNULL);
}
//
// Now load the user's personal program groups.
//
pT = szGroupList;
for (GetGroupList(pT, hkeyGroups); *pT; pT += (lstrlen(pT) + 1)) {
*szGroupKey = TEXT('\0');
cbData = sizeof(szCommonGrpInfo);
//
// If we're loading a common group...
//
if (*(pT+CCHGROUP) == TEXT('C') && hkeyPMCommonGroups) {
if (RegQueryValueEx(hkeyPMCommonGroups, pT, 0, 0,
(LPBYTE)szCommonGrpInfo, &cbData))
continue;
wIndex = 0;
for (pszT = pT + CCHCOMMONGROUP; *pszT; pszT++) {
wIndex *= 10;
wIndex += *pszT - TEXT('0');
}
//
// Get the window coordinates of this common group.
//
pszT = szCommonGrpInfo;
for (i=0; i < 7; i++) {
rgiPos[i] = 0;
while (*pszT && !((*pszT >= TEXT('0') && *pszT <= TEXT('9')) || *pszT == TEXT('-')))
pszT++;
if (!*pszT) {
bDefaultPosition = TRUE;
break;
}
rgiPos[i] = MyAtoi(pszT);
while (*pszT && ((*pszT >= TEXT('0') && *pszT <= TEXT('9')) || *pszT == TEXT('-')))
pszT++;
}
//
// Now get the common group's name.
//
if (*pszT) {
while(*pszT && *pszT == TEXT(' ')) pszT++;
lstrcpy(szGroupKey, pszT);
}
hwndGroup = IsGroupAlreadyLoaded(szGroupKey, TRUE);
if (!hwndGroup) {
//
// The common group no longer exists, remove this entry from
// the user's list.
//
RegDeleteValue(hkeyPMCommonGroups, pT);
}
if (hwndGroup && !bDefaultPosition) {
//
// Position the common group according to the user's choice.
//
SetInternalWindowPos(hwndGroup, (UINT)rgiPos[6],
(LPRECT)&rgiPos[0], (LPPOINT)&rgiPos[4]);
}
}
else {
if (RegQueryValueEx(hkeyGroups, pT, 0, 0, (LPBYTE)szGroupKey, &cbData))
continue;
wIndex = 0;
for (pszT = pT + CCHGROUP; *pszT; pszT++) {
wIndex *= 10;
wIndex += *pszT - TEXT('0');
}
LoadGroupWindow(szGroupKey, wIndex, FALSE);
}
}
bAutoArrange = bRealArrange;
//
// If we started with ANSI groups, save the newly converted unicode
// groups now.
//
if (bUseANSIGroups) {
WriteINIFile();
}
if (hkeyPMAnsiGroups) {
RegCloseKey(hkeyPMAnsiGroups);
}
/*
* Record the current display driver.
*/
GetPrivateProfileString(szSystemBoot, szSystemDisplay, szPath, szPath, CharSizeOf(szPath), szSystemIni);
RegSetValueEx(hkeyPMSettings, szSystemDisplay, 0, REG_SZ, (LPBYTE)szPath, sizeof(TCHAR)*(lstrlen(szPath)+1));
/*
* Check to see if there was any trouble.
*/
if (fErrorOnExtract) {
/*
* On observed problem with icon extraction has been to do
* with a low memory.
*/
MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXTRACT,
NULL, MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
}
}
//*************************************************************
//
// UseAnsiGroups()
//
// Purpose: Determine if we should convert the ANSI groups
// to Unicode groups.
//
// Parameters: DWORD dwDisp - disposition from RegCreateKeyEx
// on UNICODE Program Groups
//
// Return: BOOL TRUE if the groups should be converted
// FALSE if not
//
//*************************************************************
BOOL UseAnsiGroups(DWORD dwDisp)
{
DWORD dwType, dwMigrateValue, dwSize, dwAnsiValue = 0;
LONG lResult;
BOOL bRet = FALSE;
HKEY hKeyAnsiPG;
//
// If the dwDisp is a new key, then we return immediately and use
// the ANSI groups if they exist.
//
if (dwDisp == REG_CREATED_NEW_KEY) {
return TRUE;
}
//
// dwDisp is an existing key.
// If the "Migrate Ansi" value exist and the ANSI groups exist,
// then use them otherwise use the current UNICODE information.
//
dwSize = sizeof (DWORD);
lResult = RegQueryValueEx (hkeyProgramGroups, szMigrateAnsi,
NULL, &dwType, (LPBYTE) &dwMigrateValue,
&dwSize);
//
// Check the return value of registry call. If it fails
// then we are working with a machine that has UNICODE Program
// Groups, and does not need to be updated from the ANSI groups.
// Most of the time, we will exit here.
//
if (lResult != ERROR_SUCCESS) {
return FALSE;
}
//
// Now we need to know if any ANSI groups exist.
//
lResult = RegOpenKeyEx (HKEY_CURRENT_USER, szAnsiProgramGroups,
0, KEY_READ, &hKeyAnsiPG);
if (lResult == ERROR_SUCCESS) {
TCHAR szName[MAX_PATH];
DWORD dwNameSize = MAX_PATH;
FILETIME ft;
//
// The "Program Groups" key exists, check to see if there is
// really something in it.
//
lResult = RegEnumKeyEx (hKeyAnsiPG, 0, szName, &dwNameSize, NULL,
NULL, NULL, &ft);
//
// If the return value is success, then there is one or more
// items in the ANSI key.
//
if (lResult == ERROR_SUCCESS) {
dwAnsiValue = 1;
} else {
dwAnsiValue = 0;
}
//
// Close the key
//
RegCloseKey (hKeyAnsiPG);
}
//
// If the MigrateValue is set, then we want to delete this entry
// so the next time the user logs we don't try to convert the ANSI
// groups again (and this function will execute faster).
//
if (dwMigrateValue) {
RegDeleteValue (hkeyProgramGroups, szMigrateAnsi);
}
//
// Determine the return value.
//
if (dwMigrateValue && dwAnsiValue) {
bRet = TRUE;
} else {
bRet = FALSE;
}
return (bRet);
}
/*** ReadConfigFile --
*
*
* BOOL APIENTRY ReadConfigFile(int nCmdShow)
*
* ENTRY - int CmdShow -
*
* EXIT - void
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
VOID NEAR PASCAL ReadConfigFile(int nCmdShow)
{
int j;
int rgiPos[5];
LPTSTR pszT, pT;
HCURSOR hCursor;
BOOL bErrorMsgDisplayed = FALSE;
TCHAR szCommonGroupsKey[MAXKEYLEN];
DWORD dwDisposition;
HKEY hkey = NULL;
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
/*
* Create/Open the registry keys corresponding to progman.ini sections.
*/
if (!RegCreateKeyEx(HKEY_CURRENT_USER, PROGMAN_KEY, 0, szProgman, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyProgramManager, NULL)) {
RegCreateKeyEx(hkeyProgramManager, szSettings, 0, szProgman, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyPMSettings, NULL);
RegCreateKeyEx(hkeyProgramManager, szRestrict, 0, szProgman, 0,
KEY_READ,
pSecurityAttributes, &hkeyPMRestrict, NULL);
RegCreateKeyEx(hkeyProgramManager, szGroups, 0, szProgman, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyPMGroups, NULL);
}
else {
MyMessageBox(NULL, IDS_APPTITLE, IDS_REGISTRYERROR, NULL, MB_OK | MB_ICONEXCLAMATION);
bErrorMsgDisplayed = TRUE;
}
/* Get the global variable settings out of the INI file. */
if (pszT = GetSettings()) {
/* Get the window coordinates for PROGMAN's main window. */
pT = pszT;
for (j=0; j < 5; j++) {
rgiPos[j] = 0;
while (*pT && !((*pT >= TEXT('0') && *pT <= TEXT('9')) || *pT == TEXT('-')))
pT++;
if (!*pT) {
LocalFree((HANDLE)pszT);
goto DefaultPosition;
}
rgiPos[j] = MyAtoi(pT);
while (*pT && ((*pT >= TEXT('0') && *pT <= TEXT('9')) || *pT == TEXT('-')))
pT++;
}
LocalFree((HANDLE)pszT);
}
else {
DefaultPosition:
/* NOTE: cx = 0 - CW_USEDEFAULT == CW_USEDEFAULT (0x8000) */
rgiPos[0] = rgiPos[1] = CW_USEDEFAULT;
rgiPos[2] = rgiPos[3] = 0;
rgiPos[4] = SW_SHOWNORMAL;
}
if (nCmdShow != SW_SHOWNORMAL)
rgiPos[4] = nCmdShow;
/*
* We don't want an invisible Program Manager!
*/
if (!(rgiPos[4]))
rgiPos[4] = SW_SHOWNORMAL;
/* Create and paint the top-level frame window. */
if (!CreateFrameWindow((PRECT)rgiPos, (WORD)rgiPos[4]))
goto RCFErrExit;
/*
* Will create/open the key Program Groups, parent of all groups.
*/
if (RegCreateKeyEx(HKEY_CURRENT_USER, szProgramGroups, 0, szGroups, 0,
KEY_READ | KEY_WRITE,
pSecurityAttributes, &hkeyProgramGroups, &dwDisposition)) {
if (!bErrorMsgDisplayed) {
MyMessageBox(NULL, IDS_APPTITLE, IDS_REGISTRYERROR, NULL, MB_OK | MB_ICONEXCLAMATION);
}
goto RCFErrExit;
}
if (UseAnsiGroups(dwDisposition)) {
//
// There are no UNICODE groups, so convert the ANSI groups and save
// them as UNICODE groups.
//
bUseANSIGroups = TRUE;
if (RegCreateKeyEx(HKEY_CURRENT_USER, szAnsiProgramGroups, 0, szGroups, 0,
KEY_READ,
pSecurityAttributes, &hkeyAnsiProgramGroups, &dwDisposition)) {
if (!bErrorMsgDisplayed) {
MyMessageBox(NULL, IDS_APPTITLE, IDS_REGISTRYERROR, NULL, MB_OK | MB_ICONEXCLAMATION);
}
goto RCFErrExit;
}
}
/*
* Will create/open the key Program Groups for common groups on the local
* machine.
*/
lstrcpy(szCommonGroupsKey, TEXT("SOFTWARE\\"));
lstrcat(szCommonGroupsKey, szAnsiProgramGroups);
//
// Try opening/creating the common groups key with Write access
//
OpenCommonGroupsKey:
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szCommonGroupsKey, 0, szGroups, 0,
KEY_READ | KEY_WRITE | DELETE,
pAdminSecAttr, &hkeyCommonGroups, &dwDisposition)
== ERROR_SUCCESS) {
if (dwDisposition == REG_CREATED_NEW_KEY) {
//
// need to close and reopen the key to make sure we have the
// right access
//
RegCloseKey(hkeyCommonGroups);
goto OpenCommonGroupsKey;
}
AccessToCommonGroups = TRUE;
} else {
RegOpenKeyEx(HKEY_LOCAL_MACHINE, szCommonGroupsKey, 0, KEY_READ,
&hkeyCommonGroups);
}
//
// If we have Ansi groups in the profile, add a menu item under the Options menu
// to remove the old NT1.0 ANSI groups. This menu item will be deleted we the
// user selects to remove the old groups
//
if (!fNoSave && (bUseANSIGroups || !RegOpenKeyEx(HKEY_CURRENT_USER,
szAnsiProgramGroups,
0,
DELETE | KEY_READ | KEY_WRITE, &hkey))){
HMENU hMenu = GetSubMenu(GetMenu(hwndProgman), 1);
AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
LoadString(hAppInstance, IDS_ANSIGROUPSMENU, szMessage, CharSizeOf(szMessage));
AppendMenu(hMenu, MF_STRING | MF_ENABLED, IDM_ANSIGROUPS, szMessage);
if (hkey) {
RegCloseKey(hkey);
}
}
/* The main frame window's been created, shown, and filled.
* It's time to read the various group files, by enumerating group#
* lines in PROGMAN.INI
*/
LoadAllGroups();
/*
* Restriction key is no longer needed.
*/
if (hkeyPMRestrict) {
RegCloseKey(hkeyPMRestrict);
hkeyPMRestrict = NULL;
}
RCFErrExit:
//
// We've got the Ansi groups, reset this value.
//
bUseANSIGroups = FALSE;
RegCloseKey(hkeyAnsiProgramGroups);
hkeyAnsiProgramGroups = NULL;
ShowCursor(FALSE);
SetCursor(hCursor);
ShowWindow(hwndMDIClient,SW_SHOWNORMAL);
}
/****************************************************************************
*
* FUNCTION: ParseReserved(LPTSTR lpReserved, LPDWORD lpDdeId, LPDWORD lpHotKey)
*
* PURPOSE: Parses the lpReserved field of the StartupInfo structure to
* get the Progman's new instance DDE id and its Hot key.
* The lpReserved field is a string of thee following format:
* "dde.%d,hotkey.%d"
*
* Returns the dde id and hotkey.
*
* COMMENTS: This is to be compatible with Win3.1 by allowing users to
* set a hotkey for Progman, and to allow them to change
* Progman's icon and window title (see SetProgmanProperties in
* pmwprocs.c)
*
*
* HISTORY: 08-28-92 JohanneC Created.
*
****************************************************************************/
void ParseReserved(LPTSTR lpReserved, LPDWORD lpDdeId, LPDWORD lpHotKey)
{
TCHAR *pch, *pchT, ch;
//
// The string will be of the format "dde.%d,hotkey.%d"
//
//
// Get the DDE id.
//
if ((pch = wcsstr(lpReserved, TEXT("dde."))) != NULL) {
pch += 4;
pchT = pch;
while (*pchT >= TEXT('0') && *pchT <= TEXT('9'))
pchT++;
ch = *pchT;
*pchT = 0;
*lpDdeId = MyAtoi(pch);
*pchT = ch;
}
//
// Get the hot key.
//
if ((pch = wcsstr(lpReserved, TEXT("hotkey."))) != NULL) {
pch += 7;
pchT = pch;
while (*pchT >= TEXT('0') && *pchT <= TEXT('9'))
pchT++;
ch = *pchT;
*pchT = 0;
*lpHotKey = MyAtoi(pch);
*pchT = ch;
}
}
/*** IsHandleReallyProgman --
*
*
* BOOL IsHandleReallyProgman (HWND hProgman, LPTSTR lpClassName)
*
* ENTRY - HWND hProgman
*
* EXIT - BOOL TRUE if it is progman
* FALSE if not
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
BOOL IsHandleReallyProgman(HWND hwndProgman)
{
//
// Test to see if we found Progman or Explorer.
//
if ((GetClassLong (hwndProgman, GCL_STYLE) == 0) &&
(GetClassLongPtr (hwndProgman, GCLP_HICON) != 0) &&
(GetClassLongPtr (hwndProgman, GCLP_MENUNAME) != 0)) {
return TRUE;
}
return FALSE;
}
/*** AppInit --
*
*
* BOOL APIENTRY AppInit(HANDLE hInstance, HANDLE hPrevInstance,
* LPTSTR lpszCmdLine, int nCmdShow)
*
* ENTRY - HANDLE hInstance
* HANDLE hPrevInstance
* LPTSTR lpszCmdLine
* int nCmdSHow
*
* EXIT - BOOL xxx - (FALSE == ERROR)
*
* SYNOPSIS - ??
*
* WARNINGS -
* EFFECTS -
*
*/
BOOL APIENTRY AppInit(HANDLE hInstance, LPTSTR lpszCmdLine, int nCmdShow)
{
WORD ret;
WNDCLASS wndClass;
TCHAR szClass[16];
TCHAR szBuffer[MAX_PATH];
LOGFONT lf;
TCHAR szText[MAXMESSAGELEN+1];
STARTUPINFO si;
HWND hwndPrev;
INT nTempCmdShow = nCmdShow;
#ifdef DEBUG_PROGMAN_DDE
{
TCHAR szDebug[300];
wsprintf (szDebug, TEXT("%d PROGMAN: Enter AppInit\r\n"),
GetTickCount());
OutputDebugString(szDebug);
}
#endif
//
// Preserve this instance's module handle.
//
hAppInstance = hInstance;
//
// Specify the shutdown order of the progman process.
// 2 means Porgman will shutdown before taskman (level = 1) and
// ntsd or windbg (level = 0)
//
SetProcessShutdownParameters(2,0);
#ifndef MYDEBUG
LoadString(hAppInstance, IDS_PMCLASS, szClass, CharSizeOf(szClass));
if (hwndPrev = FindWindow(szClass, NULL)) {
bDisableDDE = TRUE; // Only 1 "PROGMAN" should respond to dde
if (IsHandleReallyProgman(hwndPrev)) {
DWORD dwDdeId = 0;
DWORD dwHotKey = 0;
LONG lExiting;
GetStartupInfo(&si);
if (si.lpReserved) {
ParseReserved(si.lpReserved, &dwDdeId, &dwHotKey);
}
PostMessage(hwndPrev, WM_EXECINSTANCE, (WPARAM)dwDdeId, dwHotKey);
//
// Need to check the other progman to see if it is exiting currently.
// If so, then we will continue. GetWindowLong returns 0 as a
// failure case and as the "Not exiting" case (1 if we are exiting),
// so we need to confirm that the last error is also
// zero.
//
lExiting = GetWindowLong (hwndPrev, GWL_EXITING);
if (lExiting != 1) {
return FALSE;
}
}
}
#endif
/*
* Compute general constants.
*/
dyBorder = GetSystemMetrics(SM_CYBORDER);
hItemIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(ITEMICON));
if (!hItemIcon) {
return FALSE;
}
/*
* Load the accelerator table.
*/
hAccel = LoadAccelerators(hAppInstance, (LPTSTR) MAKEINTRESOURCE(PMACCELS));
if (!hAccel)
return FALSE;
cxIcon = GetSystemMetrics(SM_CXICON);
cyIcon = GetSystemMetrics(SM_CYICON);
cxOffset = 2 * GetSystemMetrics(SM_CXBORDER);
cyOffset = 2 * GetSystemMetrics(SM_CYBORDER);
cxIconSpace = cxIcon + 2 * cxOffset;
cyIconSpace = cyIcon + 2 * cyOffset;
SystemParametersInfo(SPI_ICONHORIZONTALSPACING, 0, (PVOID)(LPINT)&cxArrange, FALSE);
SystemParametersInfo(SPI_ICONVERTICALSPACING, 0, (PVOID)(LPINT)&cyArrange, FALSE);
SystemParametersInfo(SPI_GETICONTITLEWRAP, 0, (PVOID)(LPWORD)&bIconTitleWrap, FALSE);
SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), (PVOID)(LPLOGFONT)&lf, FALSE);
// lhb tracks check this out !!!! save this one for later! 1/21/93
//lf.lfCharSet = ANSI_CHARSET ;
//lstrcpy (lf.lfFaceName, TEXT("Lucida Sans Unicode"));
hFontTitle = CreateFontIndirect(&lf);
if (!hFontTitle)
return FALSE;
hIconGlobal = LoadIcon(hAppInstance,(LPTSTR) MAKEINTRESOURCE(WORDICON));
if (!hIconGlobal) {
return FALSE;
}
/*
* Remember the original directory.
*/
GetCurrentDirectory(MAXITEMPATHLEN+1, szOriginalDirectory);
//
// Set Progman's working directory to system32 directory instead of the
// windows directory. johannec 5-4-93 bug 8364
//
//GetWindowsDirectory(szWindowsDirectory, MAXITEMPATHLEN+1);
GetSystemDirectory(szWindowsDirectory, MAXITEMPATHLEN+1);
/*
* Make sure drive letter is upper case.
*/
CharUpperBuff(szWindowsDirectory, 1);
bInNtSetup = FALSE;
if (lpszCmdLine && *lpszCmdLine &&
!lstrcmpi(lpszCmdLine, TEXT("/NTSETUP"))) {
//
// Progman was started from ntsetup.exe, so it can be exited
// without causing NT Windows to exit.
//
bExitWindows = FALSE;
bInNtSetup = TRUE;
*lpszCmdLine = 0;
}
else {
HKEY hkeyWinlogon;
DWORD dwType;
DWORD cbBuffer;
LPTSTR lpt;
/* Check if we should be the shell by looking at shell= line for WInlogon
*/
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"),
0,
KEY_READ,
&hkeyWinlogon) == ERROR_SUCCESS) {
cbBuffer = sizeof(szBuffer);
if (RegQueryValueEx(hkeyWinlogon,
TEXT("Shell"),
0,
&dwType,
(LPBYTE)szBuffer,
&cbBuffer) == ERROR_SUCCESS) {
CharLower(szBuffer);
lpt = szBuffer;
while (lpt = wcsstr(lpt, szProgman)) {
//
// we probably found progman
//
lpt += lstrlen(szProgman);
if (*lpt == TEXT(' ') || *lpt == TEXT('.') || *lpt == TEXT(',') || !*lpt)
bExitWindows = TRUE;
}
}
else {
//
// assume that progman is the shell.
//
bExitWindows = TRUE;
}
RegCloseKey(hkeyWinlogon);
}
else {
//
// assume that progman is the shell.
//
bExitWindows = TRUE;
}
}
if (lpszCmdLine && *lpszCmdLine) {
nCmdShow = SW_SHOWMINNOACTIVE;
}
/*
* call private api to mark task man as a system app. This causes
* it to be killed after all other non-system apps during shutdown.
*/
// MarkProcess(MP_SYSTEMAPP);
/*
* Load these strings now. If we need them later,
* we won't be able to load them at that time.
*/
LoadString(hAppInstance, IDS_OOMEXITTITLE, szOOMExitTitle, CharSizeOf(szOOMExitTitle));
LoadString(hAppInstance, IDS_OOMEXITMSG, szOOMExitMsg, CharSizeOf(szOOMExitMsg));
LoadString(hAppInstance, IDS_PMCLASS, szClass, CharSizeOf(szClass));
SetCurrentDirectory(szWindowsDirectory);
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS); // Bounce errors to us, not fs.
// Set global exit flag.
fExiting = FALSE;
uiHelpMessage = RegisterWindowMessage(TEXT("ShellHelp"));
uiBrowseMessage = RegisterWindowMessage(HELPMSGSTRING);
uiActivateShellWindowMessage = RegisterWindowMessage(TEXT("ACTIVATESHELLWINDOW"));
uiConsoleWindowMessage = RegisterWindowMessage(TEXT("ConsoleProgmanHandle"));
uiSaveSettingsMessage = RegisterWindowMessage(TEXT("SaveSettings")); // for UPEDIT.exe : User Profile Editor
hhkMsgFilter = SetWindowsHook(WH_MSGFILTER, MessageFilter);
if (hhkMsgFilter == 0) {
GetLastError();
}
/*
* Register the Frame window class.
*/
wndClass.lpszClassName = szClass;
wndClass.style = 0;
wndClass.lpfnWndProc = ProgmanWndProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = sizeof(LONG);
wndClass.hInstance = hAppInstance;
wndClass.hIcon = hProgmanIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(PROGMANICON));
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = NULL;
wndClass.lpszMenuName = (LPTSTR) MAKEINTRESOURCE(PROGMANMENU);
if (!RegisterClass(&wndClass))
return(FALSE);
/*
* Register the Program Group window class.
*/
LoadString(hAppInstance, IDS_GROUPCLASS, szClass, 16);
wndClass.lpszClassName = szClass;
wndClass.style = CS_DBLCLKS;
wndClass.lpfnWndProc = GroupWndProc;
/*wndClass.cbClsExtra = 0;*/
wndClass.cbWndExtra = sizeof(PGROUP); /* <== PGROUP */
/*wndClass.hInstance = hAppInstance;*/
wndClass.hIcon = NULL;
/*wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);*/
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndClass.lpszMenuName = NULL;
if (!RegisterClass(&wndClass))
return(FALSE);
{
//
// Set the working set size to 300k.
//
QUOTA_LIMITS QuotaLimits;
NTSTATUS status;
status = NtQueryInformationProcess( NtCurrentProcess(),
ProcessQuotaLimits,
&QuotaLimits,
sizeof(QUOTA_LIMITS),
NULL );
if (NT_SUCCESS(status)) {
QuotaLimits.MinimumWorkingSetSize = 400 * 1024;
QuotaLimits.MaximumWorkingSetSize = 508 * 1024;
NtSetInformationProcess( NtCurrentProcess(),
ProcessQuotaLimits,
&QuotaLimits,
sizeof(QUOTA_LIMITS) );
}
}
hGroupIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(PERSGROUPICON));
hCommonGrpIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(COMMGROUPICON));
if (!RegisterHotKeyClass((HANDLE)hAppInstance))
return FALSE;
RegisterDDEClasses((HANDLE)hAppInstance);
/*
* Initialize the security descriptor for the registry keys that
* will be added to the user's personal profile.
*/
pSecurityAttributes = &SecurityAttributes;
if (!InitializeSecurityAttributes(pSecurityAttributes, TRUE))
pSecurityAttributes = NULL;
/*
* Initialize the security descriptor for the registry keys that
* will be added to the local machine program groups. Only
* Administrators, Power Users and Server Operators
* have all access to these keys, other users have only read access.
*/
pAdminSecAttr = &AdminSecAttr;
if (!InitializeSecurityAttributes(pAdminSecAttr, FALSE))
pAdminSecAttr = NULL;
/*
* Test if the current user is an admin. If so, ignore restrictions
* from the profile.
*/
UserIsAdmin = TestUserForAdmin();
/*
* Read in the Group/Item data structures and create the windows.
*/
#ifdef DEBUG_PROGMAN_DDE
{
TCHAR szDebug[300];
wsprintf (szDebug, TEXT("%d PROGMAN: Before ReadConfigFile\r\n"),
GetTickCount());
OutputDebugString(szDebug);
}
#endif
ReadConfigFile(nCmdShow);
#ifdef DEBUG_PROGMAN_DDE
{
TCHAR szDebug[300];
wsprintf (szDebug, TEXT("%d PROGMAN: After ReadConfigFile\r\n"),
GetTickCount());
OutputDebugString(szDebug);
}
#endif
if (hwndProgman == NULL)
return FALSE;
/*
* NOTE: the nCmdShow stuff from here down is bogus
*
* Do load/run lines, then the command line, then the startup group...
*/
if (bExitWindows)
DoRunEquals(&nCmdShow);
/* Process the Command Line */
if (lpszCmdLine && *lpszCmdLine) {
WORD cbText;
TCHAR szFilename[MAXITEMPATHLEN+1];
lstrcpy(szPathField, lpszCmdLine);
// win foo.bar is done relative to the original directory.
SetCurrentDirectory(szOriginalDirectory);
GetDirectoryFromPath(szPathField, szDirField);
// now kernel converts the DOS cmd line to Ansi for us!
GetFilenameFromPath(szPathField, szFilename);
ret = ExecProgram(szFilename, szDirField, NULL, FALSE, 0, 0, 0);
if (ret) {
szText[0] = TEXT('\'');
lstrcpy(&szText[1],szPathField);
cbText = (WORD)lstrlen(szText);
LoadString(hAppInstance,IDS_CMDLINEERR,&szText[cbText],CharSizeOf(szText)-cbText);
MyMessageBox(NULL, IDS_APPTITLE, ret, szText, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
} else
nCmdShow = SW_SHOWMINNOACTIVE;
SetCurrentDirectory(szWindowsDirectory);
}
/*
* See if we have a startup group last.
*/
#ifndef MYDEBUG
if (bExitWindows || GetAsyncKeyState(VK_CONTROL) < 0)
#endif
HandleStartupGroup(nTempCmdShow);
/*
* create an event for monitoring the ProgramGroups key.
*/
InitializeGroupKeyNotification();
if (bInitialArrange) {
PostMessage(hwndMDIClient, WM_MDIICONARRANGE, 0, 0L);
PostMessage(hwndProgman, WM_COMMAND, IDM_SAVENOW, 0L);
}
#ifdef DEBUG_PROGMAN_DDE
{
TCHAR szDebug[300];
wsprintf (szDebug, TEXT("%d PROGMAN: Leave AppInit\r\n"),
GetTickCount());
OutputDebugString(szDebug);
}
#endif
return TRUE;
}