able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/osshell/progman/pmdlgs.c

4030 lines
120 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* pmdlgs.c - program manager dialog procedures
*
* Copyright (c) 1991, Microsoft Corporation
*
* DESCRIPTION
*
* This file is for support of program manager under NT Windows.
* This file is/was ported from pmdlgs.c (program manager).
*
* MODIFICATION HISTORY
* Initial Version: x/x/90 Author Unknown, since he didn't feel
* like lettings us know...
*
* NT 32b Version: 2/1/91 Jeff Pack
* Intitial port to begin.
*
*
*/
#include "progman.h"
#include "commdlg.h"
#include "io.h"
#include "stdio.h"
#include <vdmapi.h>
#define CBCUSTFILTER 40 // Max size of custom filter.
BOOL fFirstPass; // For IconDlgProc so we can fill the list
// with stuff from progman if the first
// file given has no icons.
BOOL fNewIcon; // Flags if the icon has been explicitely
// set.
extern BOOL bHandleProgramGroupsEvent;
TCHAR szDotPIF[] = TEXT(".pif");
TCHAR szCommdlg[] = TEXT("comdlg32.dll"); // The name of the common dialog.
typedef BOOL (APIENTRY *OPENFILENAME_PROC)(LPOPENFILENAME); // Commdlgs GetOpenFileName routine.
OPENFILENAME_PROC lpfnGOFN;
#define szGetOpenFileName "GetOpenFileNameW"
/* from pmgseg.c */
DWORD PASCAL SizeofGroup(LPGROUPDEF lpgd);
void RemoveBackslashFromKeyName(LPTSTR lpKeyName);
VOID CentreWindow(HWND hwnd);
VOID FreeIconList(HANDLE hIconList, int iKeepIcon);
#define CHECK_BINARY_EVENT_NAME TEXT("CheckBinaryEvent")
#define CHECK_BINARY_ID 1
BOOL bCheckBinaryType;
HANDLE hCheckBinaryEvent;
UINT uiCheckBinaryTimeout;
BOOL bCheckBinaryDirtyFlag;
void CheckBinaryThread (LPVOID);
extern TCHAR szCheckBinaryType[];
extern TCHAR szCheckBinaryTimeout[];
//#ifdef JAPAN
//BOOL CheckPortName(HWND,LPTSTR );
//BOOL PortName(LPTSTR );
//#endif
BOOL APIENTRY InQuotes(LPTSTR sz)
{
if (*sz == TEXT('"') && *(sz + lstrlen(sz) - 1) == TEXT('"')) {
return(TRUE);
}
return(FALSE);
}
//-------------------------------------------------------------------------
// Removes leading and trailing spaces.
VOID APIENTRY RemoveLeadingSpaces(LPTSTR sz)
{
TCHAR *pChr2;
LPTSTR lpTmp;
while(*sz == TEXT(' ')) {
// First Char is a space.
// Move them all down one.
for (pChr2 = sz; *pChr2; pChr2++) {
*pChr2 = *(pChr2+1);
}
}
if (!*sz) {
return;
}
lpTmp = sz + lstrlen(sz) - 1;
while (*lpTmp && *lpTmp == TEXT(' ')) {
*lpTmp-- = TEXT('\0');
}
}
/*** GroupFull - Check for full group. Returns FALSE if the group isn't full.
*
*
* BOOL PASCAL GroupFull(PGROUP pGroup)
*
* ENTRY - PGROUP pGroup
*
* EXIT - BOOL - returns TRUE if group is full
*
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
BOOL PASCAL GroupFull(PGROUP pGroup)
{
WORD i=0;
PITEM pItem;
BOOL ret;
// Count the items in the group.
for (pItem = pGroup->pItems;pItem;pItem = pItem->pNext)
i++;
if (i >= CITEMSMAX) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_TOOMANYITEMS, NULL,
MB_OK | MB_ICONEXCLAMATION|MB_SYSTEMMODAL);
ret = TRUE;
}
else
ret = FALSE;
return ret;
}
/*** ValidPathDrive
*
*
* BOOL APIENTRY ValidPathDrive(LPTSTR lpPath)
*
* ENTRY - LPTSTR lpPath - pointer to path
*
* EXIT - BOOL - returns TRUE if drive path is valid
*
* SYNOPSIS - Check the drive letter of the given path (if it has one).
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
BOOL APIENTRY PASCAL ValidPathDrive(LPTSTR lpPath)
{
int nValid;
TCHAR szDriveRoot[4] = TEXT("?:\\");
// Store first letter of path.
*szDriveRoot = *lpPath;
lpPath = CharNext(lpPath);
if (*lpPath == TEXT(':')) {
//
// It's got a drive letter. Test the drive type with the root directory.
//
nValid = GetDriveType(szDriveRoot);
if ( nValid == 1 || nValid == 0) {
return FALSE;
}
else {
return TRUE;
}
}
return TRUE;
}
/*** StripArgs -- strip everything after a space
*
*
* VOID APIENTRY StripArgs(LPTSTR szCmmdLine)
*
* ENTRY - LPTSTR szCmmdLine - Pointer to command line
* int index
*
*
* EXIT - VOID
*
* SYNOPSIS - This searches for first space, and places NULL there, stripping
* everything after that
*
* WARNINGS -
* EFFECTS -
*
*/
void NEAR PASCAL StripArgs(LPTSTR szCmmdLine)
{
TCHAR *pch;
//
// first skip leading spaces
//
for (pch = szCmmdLine; *pch && *pch == TEXT(' '); pch = CharNext(pch))
;
//
// check if we have a quote, if so look for second quote.
//
if (*pch == TEXT('"')) {
for (pch++; *pch; pch = CharNext(pch)) {
if (*pch == TEXT('"')) {
// Found it, limit string at this point.
pch++;
*pch = TEXT('\0');
break;
}
}
}
else {
// Search forward to find the first space in the cmmd line.
for (; *pch; pch = CharNext(pch)) {
if (*pch == TEXT(' ')) {
// Found it, limit string at this point.
*pch = TEXT('\0');
break;
}
}
}
}
/*** GetPathInfo -- tokenizes string to path/name/extension components
*
*
* VOID APIENTRY GetPathInfo(LPTSTR szPath, LPTSTR *pszLastSlash, LPTSTR *pszExt, DWORD *pich)
*
* ENTRY - LPTSTR szPath - pointer to path stuff
* LPTSTR *pszLastSlash - last slash in path
* LPTSTR *pszExt - pointer to extension
* WORD *plich - index of last slash
*
*
* EXIT - VOID
*
* SYNOPSIS - This searches for first space, and places NULL there, stripping
* everything after that
*
* WARNINGS - BUG BUG , NOT LFN aware!
* EFFECTS -
*
*/
void PASCAL GetPathInfo(LPTSTR szPath,
LPTSTR *pszFileName,
LPTSTR *pszExt,
WORD *pich,
BOOL *pfUnc)
{
TCHAR *pch; // Temp variable.
WORD ich = 0; // Temp.
BOOL InQuotes;
*pszExt = NULL; // If no extension, return NULL.
*pszFileName = szPath; // If no seperate filename component, return path.
*pich = 0;
*pfUnc = FALSE; // Default to not UNC style.
//
// Check if path is in quotes.
//
if (InQuotes = (*szPath == TEXT('"'))) {
szPath++;
}
// Check for UNC style paths.
if (*szPath == TEXT('\\') && *(szPath+1) == TEXT('\\'))
*pfUnc = TRUE;
// Search forward to find the last backslash or colon in the path.
// While we're at it, look for the last dot.
for (pch = szPath; *pch; pch = CharNext(pch)) {
if ((*pch == TEXT(' ')) && (!InQuotes)) {
// Found a space - stop here.
break;
}
if (*pch == TEXT('"')) {
// Found a the second quote - stop here.
pch++;
break;
}
if (*pch == TEXT('\\') || *pch == TEXT(':')) {
// Found it, record ptr to it and it's index.
*pszFileName = pch+1;
*pich = ich + (WORD)1;
}
if (*pch == TEXT('.')) {
// Found a dot.
*pszExt = pch;
}
ich++;
}
/* Check that the last dot is part of the last filename. */
if (*pszExt < *pszFileName)
*pszExt = NULL;
}
/*** TagExtension
*
*
* void APIENTRY TagExtension(PSTR pszPath, UINT cbPath)
*
* ENTRY - PSTR pszPath -
* UINT cbPath - length of path in bytes
*
* EXIT -
*
* SYNOPSIS - Checks a string to see if it has an extension.
* If it doesn't then .exe will be appended.
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
void FAR PASCAL TagExtension(LPTSTR szPath, UINT cbPath)
{
DWORD dummy;
LPTSTR szFileName;
LPTSTR pszExt;
LPTSTR pch;
GetPathInfo(szPath, &szFileName, &pszExt, (WORD*) &dummy, (BOOL*) &dummy);
if (!pszExt && (sizeof(TCHAR) * (lstrlen(szPath) + 5)) < cbPath) {
// No extension, tag on a ".exe"
// but first check if the path is in quotes
pch = szPath + lstrlen(szPath);
if (InQuotes(szPath)) {
*pch = TEXT('\0');
lstrcat(szPath, TEXT(".exe\""));
}
else {
lstrcat(szPath, TEXT(".exe"));
}
}
}
// PIF stuff added 1/9/92
#define PTITLELEN 30
#define PPATHLEN 63
#define PATHMAX 64
#define COMMAX 64
#define PIFEDITMAXPIFL 1024L
typedef struct tagPIFFILE
{
TCHAR Reserved1[2];
TCHAR PTITLE[PTITLELEN];
WORD MAXMEMWORD;
WORD MINMEMWORD;
TCHAR PPATHNAME[PPATHLEN];
TCHAR MSFLAGS;
TCHAR Reserved2;
TCHAR INITIALDIR[PATHMAX];
TCHAR INITIALCOM[COMMAX];
TCHAR SCREENTYPE;
TCHAR SCREENPAGES;
TCHAR INTVECLOW;
TCHAR INTVECHIGH;
TCHAR ROWS;
TCHAR COLUMNS;
TCHAR ROWOFFS;
TCHAR COLOFFS;
WORD SYSTEMMEM;
TCHAR SHAREDPROG[64];
TCHAR SHAREDDATA[64];
TCHAR BEHAVBYTE;
TCHAR SYSTEMFLAGS;
} PIFFILE ;
void NEAR PASCAL GetTheString(LPTSTR pDst, LPTSTR pSrc, UINT iLen)
{
TCHAR cTemp;
/* Ensure there is NULL termination, and then copy the description
*/
cTemp = pSrc[iLen];
pSrc[iLen] = TEXT('\0');
lstrcpy(pDst, pSrc);
pSrc[iLen] = cTemp;
/* Strip off trailing spaces
*/
for (pSrc=NULL; *pDst; pDst=CharNext(pDst))
if (*pDst != TEXT(' '))
pSrc = pDst;
if (pSrc)
*CharNext(pSrc) = TEXT('\0');
}
void NEAR PASCAL GetStuffFromPIF(LPTSTR szPath, LPTSTR szName, LPTSTR szDir)
{
TCHAR szTemp[MAXITEMPATHLEN+1];
DWORD dummy;
LPTSTR pszExt;
LPTSTR pszFileName;
PIFFILE pfTemp;
HANDLE fh;
DWORD dwBytesRead ;
/* Do nothing if the user has filled in these fields
*/
if (*szName && *szDir)
return;
/* Check for the ".pif" extension
*/
lstrcpy(szTemp, szPath);
StripArgs(szTemp);
GetPathInfo(szTemp, &pszFileName, &pszExt, (WORD*) &dummy,
(BOOL*) &dummy);
if (!pszExt || lstrcmpi(pszExt, szDotPIF))
return;
/* There is no real way to verify the PIF format, like the COM format,
* so we are assuming that the extension is our verification
*/
fh = CreateFile(szTemp,
GENERIC_READ,FILE_SHARE_READ, NULL,
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0) ;
if ( fh == INVALID_HANDLE_VALUE)
return;
ReadFile(fh,(LPTSTR)&pfTemp,sizeof(pfTemp),&dwBytesRead,NULL) ;
if (dwBytesRead == sizeof(pfTemp)
&& SetFilePointer(fh, 0L, NULL, FILE_END) < PIFEDITMAXPIFL) {
if (!*szName) {
GetTheString(szName, pfTemp.PTITLE, CharSizeOf(pfTemp.PTITLE));
DoEnvironmentSubst(szName, CharSizeOf(szNameField));
}
if (!*szDir) {
GetTheString(szDir, pfTemp.INITIALDIR, CharSizeOf(pfTemp.INITIALDIR));
}
}
CloseHandle(fh);
}
/*** GetDirectoryFromPath
*
*
* VOID APIENTRY GetDirectoryFromPath (PSTR szFilePath, PSTR szDir)
*
* ENTRY - PSTR szFilePath - Full path to a file.
* PSTR szDir - Directory returned in here, the buffer
* is assumed to be as big as szFilePath.
*
* EXIT -
*
* SYNOPSIS - Given a full path, returns the directory of the file specified
* by the path. If the path is UNC style or the path is just a
* filename then the directory returned will be a NULL.
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
VOID FAR PASCAL GetDirectoryFromPath(LPTSTR szFilePath, LPTSTR szDir)
{
LPTSTR pFileName;
LPTSTR pExt;
WORD ich;
BOOL fUnc;
*szDir = TEXT('\0');
/* Get info about file path. */
GetPathInfo(szFilePath, &pFileName, &pExt, &ich, &fUnc);
/* UNC paths don't (conceptually to Progman) have a directory component. */
if (fUnc)
return;
/* Does it have a directory component ? */
if (pFileName != szFilePath) { // Yep.
/* copy path to temp. */
if (*szFilePath == TEXT('"')) {
szFilePath++;
}
lstrcpy(szDir, szFilePath);
/* check path style. */
if (ich <= 3 && *(szDir+1) == TEXT(':')){
/*
* The path is "c:\foo.c" or "c:foo.c" style.
* Don't remove the last slash/colon, just the filename.
*/
szDir[pFileName-szFilePath] = TEXT('\0');
}
else if (ich == 1) {
/*
* something like "\foo.c"
* Don't remove the last slash/colon, just the filename.
*/
szDir[pFileName-szFilePath] = TEXT('\0');
}
else {
/*
* The filepath is a full normal path.
* Could be something like "..\foo.c" or ".\foo.c" though.
* Stomp on the last slash to get just the path.
*/
szDir[pFileName-szFilePath-1] = TEXT('\0');
}
}
/* else just a filename with no path. */
}
/*** GetFilenameFromPath
*
*
* PSTR APIENTRY GetFilenameFromPath (PSTR szPath)
*
* ENTRY - PSTR szPath -
*
* EXIT - PSTR -
*
* SYNOPSIS - Given a full path returns a ptr to the filename bit.
* Unless it's a UNC style path in which case it returns the path.
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
VOID FAR PASCAL GetFilenameFromPath(LPTSTR szPath, LPTSTR szFilename)
{
DWORD dummy;
LPTSTR pFileName;
LPTSTR pExt;
BOOL fUNC;
GetPathInfo(szPath, &pFileName, &pExt, (WORD*) &dummy, &fUNC);
/* If it's a UNC then the 'filename' part is the whole thing. */
if (fUNC || (szPath == pFileName))
lstrcpy(szFilename, szPath);
else {
if (*szPath == TEXT('"')) {
*szFilename++ = TEXT('"');
}
lstrcpy(szFilename, pFileName);
}
}
/*** HandleDosApps
*
*
* void HandleDosApps (PSTR sz)
*
* ENTRY - PSTR sz - full path sans arguments
*
* EXIT -
*
* SYNOPSIS - Takes a full path to a file and checks if it's a dos app mentioned
* in the pif.inf file.
* If it isn't in the pif.inf file then the the routine returns without
* doing anything.
* If it is then it looks for a pif file with the same base name
* in the same directory.
* If there isn't one then it checks the windows directory.
* If that fails it calls setup to create a new one giving the full
* path to the app in question. - NOT supported in NTSetup.
* The procedure doesn't alter the input string.
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - ported from Windows 3.1
*
*/
void FAR PASCAL HandleDosApps(LPTSTR sz)
{
TCHAR szPath[MAXITEMPATHLEN+1]; // Copy of path so we can stomp all over
// it.
LPTSTR pszFileName; // The file filename part.
LPTSTR pszExt; // The extension.
WORD ich; // Index to filename.
TCHAR szPifSection[32]; // Section in file to search,
TCHAR szPifIniFile[16]; // Ini file to check.
TCHAR szSystemDir[MAXITEMPATHLEN+1]; // Path to system dir.
TCHAR szReturnString[2]; // Mini buffer to check return from GPPS.
//OFSTRUCT of; // OF struct.
TCHAR szExecSetup[MAXITEMPATHLEN+1]; // String used to WinExec setup to
// create the pif for this app.
BOOL dummy; // Dummy variable.
DWORD dwResult ;
TCHAR szPathFieldTemp[MAXITEMPATHLEN+1] ;
LPTSTR FilePart ;
/* Get system dir. */
GetSystemDirectory(szSystemDir, CharSizeOf(szSystemDir));
/* Load ini file info. */
LoadString(hAppInstance, IDS_PIFINIFILE, szPifIniFile, CharSizeOf(szPifIniFile));
LoadString(hAppInstance, IDS_PIFSECTION, szPifSection, CharSizeOf(szPifSection));
LoadString(hAppInstance, IDS_EXECSETUP, szExecSetup, CharSizeOf(szExecSetup));
/* Set up path to inf file. */
if (lstrlen(szSystemDir) > 3) {
lstrcat(szSystemDir, TEXT("\\"));
}
lstrcat(szSystemDir, szPifIniFile);
/* Copy path */
lstrcpy(szPath, sz);
/* Get info about the path. */
GetPathInfo(szPath, &pszFileName, &pszExt, &ich, &dummy);
#ifdef DEBUG
OutputDebugString(TEXT("\n\rLooking in apps.ini for "));
OutputDebugString(pszFileName);
OutputDebugString(TEXT("\n\r"));
#endif
/* Init the default to null. */
szReturnString[0] = TEXT('\0');
/*
* Check in pif.ini file.
* GPPS([section], keyname, szDef, szResultString, cbResString, FileName);
*/
GetPrivateProfileString(szPifSection, pszFileName, szReturnString,
szReturnString, CharSizeOf(szReturnString), szSystemDir);
if (szReturnString[0] == TEXT('\0')) {
/* It's not there. */
#ifdef DEBUG
OutputDebugString(TEXT("App not in inf file"));
OutputDebugString(TEXT("\n\r"));
#endif
return;
}
#ifdef DEBUG
OutputDebugString(TEXT("App in inf file"));
OutputDebugString(TEXT("\n\r"));
#endif
/*
* It's in the pif file, there should be a .pif for it somewhere.
* Change extension to .pif
*/
if (pszExt) {
// copy .pif\0 over the existing extension.
lstrcpy(pszExt, TEXT(".pif"));
}
else {
// cat .pif\0 onto the end.
lstrcat(szPath,TEXT(".pif"));
}
// Check given directory first.
#ifdef DEBUG
OutputDebugString(TEXT("Checking "));
OutputDebugString(szPath);
OutputDebugString(TEXT("\n\r"));
#endif
//SearchPath!!!
dwResult = SearchPath(NULL,szPath,NULL,MAXITEMPATHLEN+1,
szPathFieldTemp,&FilePart) ;
if (dwResult == 0 && GetLastError() != 0x20) {
//if (OpenFile(szPath, &of, OF_EXIST) == (HFILE)-1 && of.nErrCode != 0x20) {
// It's not there.
#ifdef DEBUG
OutputDebugString(TEXT("Checking "));
OutputDebugString(pszFileName);
OutputDebugString(TEXT("\n\r"));
#endif
// Check path.
dwResult = SearchPath(NULL,pszFileName,NULL,MAXITEMPATHLEN+1,
szPathFieldTemp,&FilePart) ;
if (dwResult == 0 && GetLastError() != 0x20) {
//if (! (OpenFile(pszFileName, &of, OF_EXIST) == (HFILE)-1 && of.nErrCode !=0x20) ) {
// Found it on path - winoldapp app will find it,
#ifdef DEBUG
OutputDebugString(TEXT("Found it on path. "));
OutputDebugString(szPathFieldTemp);
OutputDebugString(TEXT("\n\r"));
#endif
}
else {
#ifdef LATER
//
// NT Setup does not support this.
// sunilp said so 9-9-92
//
// It's not anywhere so get setup to create it.
lstrcat(szExecSetup, sz);
// Exec setup - REVIEW silently ignore any errors from win exec.
WinExec(szExecSetup, SW_SHOWNORMAL);
#endif
}
}
}
/*** FixUpNulls -- replace "#" with NULL
*
*
* VOID APIENTRY FixUpNulls(PSTR p)
*
* ENTRY - PSTR p - pointer to string to replaces chars
*
*
* EXIT - VOID
*
* SYNOPSIS - seraches for any "#" chars, and replaces them with NULL
*
*
* WARNINGS -
* EFFECTS -
*
*/
void NEAR PASCAL FixupNulls(LPTSTR p)
{
while (*p) {
if (*p == TEXT('#'))
*p = TEXT('\0');
p++;
}
}
/*** GetFileNameFromBrowser --
*
*
* BOOL APIENTRY GetFileNameFromBrowse(HWND, PSTR, WORD, PSTR, WORD, PSTR)
*
* ENTRY - HWND hwnd - Owner for browse dialog.
* PSTR szFilePath - Path to file
* WORD cbFilePath - Max length of file path buffer, in bytes.
* PSTR szWorkingDir - Working directory
* WORD wId - Id for filters string.
* PSTR szDefExt - Default extension to use if the user doesn't
* specify enter one.
* EXIT - BOOL
*
* SYNOPSIS - Use the common browse dialog to get a filename. The working
* directory of the common dialog will be set to the directory
* part of the file path if it is more than just a filename.
* If the filepath consists of just a filename then the working
* directory will be used. The full path to the selected file will
* be returned in szFilePath.
*
* WARNINGS -
* EFFECTS -
*
*/
BOOL GetFileNameFromBrowse(
HWND hwnd,
LPTSTR szFilePath,
WORD cbFilePath,
LPTSTR szWorkingDir,
WORD wId,
LPTSTR szDefExt)
{
OPENFILENAME ofn; // Structure used to init dialog.
TCHAR szFilters[200];// Filters string.
TCHAR szTitle[80]; // Title for dialog.
TCHAR szBrowserDir[MAXITEMPATHLEN+1]; // Directory to start browsing from.
BOOL fBrowseOK; // Result from browser.
szBrowserDir[0] = TEXT('\0'); // By default use CWD.
// Try to set the directory in the user's home directory.
SetCurrentDirectory(szOriginalDirectory);
// Load filter for the browser.
LoadString(hAppInstance, wId, szFilters, CharSizeOf(szFilters));
// Convert the hashes in the filter into NULLs for the browser.
FixupNulls(szFilters);
// Load the title for the browser.
LoadString(hAppInstance, IDS_BROWSE, szTitle, CharSizeOf(szTitle));
// Set up info for browser. */
GetDirectoryFromPath(szFilePath, szBrowserDir);
if (*szBrowserDir == TEXT('\0') && szWorkingDir) {
lstrcpy(szBrowserDir, szWorkingDir);
}
/*
* Stomp on the file path so that the dialog doesn't
* try to use it to initialise the dialog. The result is put
* in here.
*/
szFilePath[0] = TEXT('\0');
/* Setup info for comm dialog. */
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwnd;
ofn.hInstance = NULL;
ofn.lpstrFilter = szFilters;
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = 1;
ofn.nMaxCustFilter = 0;
ofn.lpstrFile = szFilePath;
ofn.nMaxFile = cbFilePath/sizeof(TCHAR);
ofn.lpstrInitialDir = szBrowserDir;
ofn.lpstrTitle = szTitle;
ofn.Flags = OFN_SHOWHELP | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST |
OFN_NOCHANGEDIR;
ofn.lpfnHook = NULL;
ofn.lpstrDefExt = szDefExt;
ofn.lpstrFileTitle = NULL;
/*
* Get a filename from the dialog...
* Load the commdlg dll.
*/
if (!hCommdlg) {
hCommdlg = LoadLibrary(szCommdlg);
if (!hCommdlg) {
/* Commdlg not available. */
MyMessageBox(hwnd, IDS_APPTITLE, IDS_COMMDLGLOADERR, NULL, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
hCommdlg = NULL;
fBrowseOK = FALSE;
goto ProcExit;
}
else {
lpfnGOFN = (OPENFILENAME_PROC)GetProcAddress(hCommdlg, (LPSTR)szGetOpenFileName);
if (!lpfnGOFN) {
MyMessageBox(hwnd, IDS_APPTITLE, IDS_COMMDLGLOADERR, NULL, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
hCommdlg = NULL;
fBrowseOK = FALSE;
goto ProcExit;
}
}
}
/*
* Commdlg is loaded...
* Call it.
*/
fBrowseOK = (*lpfnGOFN)(&ofn);
ProcExit:
// restore the current dir
SetCurrentDirectory(szWindowsDirectory);
return fBrowseOK;
}
/*** PMHelp --
*
*
* VOID APIENTRY PMHelp(HWND hwnd)
*
* ENTRY - HWND hwnd
*
*
* EXIT - VOID
*
* SYNOPSIS -
*
*
* WARNINGS -
* EFFECTS -
*
*/
void FAR PASCAL PMHelp(HWND hwnd)
{
SetCurrentDirectory(szOriginalDirectory);
if (!WinHelp(hwnd, szProgmanHelp, HELP_CONTEXT, dwContext)) {
MyMessageBox(hwnd, IDS_APPTITLE, IDS_WINHELPERR, NULL, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
}
SetCurrentDirectory(szWindowsDirectory);
}
/*** MyDialogBox --
*
*
* WORD APIENTRY MyDialogBox(WORD idd, HWND hwndParent, FARPROC lpfnDlgProc)
*
* ENTRY - WORD idd
* HWND hwnd
* FARPROC lpfnDlgProc
*
* EXIT - WORD xxx
*
* SYNOPSIS -
*
*
* WARNINGS -
* EFFECTS -
*
*/
WORD APIENTRY MyDialogBox(WORD idd, HWND hwndParent, DLGPROC lpfnDlgProc)
{
WORD wRet;
DWORD dwSave = dwContext;
dwContext = IDH_DLGFIRST + idd;
wRet = (WORD)DialogBox(hAppInstance, (LPTSTR) MAKEINTRESOURCE(idd), hwndParent,
lpfnDlgProc);
dwContext = dwSave;
return(wRet);
}
/*** ChooserDlgProc -- Dialog Procedure for chooser
*
*
*
* ChooserDlgProc(HWND hwnd, UINT uiMsg, DWORD wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY ChooserDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
register WORD wTempSelection;
switch (uiMsg)
{
case WM_INITDIALOG:
if (!AccessToCommonGroups) {
EnableWindow(GetDlgItem(hwnd, IDD_COMMONGROUP), FALSE);
}
wNewSelection = SelectionType();
if (wNewSelection == TYPE_ITEM)
wTempSelection = IDD_ITEM;
else {
wTempSelection = IDD_PERSGROUP;
wNewSelection = TYPE_PERSGROUP;
}
/* Grey out illegal items. */
if (!pCurrentGroup || !GroupCheck(pCurrentGroup)) {
/* Group is RO - can't create new items. */
EnableWindow(GetDlgItem(hwnd,IDD_ITEM), FALSE);
wTempSelection = IDD_PERSGROUP;
wNewSelection = TYPE_PERSGROUP;
}
if (dwEditLevel == 1) {
/* Not allowed to create new groups. */
EnableWindow(GetDlgItem(hwnd,IDD_PERSGROUP), FALSE);
wTempSelection = IDD_ITEM;
wNewSelection = TYPE_ITEM;
}
CheckRadioButton(hwnd, IDD_ITEM, IDD_COMMONGROUP, wTempSelection);
break;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam))
{
case IDD_HELP:
goto DoHelp;
case IDD_ITEM:
if (IsWindowEnabled(GetDlgItem(hwnd,IDD_ITEM)))
wNewSelection = TYPE_ITEM;
break;
case IDD_PERSGROUP:
if (IsWindowEnabled(GetDlgItem(hwnd,IDD_PERSGROUP)))
wNewSelection = TYPE_PERSGROUP;
break;
case IDD_COMMONGROUP:
if (IsWindowEnabled(GetDlgItem(hwnd,IDD_COMMONGROUP)))
wNewSelection = TYPE_COMMONGROUP;
break;
case IDOK:
EndDialog(hwnd, TRUE);
break;
case IDCANCEL:
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** MoveItemDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY MoveItemDlgProc(HWND hwnd, UINT uiMsg, DWORD wParam, LONG lParam)
*
* ENTRY - HWND hwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY MoveItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int iSel;
HWND hwndCB;
register PGROUP pGroup;
hwndCB = GetDlgItem(hwnd, IDD_GROUPS);
switch (uiMsg) {
case WM_INITDIALOG:
{
LPITEMDEF lpid;
LPGROUPDEF lpgd;
int i=0;
lpgd = LockGroup(pCurrentGroup->hwnd);
if (lpgd == 0L)
goto MoveDlgExit;
lpid = ITEM(lpgd,pCurrentGroup->pItems->iItem);
SetDlgItemText(hwnd, IDD_ITEM, (LPTSTR) PTR(lpgd, lpid->pName));
SetDlgItemText(hwnd, IDD_GROUP, (LPTSTR) PTR(lpgd, lpgd->pName));
UnlockGroup(pCurrentGroup->hwnd);
pGroup = pFirstGroup;
while (pGroup) {
if (IsGroupReadOnly(pGroup->lpKey, pGroup->fCommon))
pGroup->fRO = TRUE;
else
pGroup->fRO = FALSE;
if (!pGroup->fRO) {
if (pGroup != pCurrentGroup) {
GetWindowText(pGroup->hwnd, (LPTSTR)szMessage, MAXGROUPNAMELEN + 1);
iSel = (int)SendMessage(hwndCB, CB_ADDSTRING, 0, (LPARAM)(LPTSTR)szMessage);
SendMessage(hwndCB, CB_SETITEMDATA, iSel, (LPARAM)(LPTSTR)pGroup);
i++;
}
}
pGroup = pGroup->pNext;
}
SendMessage(hwndCB, CB_SETCURSEL, 0, 0L);
if (i==0) {
/* No items in list box - Kill the OK button. */
EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
}
break;
}
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDOK:
{
int nIndex;
PGROUP pGTemp;
/* Get the pointer to the selected group. */
nIndex = (int)SendMessage(hwndCB, CB_GETCURSEL, 0, 0L);
pGroup = (PGROUP)SendMessage(hwndCB, CB_GETITEMDATA, nIndex, 0L);
/* Check pointer. */
if (!pGroup)
goto ExitCase;
pGTemp = pCurrentGroup;
/*
* Only do this operation if the user actually had a
* group selected. CB_GETITEMDATA will return -1 if
* an item wasn't selected. This happens if the user
* tries to do a move when there's only one group around.
*/
if (pGroup != (PGROUP)(-1)) {
if (DuplicateItem(pGTemp,pGTemp->pItems,pGroup,NULL)) {
// OK to delete the original.
DeleteItem(pGTemp,pGTemp->pItems);
// It's messy to change the focus when using the keyboard.
// SendMessage(hwndMDIClient, WM_MDIACTIVATE, (WPARAM)(pGroup->hwnd), 0L);
CalcGroupScrolls(pGroup->hwnd);
}
}
ExitCase:
EndDialog(hwnd, TRUE);
break;
}
case IDCANCEL:
MoveDlgExit:
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage)
DoHelp:
{
DWORD dwSave = dwContext;
dwContext = IDH_MOVEDLG;
PMHelp(hwnd);
dwContext = dwSave;
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** CopyItemDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY CopyItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY CopyItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int iSel;
HWND hwndCB;
register PGROUP pGroup;
LPITEMDEF lpid;
LPGROUPDEF lpgd;
hwndCB = GetDlgItem(hwnd, IDD_GROUPS);
switch (uiMsg) {
case WM_INITDIALOG:
{
int i=0;
LoadString(hAppInstance, IDS_COPYDLGTITLE, (LPTSTR)szTitle, MAXTITLELEN);
SetWindowText(hwnd, szTitle);
LoadString(hAppInstance, IDS_COPYDLGTITLE1, (LPTSTR)szTitle, MAXTITLELEN);
SetDlgItemText(hwnd, IDD_MOVETITLE1, szTitle);
lpgd = LockGroup(pCurrentGroup->hwnd);
if (lpgd == 0L)
goto CopyDlgExit;
lpid = ITEM(lpgd,pCurrentGroup->pItems->iItem);
SetDlgItemText(hwnd, IDD_ITEM, (LPTSTR) PTR(lpgd, lpid->pName));
SetDlgItemText(hwnd, IDD_GROUP, (LPTSTR) PTR(lpgd, lpgd->pName));
UnlockGroup(pCurrentGroup->hwnd);
pGroup = pFirstGroup;
while (pGroup) {
if (IsGroupReadOnly(pGroup->lpKey, pGroup->fCommon))
pGroup->fRO = TRUE;
else
pGroup->fRO = FALSE;
if (!pGroup->fRO) {
GetWindowText(pGroup->hwnd, (LPTSTR)szMessage, MAXGROUPNAMELEN + 1);
iSel = (int)SendMessage(hwndCB, CB_ADDSTRING, 0, (LPARAM)(LPTSTR)szMessage);
SendMessage(hwndCB, CB_SETITEMDATA, iSel, (LPARAM)(LPTSTR)pGroup);
i++;
}
pGroup = pGroup->pNext;
}
SendMessage(hwndCB, CB_SETCURSEL, 0, 0L);
if (i==0) {
// No items in list box - Kill the OK button.
EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
}
break;
}
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDOK:
{
int nIndex;
/* Get the pointer to the selected group. */
nIndex = (int)SendMessage(hwndCB, CB_GETCURSEL, 0, 0L);
pGroup = (PGROUP)SendMessage(hwndCB, CB_GETITEMDATA, nIndex, 0L);
/* Check pointer. */
if (!pGroup)
goto ExitCase;
DuplicateItem(pCurrentGroup,pCurrentGroup->pItems,
pGroup,NULL);
// Don't change focus to destination on a copy, very messy if you have a
// group maximised and you want to copy a whole bunch of stuff to another
// group using the keyboard.
// SendMessage(hwndMDIClient, WM_MDIACTIVATE, (WPARAM)(pGroup->hwnd), 0L);
/* Redo scroll bars for destination. */
CalcGroupScrolls(pGroup->hwnd);
/* Redo scroll bars for source. */
CalcGroupScrolls(pCurrentGroup->hwnd);
ExitCase:
EndDialog(hwnd, TRUE);
break;
}
case IDCANCEL:
CopyDlgExit:
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage)
DoHelp:
{
DWORD dwSave = dwContext;
dwContext = IDH_COPYDLG;
PMHelp(hwnd);
dwContext = dwSave;
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** SaveRecentFileList -- Save the list of recently used files
*
* void APIENTRY SaveRecentFileList (HWND hwnd, LPTSTR szCurrentFile);
*
*
*
* ENTRY - HWND hwnd - handle to dialog box.
* LPTSTR szCurrentFile - pointer to selected filename
* WORD idControl - control id
*
* EXIT -
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
*/
void APIENTRY SaveRecentFileList (HWND hwnd, LPTSTR szCurrentFile, WORD idControl)
{
HKEY hKey;
DWORD dwDisp;
DWORD dwDataType, dwMaxFiles=INIT_MAX_FILES, dwMaxFilesSize, dwCount;
TCHAR szFileEntry[20];
DWORD dwEnd=0;
DWORD dwFileNum=0;
DWORD dwDup;
static TCHAR szRecentFilePath[MAXITEMPATHLEN+1];
//
// Open registry key
//
if ( RegCreateKeyEx (HKEY_CURRENT_USER, FILES_KEY, 0, 0,
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE,
NULL, &hKey, &dwDisp) != ERROR_SUCCESS) {
return;
}
//
// Query the max number of files to save first.
//
dwMaxFilesSize = sizeof (DWORD);
RegQueryValueEx (hKey, MAXFILES_ENTRY, NULL, &dwDataType,
(LPBYTE)&dwMaxFiles, &dwMaxFilesSize);
//
// If the user request 0 entries, then exit now.
//
if (dwMaxFiles == 0) {
RegCloseKey (hKey);
return;
}
//
// Find out how many items are in the list box.
//
dwEnd = (DWORD)SendDlgItemMessage (hwnd, idControl, CB_GETCOUNT, 0, 0);
//
// If the max number of items we want to save is less than the
// number of entries, then change the ending point.
//
if (dwMaxFiles < dwEnd) {
dwEnd = dwMaxFiles;
}
//
// Add the first entry (the current file)
//
wsprintf (szFileEntry, FILE_ENTRY, dwFileNum++);
dwMaxFilesSize = MAXITEMPATHLEN+1;
RegSetValueEx (hKey, szFileEntry, 0, REG_SZ, (CONST BYTE *)szCurrentFile,
sizeof (TCHAR) * (lstrlen (szCurrentFile)+1));
//
// Check for a duplicate string.
//
dwDup = (DWORD)SendDlgItemMessage (hwnd, idControl, CB_FINDSTRING,
(WPARAM) -1, (LPARAM) szCurrentFile);
//
// If we already have dwMaxFiles in the list and we don't have any
// duplicates, then we only want to save dwMaxFiles - 1 entries
// (drop the last entry).
//
//
if ( (dwEnd == dwMaxFiles) && (dwDup == CB_ERR) ) {
dwEnd--;
}
//
// Now loop through the remaining entries
//
for (dwCount=0; dwCount < dwEnd; dwCount++) {
//
// Check to see if we are at the duplicate entry. If
// so skip on to the next item.
//
if ((dwDup != CB_ERR) && (dwCount == dwDup)) {
continue;
}
//
// Get an entry out of the listbox.
//
SendDlgItemMessage (hwnd, idControl, CB_GETLBTEXT, (WPARAM) dwCount,
(LPARAM) szRecentFilePath);
//
// If we get a NULL string, break out of the loop.
//
if (!(*szRecentFilePath) || !szRecentFilePath) {
break;
}
//
// Build the entry name
//
wsprintf (szFileEntry, FILE_ENTRY, dwFileNum);
dwMaxFilesSize = MAXITEMPATHLEN+1;
//
// Save the entry
//
RegSetValueEx (hKey, szFileEntry, 0, REG_SZ,(CONST BYTE *) szRecentFilePath,
sizeof (TCHAR) * (lstrlen (szRecentFilePath)+1));
//
// Increment our current file number
//
dwFileNum++;
}
//
// Close the key
//
RegCloseKey (hKey);
}
/*** RunDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY RunDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY RunDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
WORD ret;
TCHAR szFullPath[MAXITEMPATHLEN+1];
HKEY hKey;
DWORD dwDisp;
DWORD dwDataType, dwMaxFiles=INIT_MAX_FILES, dwMaxFilesSize, dwCount;
TCHAR szFileEntry[20];
DWORD dwThreadID;
HANDLE hThread;
DWORD dwBinaryInfo, cbData;
BOOL bDoit;
switch (uiMsg) {
case WM_INITDIALOG:
SendDlgItemMessage(hwnd, IDD_PATH, EM_LIMITTEXT, CharSizeOf(szPathField)-1, 0L);
szPathField[0] =TEXT('\0'); // initialize the path to null
SetDlgItemText(hwnd, IDD_PATH, szPathField);
CheckDlgButton(hwnd, IDD_NEWVDM, 1);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), FALSE);
EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
//
// Load the combobox with recently used files from the registry.
//
// Query the max number of files first.
//
if (RegCreateKeyEx (HKEY_CURRENT_USER, FILES_KEY, 0, 0,
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE,
NULL, &hKey, &dwDisp) == ERROR_SUCCESS) {
if (dwDisp == REG_OPENED_EXISTING_KEY) {
//
// Query the max number of entries
//
dwMaxFilesSize = sizeof (DWORD);
if (RegQueryValueEx (hKey, MAXFILES_ENTRY, NULL, &dwDataType,
(LPBYTE)&dwMaxFiles, &dwMaxFilesSize) == ERROR_SUCCESS) {
//
// Now Query each entry and add it to the list box.
//
for (dwCount=0; dwCount < dwMaxFiles; dwCount++) {
wsprintf (szFileEntry, FILE_ENTRY, dwCount);
dwMaxFilesSize = MAXITEMPATHLEN+1;
if (RegQueryValueEx (hKey, szFileEntry, NULL, &dwDataType,
(LPBYTE) szFullPath, &dwMaxFilesSize) == ERROR_SUCCESS) {
//
// Found an entry. Add it to the combo box.
//
SendDlgItemMessage (hwnd, IDD_PATH,
CB_ADDSTRING, 0,
(LPARAM)szFullPath);
} else {
break;
}
}
}
} else {
//
// We are working with a new key, so we need to
// set the default number of files.
//
RegSetValueEx (hKey, MAXFILES_ENTRY, 0, REG_DWORD,
(CONST BYTE *) &dwMaxFiles, sizeof (DWORD));
}
//
// Close the registry key
//
RegCloseKey (hKey);
}
//
// Set the inital state for the thread which checks the binary
// type.
//
//
// Query if the binary type checking is enabled.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryType, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
bCheckBinaryType = (BOOL) dwBinaryInfo;
} else {
bCheckBinaryType = BINARY_TYPE_DEFAULT;
}
//
// Query the binary type checking timeout value.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryTimeout, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
uiCheckBinaryTimeout = (UINT) dwBinaryInfo;
} else {
uiCheckBinaryTimeout = BINARY_TIMEOUT_DEFAULT;
}
//
// Create the worker thread, and the signal event. If appropriate.
//
if (bCheckBinaryType) {
hCheckBinaryEvent = CreateEvent (NULL, FALSE, FALSE,
CHECK_BINARY_EVENT_NAME);
hThread = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) CheckBinaryThread,
(LPVOID) hwnd, 0, &dwThreadID);
bCheckBinaryDirtyFlag = FALSE;
}
if (!hCheckBinaryEvent || !hThread || !bCheckBinaryType) {
//
// If this statement is true, either we failed to create
// the event, the thread, or binary type checking is disabled.
// In this case, enable the separate memory checkbox, and let
// the user decide on his own.
//
CheckDlgButton(hwnd, IDD_NEWVDM, 0);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), TRUE);
//
// Clean up either item that succeeded
//
if (hCheckBinaryEvent) {
CloseHandle (hCheckBinaryEvent);
}
if (hThread) {
TerminateThread (hThread, 0);
}
//
// Setting this variable to NULL will prevent the second
// thread from trying to check the binary type.
//
hCheckBinaryEvent = NULL;
}
break;
case WM_TIMER:
if (hCheckBinaryEvent && bCheckBinaryDirtyFlag) {
bCheckBinaryDirtyFlag = FALSE;
SetEvent (hCheckBinaryEvent);
}
break;
case MYCBN_SELCHANGE:
if (bCheckBinaryType) {
bCheckBinaryDirtyFlag = TRUE;
SetTimer (hwnd, CHECK_BINARY_ID, uiCheckBinaryTimeout, NULL);
}
bDoit = (GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1) > 0);
EnableWindow(GetDlgItem(hwnd, IDOK), bDoit);
break;
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDD_PATH:
if ((GET_WM_COMMAND_CMD(wParam, lParam) != CBN_EDITCHANGE) &&
(GET_WM_COMMAND_CMD(wParam, lParam) != CBN_SELCHANGE) )
break;
PostMessage (hwnd, MYCBN_SELCHANGE, wParam, lParam);
break;
case IDOK:
{
TCHAR szFilename[MAXITEMPATHLEN+3]; // added chars for ".\"
BOOL bNewVDM;
//
// Run this app in the user's home directory
//
SetCurrentDirectory(szOriginalDirectory);
GetDlgItemText(hwnd, IDD_PATH, szPathField, CharSizeOf(szPathField));
//#ifdef JAPAN
// if (CheckPortName(hwnd,szPathField))
// break;
//#endif
DoEnvironmentSubst(szPathField, CharSizeOf(szPathField));
GetDirectoryFromPath(szPathField, szDirField);
if (*szDirField) {
// Convert path into a .\foo.exe style thing.
lstrcpy(szFilename, TEXT(".\\"));
// Tag the filename and params on to the end of the dot slash.
GetFilenameFromPath(szPathField, szFilename+2);
if (*(szFilename+2) == TEXT('"') ) {
SheRemoveQuotes(szFilename+2);
CheckEscapes(szFilename, CharSizeOf(szFilename));
}
}
else {
GetFilenameFromPath(szPathField, szFilename);
}
bNewVDM = ( IsWindowEnabled(GetDlgItem(hwnd,IDD_NEWVDM)) &&
IsDlgButtonChecked(hwnd, IDD_NEWVDM) );
ret = ExecProgram(szFilename, szDirField, szFilename,
IsDlgButtonChecked(hwnd, IDD_LOAD),
0, 0, bNewVDM);
//
// reset Progman's working directory.
//
SetCurrentDirectory(szWindowsDirectory);
if (ret) {
MyMessageBox(hwnd, IDS_EXECERRTITLE, ret, szPathField, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
} else {
GetDlgItemText(hwnd, IDD_PATH, szPathField, CharSizeOf(szPathField));
SaveRecentFileList (hwnd, szPathField, IDD_PATH);
if (bCheckBinaryType) {
//
// Setting this variable to false, and signaling the event
// will cause the binary checking thread to terminate.
//
bCheckBinaryType = FALSE;
SetEvent (hCheckBinaryEvent);
KillTimer (hwnd, CHECK_BINARY_ID);
}
EndDialog(hwnd, TRUE);
}
break;
}
case IDD_BROWSE:
{
DWORD dwSave = dwContext;
TCHAR szPathField[MAXITEMPATHLEN+1];
dwContext = IDH_RUNBROWSEDLG;
GetDlgItemText(hwnd,IDD_PATH,szPathField,MAXITEMPATHLEN+1);
wParam = GetFileNameFromBrowse(hwnd, szPathField, sizeof(szPathField),
NULL, IDS_PROPERTIESPROGS, TEXT("exe"));
dwContext = dwSave;
if (wParam) {
//
// if filename or directory have spaces, put the path
// between quotes.
//
CheckEscapes(szPathField, MAXITEMPATHLEN+1);
SetDlgItemText(hwnd, IDD_PATH, szPathField);
PostMessage (hwnd, MYCBN_SELCHANGE, wParam, lParam);
// Set default button to OK.
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwnd, IDOK), TRUE);
}
break;
}
case IDCANCEL:
if (bCheckBinaryType) {
//
// Setting this variable to false, and signaling the event
// will cause the binary checking thread to terminate.
//
bCheckBinaryType = FALSE;
SetEvent (hCheckBinaryEvent);
KillTimer (hwnd, CHECK_BINARY_ID);
}
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage || uiMsg == uiBrowseMessage)
DoHelp:
{
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** CheckBinaryThread --
*
*
*
* void CheckBinaryThread (HWND, INT)
*
* ENTRY - HWND hDlg - handle to dialog box.
* INT idCheckBox - Checkbox control id
*
* EXIT - void
*
* 05-18-94 Eric Flo - created
*
*/
void CheckBinaryThread (LPVOID hwndDlg)
{
HWND hwnd = (HWND) hwndDlg;
TCHAR szFullPath[MAXITEMPATHLEN+1];
LPTSTR FilePart ;
DWORD dwBinaryType;
while (bCheckBinaryType) {
WaitForSingleObject (hCheckBinaryEvent, INFINITE);
if (bCheckBinaryType) {
DoEnvironmentSubst(szPathField, CharSizeOf(szPathField));
StripArgs(szPathField);
TagExtension(szPathField, sizeof(szPathField));
SheRemoveQuotes(szPathField);
if (SearchPath(NULL, szPathField, NULL, MAXITEMPATHLEN+1,
szFullPath, &FilePart) &&
GetBinaryType(szFullPath, &dwBinaryType) &&
dwBinaryType == SCS_WOW_BINARY) {
CheckDlgButton(hwnd, IDD_NEWVDM, 0);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), TRUE);
} else {
CheckDlgButton(hwnd, IDD_NEWVDM, 1);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), FALSE);
}
}
}
//
// Close our event handle and exit the thread.
//
CloseHandle (hCheckBinaryEvent);
ExitThread (0);
}
/*** ValidatePath --
*
*
*
* DWORD APIENTRY ValidatePath(HWND, PSTR, PSTR, PSTR)
*
* ENTRY - HWND hDlg - handle to dialog box.
* PSTR szPath - path to item.
* PSTR szDir - path to working directory.
* PSTR szExePath - path to associated exe.
*
* EXIT - DWORD - returns PATH_VALID is path is valid.
* if path is not valid returns PATH_INVALID_OK
* if user hits OK to invalid message box,
* otherwise returns PATH_VALID
*
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
* 08-08-91 JohanneC - updated to Windows 3.1
*
*/
DWORD APIENTRY ValidatePath(HWND hDlg, LPTSTR szPath, LPTSTR szDir, LPTSTR szExePath)
{
int cDrive;
TCHAR szTemp[MAXITEMPATHLEN+1];
int err;
BOOL bOriginalDirectory; // using original directory
DWORD dwRet = PATH_VALID;
BOOL fOK = TRUE; // If the path or the dir check fail
// then don't bother with the assoc check.
/* Check working directory. */
GetCurrentDirectory(MAXITEMPATHLEN, szTemp);
SetCurrentDirectory(szOriginalDirectory);
//CharToOem(szDir, szDir);
/* Allow dir field to be NULL without error. */
if (szDir && *szDir) {
/* Remove leading spaces. */
// RemoveLeadingSpaces(szDir);
SheRemoveQuotes(szDir);
//
// Test if the directory szDir is valid.
//
if (!ValidPathDrive(szDir) || !SetCurrentDirectory(szDir)) {
if (MyMessageBox(hDlg, IDS_BADPATHTITLE, IDS_BADPATHMSG3, NULL, MB_OKCANCEL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION) == IDCANCEL)
goto ExitFalse;
fOK = FALSE;
}
}
//
// Before searching for the executable, check the validity of the szPath
// drive if there's one specified.
//
if (!ValidPathDrive(szPath)) {
if (MyMessageBox(hDlg, IDS_BADPATHTITLE, IDS_BADPATHMSG, szPath, MB_OKCANCEL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION) == IDCANCEL)
goto ExitFalse;
fOK = FALSE;
}
else {
err = (int)((DWORD_PTR)FindExecutable(szPath, szDir, szExePath));
}
/* Check if the file exists if there is no associated exe. */
if (fOK && !*szExePath) {
if (err == SE_ERR_FNF) {
/* File doesn't exist. */
if (MyMessageBox(hDlg, IDS_BADPATHTITLE, IDS_BADPATHMSG, szPath, MB_OKCANCEL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION) == IDCANCEL)
goto ExitFalse;
}
else {
/* Association is bogus. */
if (MyMessageBox(hDlg, IDS_BADPATHTITLE, IDS_BADPATHMSG2, szPath, MB_OKCANCEL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION) == IDCANCEL)
goto ExitFalse;
else
dwRet = PATH_INVALID_OK;
}
}
/* Warn people against using removable or remote paths. */
/* HACK: Hard code UNC path format. Yuck. */
if (szPath[0] == TEXT('\\') && szPath[1] == TEXT('\\'))
goto VPWarnNet;
if (szPath[1] != TEXT(':') ) {
cDrive = (int)((DWORD_PTR)CharUpper((LPTSTR)szTemp[0]));
cDrive = cDrive - (INT)TEXT('A');
bOriginalDirectory = TRUE;
}
else {
cDrive = (int)((DWORD_PTR)CharUpper((LPTSTR)szPath[0]));
cDrive = cDrive - (INT)TEXT('A');
bOriginalDirectory = FALSE;
}
/* Change back to old directory. */
SetCurrentDirectory(szTemp);
//OemToChar(szDir, szDir);
if (IsRemovableDrive(cDrive)) {
if (MyMessageBox(hDlg, IDS_REMOVEPATHTITLE, IDS_PATHWARNING, NULL, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2) == IDNO)
return(PATH_INVALID);
else
return(dwRet);
}
if (IsRemoteDrive(cDrive) && !bOriginalDirectory) {
VPWarnNet:
if (MyMessageBox(hDlg, IDS_NETPATHTITLE, IDS_PATHWARNING, NULL, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2) == IDNO)
return(PATH_INVALID);
}
return(dwRet);
ExitFalse:
// Change back to old directory.
SetCurrentDirectory(szTemp);
//OemToChar(szDir, szDir);
return(PATH_INVALID);
}
/*--------------------------------------------------------------------------*/
/* */
/* BrowseOK() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL NEAR PASCAL BrowseOK(HWND hWnd)
{
DWORD dwSave = dwContext;
TCHAR szPathField[MAXITEMPATHLEN+1];
BOOL ret;
dwContext = IDH_ICONBROWSEDLG;
GetDlgItemText(hWnd, IDD_NAME, szPathField, CharSizeOf(szPathField));
if (GetFileNameFromBrowse(hWnd, szPathField, sizeof(szPathField),
NULL, IDS_CHNGICONPROGS, TEXT("ico"))) {
//
// if filename or directory have spaces, put the path
// between quotes.
//
CheckEscapes(szPathField, MAXITEMPATHLEN+1);
SetDlgItemText(hWnd, IDD_NAME, szPathField);
/* Set default button to OK. */
PostMessage(hWnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hWnd, IDOK), TRUE);
ret = TRUE;
}
else
ret = FALSE;
dwContext = dwSave;
return ret;
}
/*--------------------------------------------------------------------------*/
/* */
/* IconFileExists() - */
/* */
/* Checks if the file exists, if it doesn't it tries tagging on .exe and */
/* if that fails it reports an error. The given path is environment expanded. */
/* If it needs to put up an error box, it changes the cursor back. */
/* Path s assumed to be MAXITEMPATHLEN long. */
/* The main reason for moving this out of the DlgProc was because we're */
/* running out of stack space on the call to the comm dlg. */
/* */
/*--------------------------------------------------------------------------*/
BOOL NEAR PASCAL IconFileExists(HWND hWnd, HCURSOR hCur, LPTSTR szPath)
{
TCHAR szExtended[MAXITEMPATHLEN+1]; // Path with .exe if needed.
BOOL ret = TRUE;
//OFSTRUCT of;
HCURSOR hCursor;
DWORD dwResult ;
TCHAR szPathFieldTemp[MAXITEMPATHLEN+1] ;
LPTSTR FilePart ;
/* Check Files existance. */
DoEnvironmentSubst(szPath, MAXITEMPATHLEN+1);
StripArgs(szPath);
if (*szPath == TEXT('"')) {
SheRemoveQuotes(szPath);
}
lstrcpy(szExtended, szPath);
// use SearchPath instead of MOpenFile(OF_EXIST) to see if a file exists
dwResult = SearchPath(NULL,szPath,NULL,MAXITEMPATHLEN+1,
szPathFieldTemp,&FilePart) ;
if (dwResult == 0 && GetLastError() != 0x20) {
dwResult = SearchPath(NULL,szExtended,TEXT(".exe"),MAXITEMPATHLEN+1,
szPathFieldTemp,&FilePart) ;
if (dwResult == 0 && GetLastError() != 0x20) {
ShowCursor(FALSE);
hCursor = SetCursor(hCur);
/*
* File doesn't exist,tidier if we report the error with the
* unextended path only.
*/
MyMessageBox(hWnd, IDS_NOICONSTITLE, IDS_BADPATHMSG,
szPath, MB_OK | MB_ICONEXCLAMATION);
ret = FALSE;
ShowCursor(TRUE);
SetCursor(hCursor);
}
else {
lstrcpy(szPath, FilePart);
}
}
return ret;
}
/*--------------------------------------------------------------------------*/
/* */
/* IconDlgProc() - */
/* */
/*--------------------------------------------------------------------------*/
/* NOTE: Returns Icon's path in 'szIconPath' and number in 'iDlgIconId'.
*
* INPUT:
* 'szIconPath' has the default icon's path.
* 'iDlgIconId' is set to the default icon's id.
*
* 'szMessage' is used as a temporary variable.
* 'szPathField' is used as a temporary variable.
*
* OUTPUT:
* 'szIconPath' contains the icon's path.
* 'iDlgIconId' contains the icon's resource id.
* 'iDlgIconIndex' contains the icon's index.
*/
INT_PTR APIENTRY IconDlgProc( HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int i;
int iIconSelected = 0;
static HANDLE hIconList = NULL;
static LPMYICONINFO lpIconList;
static INT cIcons;
switch (uiMsg) {
case WM_INITDIALOG:
{
RECT rc;
int cy;
TCHAR szExpanded[MAXITEMPATHLEN+1];
/*
* All this first pass stuff is so that the first time something
* bogus happens (file not found, no icons) we give the user
* a list of icons from progman.
*/
fFirstPass = TRUE;
SetDlgItemText(hwnd, IDD_NAME, (LPTSTR)szIconPath);
SendDlgItemMessage(hwnd, IDD_NAME, EM_LIMITTEXT, MAXITEMPATHLEN, 0L);
SendDlgItemMessage(hwnd,IDD_ICON,LB_SETCOLUMNWIDTH,
GetSystemMetrics(SM_CXICON) + 12,0L);
wParam = (WPARAM)GetDlgItem(hwnd,IDD_ICON);
/* compute the height of the listbox based on icon dimensions
*/
GetClientRect((HWND) wParam,&rc);
cy = GetSystemMetrics(SM_CYICON)
+ GetSystemMetrics(SM_CYHSCROLL)
+ GetSystemMetrics(SM_CYBORDER)
+ 4;
SetWindowPos((HWND)wParam, NULL, 0, 0, rc.right, cy,
SWP_NOMOVE | SWP_NOZORDER);
cy = rc.bottom - cy;
GetWindowRect(hwnd,&rc);
rc.bottom -= rc.top;
rc.right -= rc.left;
/* FE FONTS are taller than US Font */
if ( GetSystemMetrics( SM_DBCSENABLED ) )
rc.bottom = rc.bottom - cy;
SetWindowPos(hwnd,NULL,0,0,rc.right,rc.bottom,SWP_NOMOVE);
wParam = (WPARAM)iDlgIconId;
PutIconsInList:
if (!GetDlgItemText(hwnd, IDD_NAME, (LPTSTR)szPathField, CharSizeOf(szPathField))) {
szPathField[0] = TEXT('\0');
}
wParam = (WPARAM)SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
SendDlgItemMessage(hwnd, IDD_ICON, LB_RESETCONTENT, 0, 0L);
lstrcpy(szExpanded, szPathField);
if (!IconFileExists(hwnd, (HCURSOR)wParam, szExpanded)) {
if (fFirstPass) {
/* Icon File doesn't exist, use progman. */
fFirstPass = FALSE; // Only do this bit once.
GetModuleFileName(hAppInstance, (LPTSTR)szPathField, CharSizeOf(szPathField));
SetDlgItemText(hwnd, IDD_NAME, (LPTSTR)szPathField);
lstrcpy(szExpanded, szPathField);
}
else {
ShowCursor(FALSE);
SetCursor((HCURSOR)wParam);
break;
}
}
if (hIconList) {
FreeIconList(hIconList, -1);
hIconList = NULL;
}
cIcons = (INT)((DWORD_PTR)ExtractIcon(hAppInstance, szExpanded, (UINT)-1));
if (!cIcons) {
if (fFirstPass) {
TCHAR szFilename[MAXITEMPATHLEN+1];
fFirstPass = FALSE; // Only do this bit once.
ShowCursor(FALSE);
SetCursor((HCURSOR)wParam);
MyMessageBox(hwnd, IDS_NOICONSTITLE, IDS_NOICONSMSG1, NULL, MB_OK | MB_ICONEXCLAMATION);
/*
* No icons here - change the path do somewhere where we
* know there are icons.
* Get the path to progman.
*/
GetModuleFileName(hAppInstance, (LPTSTR)szPathField, CharSizeOf(szPathField));
GetFilenameFromPath((LPTSTR)szPathField, szFilename);
SetDlgItemText(hwnd, IDD_NAME, szFilename);
goto PutIconsInList;
}
ShowCursor(FALSE);
SetCursor((HCURSOR) wParam);
MyMessageBox(hwnd, IDS_NOICONSTITLE, IDS_NOICONSMSG, NULL, MB_OK | MB_ICONEXCLAMATION);
break;
}
SendDlgItemMessage(hwnd,IDD_ICON,WM_SETREDRAW,FALSE,0L);
// Get shell.dll to return a list of icons.
if (hIconList = InternalExtractIconList(hAppInstance, szExpanded, &cIcons)) {
if (lpIconList = (LPMYICONINFO)GlobalLock(hIconList)) {
for (i = 0; i < cIcons; i++) {
if (!(lpIconList+i)->hIcon) {
cIcons = i;
break;
}
SendDlgItemMessage(hwnd,IDD_ICON,LB_ADDSTRING,0,
(LPARAM)((lpIconList+i)->hIcon));
if ((lpIconList+i)->iIconId == iDlgIconId)
iIconSelected = i;
}
GlobalUnlock(hIconList);
}
else {
cIcons = 0;
}
}
else {
cIcons = 0;
}
if (SendDlgItemMessage(hwnd,IDD_ICON,LB_SETCURSEL,(WPARAM)iIconSelected,0L)
== LB_ERR)
{
// select the first.
SendDlgItemMessage(hwnd,IDD_ICON,LB_SETCURSEL,0,0L);
}
SendDlgItemMessage(hwnd,IDD_ICON,WM_SETREDRAW,TRUE,0L);
InvalidateRect(GetDlgItem(hwnd,IDD_ICON),NULL,TRUE);
ShowCursor(FALSE);
SetCursor((HCURSOR)wParam);
break;
}
case WM_DRAWITEM:
#define lpdi ((DRAWITEMSTRUCT FAR *)lParam)
if ((HANDLE)lpdi->itemData == (HANDLE)NULL)
break;
InflateRect(&lpdi->rcItem,-4,0);
if (lpdi->itemState & ODS_SELECTED)
SetBkColor(lpdi->hDC,GetSysColor(COLOR_HIGHLIGHT));
else
SetBkColor(lpdi->hDC,GetSysColor(COLOR_WINDOW));
/* repaint the selection state
*/
ExtTextOut(lpdi->hDC,0,0,ETO_OPAQUE,&lpdi->rcItem,NULL,0,NULL);
/* draw the icon
*/
DrawIcon(lpdi->hDC,
lpdi->rcItem.left+2,
lpdi->rcItem.top+2,
(HICON) lpdi->itemData);
/* if it has the focus, draw the focus
*/
#ifdef NOTINUSER
if (lpdi->itemState & ODS_FOCUS)
DrawFocusRect(lpdi->hDC,&lpdi->rcItem);
#endif
#undef lpdi
break;
case WM_MEASUREITEM:
#define lpmi ((MEASUREITEMSTRUCT FAR *)lParam)
lpmi->itemWidth = (WORD)(GetSystemMetrics(SM_CXICON) + 12);
lpmi->itemHeight = (WORD)(GetSystemMetrics(SM_CYICON) + 4);
#undef lpmi
break;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)){
case IDD_HELP:
goto DoHelp;
case IDD_BROWSE:
if (BrowseOK(hwnd))
goto PutIconsInList;
else
break;
case IDD_NAME:
if (!GetDlgItemText(hwnd, IDD_NAME, (LPTSTR)szMessage, MAXITEMPATHLEN+1)) {
szMessage[0] = TEXT('\0');
}
/* Did any thing change since we hit 'Next' last? */
if (lstrcmpi(szMessage, szPathField)) {
SendDlgItemMessage(hwnd,IDD_ICON,LB_SETCURSEL,(WPARAM)-1,0L);
}
break;
case IDD_ICON:
GetDlgItemText(hwnd, IDD_NAME, (LPTSTR)szMessage, MAXITEMPATHLEN+1);
/* Did any thing change since we hit 'Next' last? */
if (lstrcmpi(szMessage, szPathField)) {
lstrcpy(szPathField, szMessage);
wParam = MAKELONG(0, HIWORD(wParam));
goto PutIconsInList;
}
if (GET_WM_COMMAND_CMD(wParam, lParam) != LBN_DBLCLK)
break;
/*** FALL THRU on double click ***/
case IDOK:
if(!GetDlgItemText(hwnd, IDD_NAME, szMessage, MAXITEMPATHLEN+1))
goto PutIconsInList;
//#ifdef JAPAN
// if (CheckPortName(hwnd,szMessage))
// break;
//#endif
/* Did any thing change since we hit 'Next' last? */
if (lstrcmpi(szMessage, szPathField)) {
lstrcpy(szPathField, szMessage);
wParam = MAKELONG(0, HIWORD(wParam));
goto PutIconsInList;
}
else {
iIconSelected = (int)SendDlgItemMessage(hwnd,IDD_ICON,
LB_GETCURSEL,0,0L);
if (iIconSelected < 0)
iIconSelected = 0;
}
if (hDlgIcon)
hIconGlobal = hDlgIcon;
if (cIcons > 0) { /* if there is at least one icon */
hDlgIcon = (lpIconList+iIconSelected)->hIcon;
iDlgIconId = (lpIconList+iIconSelected)->iIconId;
iDlgIconIndex = iIconSelected;
GlobalUnlock(hIconList);
FreeIconList(hIconList,iIconSelected);
hIconList = NULL;
}
else {
hDlgIcon = NULL;
iDlgIconId = 0;
iDlgIconIndex = 0;
}
lstrcpy(szIconPath, szPathField);
EndDialog(hwnd, TRUE);
break;
case IDCANCEL:
if (hIconList) {
FreeIconList(hIconList , -1);
hIconList = NULL;
}
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage || uiMsg == uiBrowseMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
return(TRUE);
}
/*** GetRidOfIcon --
*
*
*
* VOID APIENTRY GetRidOfIcon(VOID)
*
* ENTRY - VOID
*
* EXIT - VOID
*
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
*/
VOID APIENTRY GetRidOfIcon(VOID)
{
if (hDlgIcon && (hDlgIcon != hItemIcon) &&
(hDlgIcon != hProgmanIcon) &&
(hDlgIcon != hGroupIcon))
DestroyIcon(hDlgIcon);
hDlgIcon = NULL;
}
/*** GetCurrentIcon --
*
*
*
* HICON APIENTRY GetCurrentIcon(VOID)
*
* ENTRY - VOID
*
* EXIT - HICON
*
* SYNOPSIS -
*
* WARNINGS -
* EFFECTS -
*
*/
HICON APIENTRY GetCurrentIcon(VOID)
{
TCHAR szExpanded[MAXITEMPATHLEN+1];
HANDLE hModule;
HANDLE h;
PBYTE p;
int cb;
// BUG BUG this was just added and I don't know if it's OK
if (hDlgIcon) {
DestroyIcon(hDlgIcon);
hDlgIcon = NULL;
}
lstrcpy(szExpanded, szIconPath);
DoEnvironmentSubst(szExpanded, CharSizeOf(szExpanded));
StripArgs(szExpanded);
TagExtension(szExpanded, sizeof(szExpanded));
SheRemoveQuotes(szExpanded);
if (hModule = LoadLibrary(szExpanded)) {
h = FindResource(hModule, (LPTSTR) MAKEINTRESOURCE(iDlgIconId), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
if (h) {
cb = SizeofResource(hModule, h);
h = LoadResource(hModule, h);
p = LockResource(h);
hDlgIcon = CreateIconFromResource(p, cb, TRUE, 0x00030000);
UnlockResource(h);
FreeResource(h);
}
FreeLibrary(hModule);
if (hDlgIcon) {
return(hDlgIcon);
}
}
else {
hDlgIcon = ExtractIcon(hAppInstance, szExpanded, (UINT)iDlgIconId);
if (hDlgIcon && hDlgIcon != (HANDLE)1) {
return(hDlgIcon);
}
}
iDlgIconId = 0;
if (hDlgIcon == NULL) {
if (h = FindResource(hAppInstance, (LPTSTR) MAKEINTRESOURCE(ITEMICON), RT_GROUP_ICON)) {
h = LoadResource(hAppInstance, h);
p = LockResource(h);
iDlgIconId = (WORD)LookupIconIdFromDirectory(p, TRUE);
iDlgIconIndex = ITEMICONINDEX;
UnlockResource(h);
FreeResource(h);
}
}
if (hDlgIcon == (HANDLE)1) {
if (h = FindResource(hAppInstance, (LPTSTR) MAKEINTRESOURCE(DOSAPPICON), RT_GROUP_ICON)) {
h = LoadResource(hAppInstance, h);
p = LockResource(h);
iDlgIconId = (WORD)LookupIconIdFromDirectory(p, TRUE);
iDlgIconIndex = DOSAPPICONINDEX;
UnlockResource(h);
FreeResource(h);
}
}
h = FindResource(hAppInstance, (LPTSTR) MAKEINTRESOURCE(iDlgIconId), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
if (h) {
cb = (WORD)SizeofResource(hAppInstance, h);
h = LoadResource(hAppInstance, h);
p = LockResource(h);
hDlgIcon = CreateIconFromResource(p, cb, TRUE, 0x00030000);
UnlockResource(h);
FreeResource(h);
}
if (hModule)
FreeLibrary(hModule);
return(hDlgIcon);
}
/*--------------------------------------------------------------------------*/
/* */
/* CheckHotKeyInUse() - Return of TRUE means no-dup or user says OK anyway.*/
/* fNewItem is TRUE if your about to create a new item, FALSE if your */
/* just editing an old one. */
/* */
/*--------------------------------------------------------------------------*/
BOOL NEAR PASCAL CheckHotKeyInUse(WORD wHotKey, BOOL fNewItem)
{
PGROUP pGroup;
PITEM pItem;
LPGROUPDEF lpgd;
LPITEMDEF lpid;
TCHAR szTemp1[64];
TCHAR szTemp2[MAXMESSAGELEN+1];
int ret;
for (pGroup = pFirstGroup; pGroup; pGroup = pGroup->pNext) {
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
/*
* If we're editing an existing item in then ignore the one
* we're editing (the first item in the current group).
*/
if (!fNewItem && pGroup == pCurrentGroup && pItem == pCurrentGroup->pItems)
continue;
if (wHotKey && (wHotKey == GroupFlag(pGroup,pItem,(WORD)ID_HOTKEY)))
goto Duplicate;
}
}
return TRUE;
Duplicate:
if (!(lpgd = LockGroup(pGroup->hwnd)))
return TRUE; // Crash out without error.
lpid = ITEM(lpgd, pItem->iItem);
if (!LoadString(hAppInstance, IDS_ITEMINGROUP, szTemp1, CharSizeOf(szTemp1)))
return TRUE;
wsprintf(szTemp2, szTemp1, (LPTSTR) PTR(lpgd, lpid->pName), (LPTSTR) PTR(lpgd, lpgd->pName));
ret = MyMessageBox(hwndProgman,
IDS_DUPHOTKEYTTL, IDS_DUPHOTKEYMSG, szTemp2,
MB_OKCANCEL|MB_DEFBUTTON2|MB_ICONEXCLAMATION);
UnlockGroup(pGroup->hwnd);
if (ret == IDOK)
return TRUE;
else
return FALSE;
}
/* NOTE:
* 'szIconPath' has the icon's path.
* 'iDlgIconId' is set to the icon's id.
* 'iDlgIconIndex' is set to the icon's index.
*
* 'szNameField' is used as a temporary variable.
* 'szPathField' is used as a temporary variable.
*/
/*** NewItemDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY NewItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY NewItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
static BOOL bIsWOWApp = FALSE;
DWORD dwThreadID;
HANDLE hThread;
HWND hIcon;
DWORD dwBinaryInfo, cbData, dwDataType;
BOOL bDoit;
switch (uiMsg) {
case WM_INITDIALOG:
if (GroupFull(pCurrentGroup)) {
EndDialog(hwnd, FALSE);
break;
}
SendDlgItemMessage(hwnd, IDD_NAME, EM_LIMITTEXT, MAXITEMNAMELEN, 0L);
SendDlgItemMessage(hwnd, IDD_COMMAND, EM_LIMITTEXT, MAXITEMPATHLEN, 0L);
SendDlgItemMessage(hwnd, IDD_DIR, EM_LIMITTEXT, MAXITEMPATHLEN, 0L);
szNameField[0] = TEXT('\0');
szPathField[0] = TEXT('\0');
szDirField[0] = TEXT('\0');
szIconPath[0] = TEXT('\0');
iDlgIconId = 0;
iDlgIconIndex = 0;
if (hDlgIcon)
DestroyIcon(hDlgIcon);
hDlgIcon = NULL;
EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
EnableWindow(GetDlgItem(hwnd, IDD_ICON), FALSE);
CheckDlgButton(hwnd, IDD_NEWVDM, 1);
EnableWindow(GetDlgItem(hwnd, IDD_NEWVDM), FALSE);
fNewIcon = FALSE;
//
// Set the inital state for the thread which checks the binary
// type.
//
//
// Query if the binary type checking is enabled.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryType, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
bCheckBinaryType = (BOOL) dwBinaryInfo;
} else {
bCheckBinaryType = BINARY_TYPE_DEFAULT;
}
//
// Query the binary type checking timeout value.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryTimeout, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
uiCheckBinaryTimeout = (UINT) dwBinaryInfo;
} else {
uiCheckBinaryTimeout = BINARY_TIMEOUT_DEFAULT;
}
//
// Create the worker thread, and the signal event. If appropriate.
//
if (bCheckBinaryType) {
hCheckBinaryEvent = CreateEvent (NULL, FALSE, FALSE,
CHECK_BINARY_EVENT_NAME);
hThread = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) CheckBinaryThread,
(LPVOID) hwnd, 0, &dwThreadID);
bCheckBinaryDirtyFlag = FALSE;
}
if (!bCheckBinaryType || !hThread || !hCheckBinaryEvent) {
//
// If this statement is true, either binary type checking
// is disabled or we failed to create the event or the thread.
// In this case, enable the separate memory checkbox, and let
// the user decide on his own.
//
CheckDlgButton(hwnd, IDD_NEWVDM, 0);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), TRUE);
//
// Clean up either item that succeeded
//
if (hCheckBinaryEvent) {
CloseHandle (hCheckBinaryEvent);
}
if (hThread) {
TerminateThread (hThread, 0);
}
//
// Setting this variable to NULL will prevent the second
// thread from trying to check the binary type.
//
hCheckBinaryEvent = NULL;
}
break;
case WM_TIMER:
if (hCheckBinaryEvent && bCheckBinaryDirtyFlag) {
bCheckBinaryDirtyFlag = FALSE;
SetEvent (hCheckBinaryEvent);
}
break;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDD_COMMAND:
{
if (GET_WM_COMMAND_CMD(wParam, lParam) != EN_UPDATE)
break;
if (bCheckBinaryType) {
bCheckBinaryDirtyFlag = TRUE;
SetTimer (hwnd, CHECK_BINARY_ID, uiCheckBinaryTimeout, NULL);
}
bDoit = (GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1) > 0);
EnableWindow(GetDlgItem(hwnd, IDOK), bDoit);
if ( (hIcon = GetDlgItem(hwnd, IDD_ICON)) ) {
EnableWindow(hIcon, bDoit);
}
break;
}
case IDD_BROWSE:
{
DWORD dwSave = dwContext;
TCHAR szPathField[MAXITEMPATHLEN+1];
dwContext = IDH_PROPBROWSEDLG;
GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
/* Get PathField using browser dlg. */
if (GetFileNameFromBrowse(hwnd, szPathField, sizeof(szPathField),
szDirField, IDS_PROPERTIESPROGS, TEXT("exe"))) {
// OK.
//
// if filename or directory have spaces, put the path
// between quotes.
//
CheckEscapes(szPathField, MAXITEMPATHLEN+1);
SetDlgItemText(hwnd, IDD_COMMAND, szPathField);
EnableWindow(GetDlgItem(hwnd, IDOK), TRUE);
EnableWindow(GetDlgItem(hwnd, IDD_ICON), TRUE);
/* Set default button to OK. */
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwnd, IDOK), TRUE);
}
dwContext = dwSave;
break;
}
case IDD_ICON:
{
TCHAR szTempField[MAXITEMPATHLEN+1];
GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
//#ifdef JAPAN
// if (CheckPortName(hwnd,szPathField))
// break;
//#endif
GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
// Expand env variables.
DoEnvironmentSubst(szPathField, MAXITEMPATHLEN+1)
&& DoEnvironmentSubst(szDirField, MAXITEMPATHLEN+1);
// Get a full path to the icon.
StripArgs(szPathField);
//
// Change to original directory in case the use entered a
// relative path.
//
SetCurrentDirectory(szOriginalDirectory);
FindExecutable(szPathField, szDirField, szTempField);
SetCurrentDirectory(szWindowsDirectory);
/* Discard the old Icon Path. */
lstrcpy(szIconPath, szTempField);
iDlgIconId = 0;
iDlgIconIndex = 0;
if (fNewIcon = MyDialogBox(ICONDLG, hwnd, IconDlgProc)) {
SendDlgItemMessage(hwnd, IDD_CURICON, STM_SETICON, (WPARAM)hDlgIcon, 0L);
if (hIconGlobal) {
DestroyIcon(hIconGlobal);
hIconGlobal = NULL;
}
}
else { /* Cancel/ESC was selected, reset Icon Path to NULL. */
*szIconPath = TEXT('\0');
iDlgIconId = 0;
iDlgIconIndex = 0;
}
break;
}
case IDOK:
{
WORD hk;
TCHAR szHackField[MAXITEMPATHLEN + 1];
DWORD dwRet;
DWORD dwFlags = CI_ACTIVATE | CI_SET_DOS_FULLSCRN;
if(!GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN + 1)) {
szPathField[0] = TEXT('\0');
break;
}
//RemoveLeadingSpaces(szPathField);
hk = (WORD) SendDlgItemMessage(hwnd,IDD_HOTKEY, WM_GETHOTKEY,0,0L);
if (!CheckHotKeyInUse(hk, TRUE))
break;
GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
//RemoveLeadingSpaces(szDirField)
/* Expand env variables. */
DoEnvironmentSubst(szPathField, MAXITEMPATHLEN+1);
DoEnvironmentSubst(szDirField, MAXITEMPATHLEN+1);
/* Now remove the arguments from the command line. */
StripArgs(szPathField);
dwRet = ValidatePath(hwnd, szPathField, szDirField, szHackField);
if (dwRet == PATH_INVALID) {
break;
}
else if (dwRet == PATH_INVALID_OK) {
dwFlags |= CI_NO_ASSOCIATION;
}
/* Special case DOS apps. */
HandleDosApps(szHackField);
/* If the user hasn't supplied a description then build one. */
if (!GetDlgItemText(hwnd, IDD_NAME, szNameField, MAXITEMNAMELEN+1)) {
szNameField[0] = TEXT('\0');
}
/* Get the original command line with arguments. */
GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
//#ifdef JAPAN
// if (CheckPortName(hwnd,szPathField))
// break;
//#endif
/* Get original (unexpanded) directory. */
if (!GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1)) {
szDirField[0] = TEXT('\0');
} else {
LPTSTR lpEnd;
TCHAR chT;
// Remove trailing spaces (inside of quote if applicable)
lpEnd = szDirField + lstrlen (szDirField) - 1;
chT = *lpEnd;
if ( (chT == TEXT('\"')) || (chT == TEXT(' ')) ) {
// MarkTa fix for spaces at the end of a filename
// Remove the spaces by moving the last character forward.
while (*(lpEnd-1) == TEXT(' '))
lpEnd--;
*lpEnd = chT;
*(lpEnd+1) = TEXT ('\0');
// In case the character we saved was a space, we can
// NULL terminate it because now we know the next character
// to the left is valid, and the character to the right is
// already NULL.
if (*lpEnd == TEXT(' '))
*lpEnd = TEXT('\0');
}
}
GetStuffFromPIF(szPathField, szNameField, szDirField);
if (!*szNameField) {
BuildDescription(szNameField, szPathField);
}
/* If there's no default directory then add one. */
if (!*szDirField) {
GetDirectoryFromPath(szPathField, szDirField);
}
if (!InQuotes(szDirField)) {
//
// if szDirField needs quotes and the work dir is too
// long than we need to truncate it.
//
if (lstrlen(szDirField) >= MAXITEMPATHLEN-2) {
TCHAR chT;
chT = szDirField[MAXITEMPATHLEN-2];
szDirField[MAXITEMPATHLEN-2] = 0;
CheckEscapes(szDirField, MAXITEMPATHLEN+1);
if (*szDirField != TEXT('"')) {
szDirField[MAXITEMPATHLEN-2] = chT;
}
}
else {
CheckEscapes(szDirField, MAXITEMPATHLEN+1);
}
}
if (IsWindowEnabled(GetDlgItem(hwnd, IDD_NEWVDM)) &&
IsDlgButtonChecked(hwnd, IDD_NEWVDM)) {
dwFlags |= CI_SEPARATE_VDM;
}
/* Create new item using UNICODE strings. */
CreateNewItem(pCurrentGroup->hwnd,
szNameField,
szPathField,
szIconPath,
szDirField,
hk,
(BOOL)IsDlgButtonChecked(hwnd, IDD_LOAD),
(WORD)iDlgIconId,
(WORD)iDlgIconIndex,
hDlgIcon,
NULL,
dwFlags);
}
// Update scroll bars for new item
if ((bAutoArrange) && (!bAutoArranging))
ArrangeItems(pCurrentGroup->hwnd);
else if (!bAutoArranging)
CalcGroupScrolls(pCurrentGroup->hwnd);
// fall through...
case IDCANCEL:
if (bCheckBinaryType) {
//
// Setting this variable to false, and signaling the event
// will cause the binary checking thread to terminate.
//
bCheckBinaryType = FALSE;
SetEvent (hCheckBinaryEvent);
KillTimer (hwnd, CHECK_BINARY_ID);
}
EndDialog(hwnd, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
GetRidOfIcon();
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage || uiMsg == uiBrowseMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** NewGroupDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY NewGroupDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* DWORD wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY NewGroupDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
BOOL bDoit;
HWND hwndGroup;
switch (uiMsg) {
case WM_INITDIALOG:
if (wNewSelection == TYPE_COMMONGROUP) {
TCHAR szCommonGroupTitle[64];
if (LoadString(hAppInstance, IDS_COMMONGROUPPROP,
szCommonGroupTitle, CharSizeOf(szCommonGroupTitle))) {
SetWindowText(hwnd, szCommonGroupTitle);
}
}
SendDlgItemMessage(hwnd, IDD_NAME, EM_LIMITTEXT, MAXGROUPNAMELEN, 0L);
break;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
HCURSOR hCursor;
case IDD_NAME:
case IDD_PATH:
/* Allow OK if either of the two fields have anything in them. */
bDoit = (GetDlgItemText(hwnd, IDD_NAME, szPathField, CharSizeOf(szPathField)) > 0);
EnableWindow(GetDlgItem(hwnd, IDOK), bDoit);
break;
case IDD_HELP:
goto DoHelp;
case IDOK:
if(!GetDlgItemText(hwnd, IDD_NAME, szNameField, MAXITEMNAMELEN + 1)) {
szNameField[0] = TEXT('\0');
break;
}
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
hwndGroup = CreateNewGroup(szNameField, (wNewSelection == TYPE_COMMONGROUP));
ShowCursor(FALSE);
SetCursor(hCursor);
if (hwndGroup) {
EndDialog(hwnd, TRUE);
}
break;
case IDCANCEL:
EndDialog(hwnd, FALSE);
break;
default:
return FALSE;
}
break;
default:
if (uiMsg == uiHelpMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else {
return FALSE;
}
}
return TRUE;
}
/*--------------------------------------------------------------------------*/
/* */
/* EditBrowseOK() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL NEAR PASCAL EditBrowseOK(HWND hDlg)
{
DWORD dwSave = dwContext;
TCHAR szPathField[MAXITEMPATHLEN+1];
BOOL ret;
dwContext = IDH_PROPBROWSEDLG;
GetDlgItemText(hDlg, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
GetDlgItemText(hDlg, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
/* Get PathField using browser dlg. */
if (GetFileNameFromBrowse(hDlg, szPathField,sizeof(szPathField) ,
szDirField, IDS_PROPERTIESPROGS, TEXT("exe"))) {
/* OK. */
//
// if filename or directory have spaces, put the path
// between quotes.
//
CheckEscapes(szPathField, MAXITEMPATHLEN+1);
SetDlgItemText(hDlg, IDD_COMMAND, szPathField);
EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
EnableWindow(GetDlgItem(hDlg, IDD_ICON), TRUE);
/* Set default button to OK. */
PostMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg, IDOK), TRUE);
ret = TRUE;
}
else
ret = FALSE;
dwContext = dwSave;
return ret;
}
/*** EditItemDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY EditItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hhwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
/* NOTE:
* 'szIconPath' has the icon's path.
* 'iDlgIconId' is set to the icon's id.
* 'iDlgIconIndex' is set to the icon's index.
*
* 'szNameField' is used as a temporary variable.
* 'szPathField' is used as a temporary variable.
*/
INT_PTR APIENTRY EditItemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
LPITEMDEF lpid;
LPGROUPDEF lpgd;
TCHAR szTempField[MAXITEMPATHLEN + 1];
DWORD dwFlags = CI_ACTIVATE;
DWORD dwBinaryType;
TCHAR szFullPath[MAXITEMPATHLEN+1] ;
LPTSTR FilePart ;
static BOOL bIsWOWApp = FALSE;
static WORD wHotKey;
static TCHAR szDescription[MAXITEMNAMELEN + 1];
DWORD dwThreadID;
HANDLE hThread;
HWND hIcon;
DWORD dwBinaryInfo, cbData, dwDataType;
BOOL bDoit;
switch (uiMsg) {
case WM_INITDIALOG:
/*
* Get current item information.
*/
pActiveGroup = pCurrentGroup;
lpgd = (LPGROUPDEF)GlobalLock(pActiveGroup->hGroup);
lpid = LockItem(pActiveGroup,pActiveGroup->pItems);
if (lpid == 0L)
goto EditDlgExit;
fNewIcon = FALSE;
SendDlgItemMessage(hwnd, IDD_NAME, EM_LIMITTEXT, MAXITEMNAMELEN, 0L);
SetDlgItemText(hwnd, IDD_NAME, (LPTSTR) PTR(lpgd, lpid->pName));
lstrcpy(szDescription, (LPTSTR) PTR(lpgd, lpid->pName));
GetItemCommand(pActiveGroup, pActiveGroup->pItems, szPathField, szDirField);
/* Keep a copy of what the old item was refering to.
* A full expanded OEM path to the executable
*/
DoEnvironmentSubst(szPathField, MAXITEMPATHLEN+1);
DoEnvironmentSubst(szDirField, MAXITEMPATHLEN+1);
StripArgs(szPathField);
// Find exe will toast on ansi strings.
//
// Change to original Directory in case the user entered a relative path
//
//
SetCurrentDirectory(szOriginalDirectory);
FindExecutable(szPathField, szDirField, szNameField);
SetCurrentDirectory(szWindowsDirectory);
lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
if (!*szIconPath) {
/* use default icon path */
lstrcpy(szIconPath, szNameField);
}
iDlgIconId = lpid->iIcon;
iDlgIconIndex = lpid->wIconIndex;
TagExtension(szPathField, sizeof(szPathField));
SheRemoveQuotes (szPathField);
if (SearchPath(NULL,
szPathField,
NULL,
MAXITEMPATHLEN+1,
szFullPath,
&FilePart) &&
GetBinaryType(szFullPath, &dwBinaryType) &&
dwBinaryType == SCS_WOW_BINARY) {
bIsWOWApp = TRUE;
if (GroupFlag(pActiveGroup,pActiveGroup->pItems,(WORD)ID_NEWVDM)) {
CheckDlgButton(hwnd, IDD_NEWVDM, 1);
}
}
else {
CheckDlgButton(hwnd, IDD_NEWVDM, 1);
EnableWindow(GetDlgItem(hwnd, IDD_NEWVDM), FALSE);
}
/* Re-get the fields so that the dlg is initialized with
* the environment variables intact.
*/
GetItemCommand(pActiveGroup,pActiveGroup->pItems,szPathField,szDirField);
SendDlgItemMessage(hwnd, IDD_COMMAND, EM_LIMITTEXT, MAXITEMPATHLEN, 0L);
SetDlgItemText(hwnd, IDD_COMMAND, szPathField);
SendDlgItemMessage(hwnd, IDD_DIR, EM_LIMITTEXT, MAXITEMPATHLEN, 0L);
SetDlgItemText(hwnd, IDD_DIR, szDirField);
if (GroupFlag(pActiveGroup,pActiveGroup->pItems,(WORD)ID_MINIMIZE))
CheckDlgButton(hwnd, IDD_LOAD, TRUE);
SendDlgItemMessage(hwnd,IDD_HOTKEY,WM_SETHOTKEY,
(WPARAM)GroupFlag(pActiveGroup,pActiveGroup->pItems,(WORD)ID_HOTKEY),
0L);
GetCurrentIcon(); // use szIconPath from above
GlobalUnlock(pActiveGroup->hGroup);
UnlockGroup(pActiveGroup->hwnd);
SendDlgItemMessage(hwnd, IDD_CURICON, STM_SETICON, (WPARAM)hDlgIcon, 0L);
if (pActiveGroup->fRO || dwEditLevel >= 4) {
/* if readonly, we can only view... */
EnableWindow(GetDlgItem(hwnd,IDOK), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_ICON), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_HOTKEY), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_NAME), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_DIR), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_LOAD), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_COMMAND), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_BROWSE), FALSE);
}
else if (dwEditLevel == 3) {
EnableWindow(GetDlgItem(hwnd,IDD_COMMAND), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_BROWSE), FALSE);
}
//
// Set the inital state for the thread which checks the binary
// type.
//
//
// Query if the binary type checking is enabled.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryType, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
bCheckBinaryType = (BOOL) dwBinaryInfo;
} else {
bCheckBinaryType = BINARY_TYPE_DEFAULT;
}
//
// Query the binary type checking timeout value.
//
cbData = sizeof(dwBinaryInfo);
if (RegQueryValueEx(hkeyPMSettings, szCheckBinaryTimeout, 0, &dwDataType,
(LPBYTE)&dwBinaryInfo, &cbData) == ERROR_SUCCESS) {
uiCheckBinaryTimeout = (UINT) dwBinaryInfo;
} else {
uiCheckBinaryTimeout = BINARY_TIMEOUT_DEFAULT;
}
//
// Create the worker thread, and the signal event. If appropriate.
//
if (bCheckBinaryType) {
hCheckBinaryEvent = CreateEvent (NULL, FALSE, FALSE,
CHECK_BINARY_EVENT_NAME);
hThread = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) CheckBinaryThread,
(LPVOID) hwnd, 0, &dwThreadID);
bCheckBinaryDirtyFlag = FALSE;
}
if (!hCheckBinaryEvent || !hThread || !bCheckBinaryType) {
//
// If this statement is true, either we failed to create
// the event, the thread, or binary type checking is disabled.
// In this case, enable the separate memory checkbox, and let
// the user decide on his own.
//
CheckDlgButton(hwnd, IDD_NEWVDM, 0);
EnableWindow(GetDlgItem(hwnd,IDD_NEWVDM), TRUE);
//
// Clean up either item that succeeded
//
if (hCheckBinaryEvent) {
CloseHandle (hCheckBinaryEvent);
}
if (hThread) {
TerminateThread (hThread, 0);
}
//
// Setting this variable to NULL will prevent the second
// thread from trying to check the binary type.
//
hCheckBinaryEvent = NULL;
}
break;
case WM_TIMER:
if (hCheckBinaryEvent && bCheckBinaryDirtyFlag) {
bCheckBinaryDirtyFlag = FALSE;
SetEvent (hCheckBinaryEvent);
}
break;
case WM_COMMAND:
{
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDD_COMMAND:
{
if (GET_WM_COMMAND_CMD(wParam, lParam) != EN_UPDATE)
break;
if (bCheckBinaryType) {
bCheckBinaryDirtyFlag = TRUE;
SetTimer (hwnd, CHECK_BINARY_ID, uiCheckBinaryTimeout, NULL);
}
bDoit = (GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1) > 0);
EnableWindow(GetDlgItem(hwnd, IDOK), bDoit);
if ( (hIcon = GetDlgItem(hwnd, IDD_ICON)) ) {
EnableWindow(hIcon, bDoit);
}
break;
}
case IDD_BROWSE:
EditBrowseOK(hwnd);
break;
case IDD_ICON:
{
LPITEMDEF lpid;
if (!GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1))
break;
//#ifdef JAPAN
// if (CheckPortName(hwnd,szPathField))
// break;
//#endif
GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
/* Expand env variables. */
DoEnvironmentSubst(szPathField, MAXITEMPATHLEN+1)
&& DoEnvironmentSubst(szDirField, MAXITEMPATHLEN+1);
/* Get a full path to the icon. */
StripArgs(szPathField);
SetCurrentDirectory(szOriginalDirectory);
FindExecutable(szPathField, szDirField, szTempField);
SetCurrentDirectory(szWindowsDirectory);
/*
* If the icon path hasn't been explicitly set then
* use a default one.
*/
if (!fNewIcon) {
/* Has the items path been changed? */
if (lstrcmpi(szNameField, szTempField)) {
/* Yup, it's changed, discard the old Icon Path. */
lstrcpy(szIconPath, szTempField);
iDlgIconId = 0;
iDlgIconIndex = 0;
}
else {
/* The path hasn't changed so use the old icon path. */
lpid = LockItem(pActiveGroup,pActiveGroup->pItems);
// BUG BUG! should have LockItem unlock the group
// before returning. JohanneC 7/5/91
UnlockGroup(pActiveGroup->hwnd);
if (lpid == 0L)
goto EditDlgExit;
lpgd = LockGroup(pActiveGroup->hwnd);
lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
UnlockGroup(pActiveGroup->hwnd);
}
}
/* Check if we have a default icon. */
if (!*szIconPath) {
/* Invalid path, use the executable's path. */
lstrcpy(szIconPath, szTempField);
}
if (fNewIcon = MyDialogBox(ICONDLG, hwnd, IconDlgProc)) {
// Set default button to OK.
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwnd, IDOK), TRUE);
SendDlgItemMessage(hwnd, IDD_CURICON, STM_SETICON, (WPARAM)hDlgIcon, 0L);
if (hIconGlobal) {
DestroyIcon(hIconGlobal);
hIconGlobal = NULL;
}
}
else {
/* They hit cancel, get the old path back. */
lpid = LockItem(pActiveGroup,pActiveGroup->pItems);
// BUG BUG! should have LockItem unlock the group
// before returning. JohanneC 7/5/91
UnlockGroup(pActiveGroup->hwnd);
if (lpid == 0L)
goto EditDlgExit;
lpgd = LockGroup(pActiveGroup->hwnd);
lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
UnlockGroup(pActiveGroup->hwnd);
}
break;
}
case IDOK:
{
RECT rc;
WORD hk;
BOOL bARTmp; //AutoArrangeFlag
BOOL fNewItem = FALSE;
DWORD dwRet;
hk = (WORD) SendDlgItemMessage(hwnd,IDD_HOTKEY, WM_GETHOTKEY,0,0L);
if (!CheckHotKeyInUse(hk, FALSE))
break;
/* Get the non-parm part of the new command line. */
GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
//#ifdef JAPAN
// if (CheckPortName(hwnd,szPathField))
// break;
//#endif
GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1);
/* Expand env variables. */
DoEnvironmentSubst(szPathField, MAXITEMPATHLEN+1)
&& DoEnvironmentSubst(szDirField, MAXITEMPATHLEN+1);
/* Remove arguments before validating path. */
StripArgs(szPathField);
dwRet = ValidatePath(hwnd, szPathField, szDirField, szTempField);
if (dwRet == PATH_INVALID) {
break;
}
else if (dwRet == PATH_INVALID_OK) {
dwFlags |= CI_NO_ASSOCIATION;
}
if (bCheckBinaryType) {
//
// Setting this variable to false, and signaling the event
// will cause the binary checking thread to terminate.
//
bCheckBinaryType = FALSE;
SetEvent (hCheckBinaryEvent);
KillTimer (hwnd, CHECK_BINARY_ID);
}
EndDialog(hwnd, TRUE);
/*
* If the item refers to a different exe then we need
* to update a few things.
*/
if (lstrcmpi(szNameField, szTempField)) {
/* Things have changed. */
if (!fNewIcon) {
/*
* The icon hasn't been expicitely set.
* So use the new exe path for
* the icon.
*/
// lstrcpy(szIconPath, szPathField);
szIconPath[0] = TEXT('\0'); /* reset icon path */
iDlgIconId = 0;
iDlgIconIndex = 0;
}
fNewItem = TRUE;
/* Check if the new thing is a DOS app. */
HandleDosApps(szTempField);
}
else {
/* test if icon has changed. If not, reset iconpath.*/
if (!fNewIcon) {
lpgd = LockGroup(pActiveGroup->hwnd);
lpid = LockItem(pActiveGroup,pActiveGroup->pItems);
lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
// LockItem locks the group, must unlock
// after returning. JohanneC
UnlockGroup(pActiveGroup->hwnd);
UnlockGroup(pActiveGroup->hwnd);
}
}
CopyRect(&rc, &pActiveGroup->pItems->rcIcon);
/* Re-get the new command line. */
GetDlgItemText(hwnd, IDD_COMMAND, szPathField, MAXITEMPATHLEN+1);
/* Use unexpanded path for the item info. */
if (!GetDlgItemText(hwnd, IDD_DIR, szDirField, MAXITEMPATHLEN+1)) {
szDirField[0] = TEXT('\0');
} else {
LPTSTR lpEnd;
TCHAR chT;
// Remove trailing spaces (inside of quote if applicable)
lpEnd = szDirField + lstrlen (szDirField) - 1;
chT = *lpEnd;
if ( (chT == TEXT('\"')) || (chT == TEXT(' ')) ) {
// MarkTa fix for spaces at the end of a filename
// Remove the spaces by moving the last character forward.
while (*(lpEnd-1) == TEXT(' '))
lpEnd--;
*lpEnd = chT;
*(lpEnd+1) = TEXT ('\0');
// In case the character we saved was a space, we can
// NULL terminate it because now we know the next character
// to the left is valid, and the character to the right is
// already NULL.
if (*lpEnd == TEXT(' '))
*lpEnd = TEXT('\0');
}
}
if (!InQuotes(szDirField)) {
//
// if szDirField needs quotes and the work dir is too
// long than we need to truncate it.
//
if (lstrlen(szDirField) >= MAXITEMPATHLEN-2) {
TCHAR chT;
chT = szDirField[MAXITEMPATHLEN-2];
szDirField[MAXITEMPATHLEN-2] = 0;
CheckEscapes(szDirField, MAXITEMPATHLEN+1);
if (*szDirField != TEXT('"')) {
szDirField[MAXITEMPATHLEN-2] = chT;
}
}
else {
CheckEscapes(szDirField, MAXITEMPATHLEN+1);
}
}
/* Check if the Desc line has been filled. */
if (!GetDlgItemText(hwnd, IDD_NAME, szNameField, MAXITEMNAMELEN+1)) {
BuildDescription(szNameField, szPathField);
SetDlgItemText(hwnd, IDD_NAME, szNameField);
}
/*
* Stop ARing for a mo because we're going to do a
* delete and the an add and there's no point in doing
* the auto arrange stuff twice.
*/
bARTmp = bAutoArrange;
bAutoArrange = FALSE;
DeleteItem(pActiveGroup,pActiveGroup->pItems);
bAutoArrange = bARTmp;
if (fNewItem || lstrcmpi(szDescription, szNameField)) {
dwFlags |= CI_SET_DOS_FULLSCRN;
}
if (IsWindowEnabled(GetDlgItem(hwnd, IDD_NEWVDM)) &&
IsDlgButtonChecked(hwnd, IDD_NEWVDM)) {
dwFlags |= CI_SEPARATE_VDM;
}
CreateNewItem(pActiveGroup->hwnd,
szNameField,
szPathField,
szIconPath,
szDirField,
hk,
(BOOL)IsDlgButtonChecked(hwnd, IDD_LOAD),
(WORD)iDlgIconId,
(WORD)iDlgIconIndex,
hDlgIcon,
(LPPOINT)&rc.left,
dwFlags);
GetRidOfIcon();
pActiveGroup = NULL;
break;
}
case IDCANCEL:
EditDlgExit:
if (bCheckBinaryType) {
//
// Setting this variable to false, and signaling the event
// will cause the binary checking thread to terminate.
//
bCheckBinaryType = FALSE;
SetEvent (hCheckBinaryEvent);
KillTimer (hwnd, CHECK_BINARY_ID);
}
pActiveGroup = NULL;
EndDialog(hwnd, FALSE);
GetRidOfIcon();
break;
default:
return(FALSE);
}
break;
}
default:
if (uiMsg == uiHelpMessage || uiMsg == uiBrowseMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/*** EditGroupDlgProc -- Dialog Procedure
*
*
*
* INT_PTR APIENTRY EditGroupDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
*
* ENTRY - HWND hwnd - handle to dialog box.
* UINT uiMsg - message to be acted upon.
* WPARAM wParam - value specific to uiMsg.
* LPARAM lParam - value specific to uiMsg.
*
* EXIT - True if success, False if not.
* SYNOPSIS - Dialog box message processing function.
*
* WARNINGS -
* EFFECTS -
*
*/
INT_PTR APIENTRY EditGroupDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
LPGROUPDEF lpgd;
static TCHAR szGroupName[MAXGROUPNAMELEN + 1];
switch (uiMsg) {
case WM_INITDIALOG:
pActiveGroup = pCurrentGroup;
lpgd = LockGroup(pActiveGroup->hwnd);
if (lpgd == 0L) {
EndDialog(hwnd, FALSE);
break;
}
if (pActiveGroup->fCommon) {
TCHAR szCommonGroupTitle[64];
if (LoadString(hAppInstance, IDS_COMMONGROUPPROP,
szCommonGroupTitle, CharSizeOf(szCommonGroupTitle))) {
SetWindowText(hwnd, szCommonGroupTitle);
}
}
lstrcpy(szGroupName, (LPTSTR) PTR(lpgd, lpgd->pName));
SetDlgItemText(hwnd, IDD_NAME, (LPTSTR) PTR(lpgd, lpgd->pName));
UnlockGroup(pActiveGroup->hwnd);
SendDlgItemMessage(hwnd, IDD_NAME, EM_LIMITTEXT, MAXGROUPNAMELEN, 0L);
if (pActiveGroup->fRO || dwEditLevel >= 1) {
EnableWindow(GetDlgItem(hwnd,IDOK), FALSE);
EnableWindow(GetDlgItem(hwnd,IDD_NAME), FALSE);
}
break;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_HELP:
goto DoHelp;
case IDOK:
{
INT err = 0;
#if 0
HKEY hkey;
HKEY hkeyGroups;
TCHAR szKeyName[MAXGROUPNAMELEN + 1];
PSECURITY_ATTRIBUTES pSecAttr;
if (!hkeyProgramGroups || !hkeyPMGroups) {
err = TRUE;
goto Exit;
}
#endif
GetDlgItemText(hwnd, IDD_NAME, szNameField, MAXITEMNAMELEN+1);
/* maybe should strip leading and trailing blanks? */
//
// If all spaces or null string do not change it, but if WIn3.1 does.
//
if (lstrcmp(szGroupName, szNameField)) {
ChangeGroupTitle(pActiveGroup->hwnd, szNameField, pActiveGroup->fCommon);
}
#if 0
//
// stop handling of Program Groups key changes.
//
bHandleProgramGroupsEvent = FALSE;
//
// Determine if we're about to change the name of Personal
// group and a Common group.
//
if (pActiveGroup->fCommon) {
hkeyGroups = hkeyCommonGroups;
pSecAttr = pAdminSecAttr;
}
else {
hkeyGroups = hkeyProgramGroups;
pSecAttr = pSecurityAttributes;
}
//
// If the group name contains backslashes (\) remove them
// from the key name. Can not have key names with backslash
// in the registry.
//
lstrcpy(szKeyName, szNameField);
RemoveBackslashFromKeyName(szKeyName);
/* create a new key, and delete the old key */
if (err = RegCreateKeyEx(hkeyGroups, szKeyName, 0, 0, 0,
DELETE | KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_NOTIFY,
pSecAttr, &hkey, NULL)) {
goto Exit;
}
lpgd = (LPGROUPDEF)GlobalLock(pActiveGroup->hGroup);
if (err = RegSetValueEx(hkey, NULL, 0, REG_BINARY, (LPTSTR)lpgd,
SizeofGroup(lpgd))) {
RegCloseKey(hkey);
goto Exit;
}
RegDeleteKey(hkeyGroups, pActiveGroup->lpKey);
//
// Now that it all worked, do the actually name change:
// Change the group window title and the group key name.
//
ChangeGroupTitle(pActiveGroup->hwnd, szNameField, pActiveGroup->fCommon);
LocalFree((HANDLE)pActiveGroup->lpKey);
pActiveGroup->lpKey = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(lstrlen(szKeyName) + 1));
lstrcpy(pActiveGroup->lpKey, szKeyName);
if (bSaveSettings) {
RegFlushKey(hkey);
}
RegCloseKey(hkey);
if (!pActiveGroup->fCommon) {
WriteGroupsSection();
}
}
Exit:
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(pActiveGroup->fCommon);
bHandleProgramGroupsEvent = TRUE;
if (err) {
MyMessageBox(hwnd,IDS_CANTRENAMETITLE,
IDS_CANTRENAMEMSG,NULL, MB_OK|MB_ICONEXCLAMATION);
}
GlobalUnlock(pActiveGroup->hGroup);
#endif
pActiveGroup = NULL;
EndDialog(hwnd, TRUE);
break;
}
case IDCANCEL:
pActiveGroup = NULL;
EndDialog(hwnd, FALSE);
break;
default:
return(FALSE);
}
break;
default:
if (uiMsg == uiHelpMessage) {
DoHelp:
PMHelp(hwnd);
return TRUE;
} else
return FALSE;
}
UNREFERENCED_PARAMETER(lParam);
return(TRUE);
}
/******************************************************************************
UpdateGroupsDlgProc
10-18-93 Created by Johannec
******************************************************************************/
INT_PTR APIENTRY
UpdateGroupsDlgProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
switch (message) {
case WM_INITDIALOG:
//
// Position ourselves
//
CentreWindow(hDlg);
return(TRUE);
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
// fall through...
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam) == IDOK);
break;
case IDD_HELP:
goto DoHelp;
break;
}
break;
default:
if (message == uiHelpMessage)
DoHelp:
{
DWORD dwSave = dwContext;
dwContext = IDH_UPDATEGRPDLG;
PMHelp(hDlg);
dwContext = dwSave;
return TRUE;
} else
return FALSE;
}
// We didn't process the message
return(FALSE);
}
//#ifdef JAPAN
/******************************************************************************
CheckPortName(HWND,LPTSTR)
This function check filename of path is reserveed as device name.
1993/1/18 by yutakas
******************************************************************************/
//BOOL CheckPortName(HWND hDlg, LPTSTR lpszPath)
//{
// LPTSTR lpT;
//
// lpT = lpszPath + lstrlen(lpszPath);
// while (lpT != lpszPath)
// {
// lpT = CharPrev(lpszPath,lpT);
// }
//
// if (PortName(lpT))
// {
// MyMessageBox(hDlg, IDS_BADPORTPATHTITLE, IDS_BADPORTPATHMSG, lpszPath,
// MB_OK | MB_ICONEXCLAMATION);
// return TRUE;
// }
//
// return FALSE;
//
//}
//
//BOOL PortName(LPTSTR lpszFileName)
//{
//#define PORTARRAY 22
// static TCHAR *szPorts[PORTARRAY] = {TEXT("LPT1"), TEXT("LPT2"), TEXT("LPT3"), TEXT("LPT4"), TEXT("LPT5"),
// TEXT("LPT6"), TEXT("LPT7"), TEXT("LPT8"), TEXT("LPT9"),
// TEXT("COM1"), TEXT("COM2"), TEXT("COM3"), TEXT("COM4"), TEXT("COM5"),
// TEXT("COM6"), TEXT("COM7"), TEXT("COM8"), TEXT("COM9"),
// TEXT("NUL"), TEXT("PRN"), TEXT("CON"), TEXT("AUX")};
// short i;
// TCHAR cSave;
//
// cSave = *(lpszFileName + 4);
// if (cSave == TEXT('.'))
// *(lpszFileName + 4) = TEXT('\0');
// for (i = 0; i < PORTARRAY; i++) {
// if (!lstrcmpi(szPorts[i], lpszFileName))
// break;
// }
// *(lpszFileName + 4) = cSave;
// return(i != PORTARRAY);
//}
//#endif
Reference in a new issue Copy permalink