/****************************************************************************/
/* */
/* WFUTIL.C - */
/* */
/* Windows File System String Utility Functions */
/* */
/****************************************************************************/
#include "winfile.h"
#include "lfn.h"
#include "winnet.h"
#include "wnetcaps.h" // WNetGetCaps()
#include "stdlib.h"
int rgiDriveType[26];
PSTR CurDirCache[26];
// cache GetDriveType calls for speed
INT
DriveType(
INT iDrive
)
{
if (rgiDriveType[iDrive] != -1)
return rgiDriveType[iDrive];
return rgiDriveType[iDrive] = MGetDriveType(iDrive);
}
VOID
InvalidateDriveType()
{
INT i;
for (i = 0; i < 26; i++)
rgiDriveType[i] = -1;
}
// iDrive zero based drive number (0 = A, 1 = B)
// returns:
// TRUE we have it saved pszPath gets path
// FALSE we don't have it saved
BOOL
APIENTRY
GetSavedDirectory(
INT iDrive,
PSTR pszPath
)
{
if (CurDirCache[iDrive]) {
lstrcpy(pszPath, CurDirCache[iDrive]);
return TRUE;
} else
return FALSE;
}
VOID
APIENTRY
SaveDirectory(
PSTR pszPath
)
{
INT i;
i = DRIVEID(pszPath);
if (CurDirCache[i])
LocalFree((HANDLE)CurDirCache[i]);
CurDirCache[i] = (PSTR)LocalAlloc(LPTR, lstrlen(pszPath)+1);
if (CurDirCache[i])
lstrcpy(CurDirCache[i], pszPath);
}
/*
* GetSelectedDrive() -
*
* Get the selected drive from the currently active window
*
* should be in wfutil.c
*/
INT
APIENTRY
GetSelectedDrive()
{
HWND hwnd;
hwnd = (HWND)SendMessage(hwndMDIClient,WM_MDIGETACTIVE,0,0L);
return (INT)SendMessage(hwnd,FS_GETDRIVE,0,0L) - (INT)'A';
}
/*
* GetSelectedDirectory() -
*
* Gets the directory selected for the drive. uses the windows
* z-order to give precidence to windows higher in the order.
*
* works like GetCurrentDirectory() except it looks through
* the window list for directories first (and returns ANSI)
*
* returns:
* lpDir ANSI string of current dir
*/
VOID
APIENTRY
GetSelectedDirectory(
WORD iDrive,
PSTR pszDir
)
{
HWND hwnd;
WORD iDriveT;
if (iDrive) {
for (hwnd = GetWindow(hwndMDIClient,GW_CHILD);
hwnd;
hwnd = GetWindow(hwnd,GW_HWNDNEXT)) {
iDriveT = (WORD)SendMessage(hwnd,FS_GETDRIVE,0,0L);
if (iDrive == (WORD)(iDriveT - 'A' + 1))
goto hwndfound;
}
if (!GetSavedDirectory(iDrive - 1, pszDir)) {
SheGetDir(iDrive,pszDir);
OemToAnsi(pszDir,pszDir);
}
return;
} else
hwnd = (HWND)SendMessage(hwndMDIClient,WM_MDIGETACTIVE,0,0L);
hwndfound:
SendMessage(hwnd,FS_GETDIRECTORY,MAXPATHLEN,(LPARAM)pszDir);
StripBackslash(pszDir);
}
// avoid confusion in DOSs upper case mapping by converting to
// upper case before passing down to dos
VOID
APIENTRY
FixAnsiPathForDos(
LPSTR szPath
)
{
if (GetNameType(szPath) == FILE_83_CI)
AnsiUpper(szPath);
AnsiToOem(szPath, szPath);
}
// refresh a MDI child window (works for any type of mdi child)
VOID
APIENTRY
RefreshWindow(
HWND hwndActive
)
{
HWND hwndTree, hwndDir;
LPARAM lParam;
CHAR szDir[MAXPATHLEN];
INT iDrive;
cDrives = UpdateDriveList(); // updates rgiDrive[]
InitDriveBitmaps();
// make sure the thing is still there (floppy drive, net drive)
iDrive = (INT)GetWindowLong(hwndActive, GWL_TYPE);
if ((iDrive >= 0) && !CheckDrive(hwndActive, iDrive))
return;
// update the dir part first so tree can steal later
if (hwndDir = HasDirWindow(hwndActive))
SendMessage(hwndDir, FS_CHANGEDISPLAY, CD_PATH, 0L);
if (hwndTree = HasTreeWindow(hwndActive)) {
// remember the current directory
SendMessage(hwndActive, FS_GETDIRECTORY, sizeof(szDir), (LPARAM)szDir);
// update the drives windows
SendMessage(hwndActive, FS_CHANGEDRIVES, 0, 0L);
if (IsValidDisk(szDir[0] - 'A'))
lParam = (LPARAM)szDir;
else
lParam = 0;
// update the tree
SendMessage(hwndTree, TC_SETDRIVE, MAKEWORD(FALSE, TRUE), lParam);
}
if (hwndActive == hwndSearch)
SendMessage(hwndActive, FS_CHANGEDISPLAY, CD_PATH, 0L);
}
VOID
APIENTRY
CheckEscapes(
LPSTR szFile
)
{
CHAR szT[MAXPATHLEN];
CHAR *p, *pT;
for (p = szFile; *p; p = (LPSTR)AnsiNext(p)) {
switch (*p) {
case ' ':
case ',':
case ';':
case '^':
case '"':
{
// this path contains an annoying character
lstrcpy(szT,szFile);
p = szFile;
*p++ = '"';
for (pT = szT; *pT; ) {
if (*pT == '^' || *pT == '"')
*p++ = '^';
if (IsDBCSLeadByte(*p++ = *pT++))
*p++ = *pT++;
}
*p++ = '"';
*p = 0;
return;
}
}
}
}
HWND
APIENTRY
GetRealParent(
HWND hwnd
)
{
// run up the parent chain until you find a hwnd
// that doesn't have WS_CHILD set
while (GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD)
hwnd = (HWND)GetWindowLongPtr(hwnd, GWLP_HWNDPARENT);
return hwnd;
}
VOID
APIENTRY
WFHelp(
HWND hwnd
)
{
if (!WinHelp(hwnd, szWinObjHelp, HELP_CONTEXT, dwContext)) {
MyMessageBox(hwnd, IDS_WINFILE, IDS_WINHELPERR, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
}
}
BOOL
APIENTRY
IsLastWindow()
{
HWND hwnd;
INT count;
count = 0;
// count all non title/search windows to see if close is allowed
for (hwnd = GetWindow(hwndMDIClient, GW_CHILD); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT))
if (!GetWindow(hwnd, GW_OWNER) && ((INT)GetWindowLong(hwnd, GWL_TYPE) >= 0))
count++;
return count == 1;
}
// get connection information including disconnected drives
//
// in:
// lpDev device name "A:" "LPT1:", etc.
// fClosed if FALSE closed or error drives will be converted to
// WN_SUCCESS return codes. if TRUE return not connected
// and error state values (ie, the caller knows about not
// connected and error state drives)
// out:
// lpPath filled with net name if return is WN_SUCCESS (or not connected/error)
// returns:
// WN_* error code
WORD
APIENTRY
WFGetConnection(
LPSTR lpDev,
LPSTR lpPath,
BOOL fClosed
)
{
DWORD cb;
UINT err;
UINT caps;
cb = 64;
caps = WNetGetCaps(WNNC_CONNECTION);
if (caps & WNNC_CON_GETCONNECTIONS)
err = WNetGetConnection(lpDev,lpPath,&cb);
else
return WN_NOT_CONNECTED;
if (err == WN_NOT_CONNECTED &&
!(caps & WNNC_CON_RESTORECONNECTION)) {
if (GetProfileString(szNetwork,lpDev,szNULL,lpPath,64))
err = WN_CONNECTION_CLOSED;
}
if (!fClosed)
if (err == WN_CONNECTION_CLOSED || err == WN_DEVICE_ERROR)
err = WN_SUCCESS;
return (WORD)err;
}
// returns the number of this MDI window as well as returning
// the text with the number stripped off
//
// returns:
// 0 this title doesn't have a number
// > 0 the title number
// szTitle the title with the number stripped off
INT
APIENTRY
GetMDIWindowText(
HWND hWnd,
LPSTR szTitle,
INT size
)
{
LPSTR lp, lpLast;
ENTER("GetMDIWindowText");
GetWindowText(hWnd, szTitle, size);
lpLast = NULL;
for (lp = szTitle; *lp; lp = AnsiNext(lp))
if (*lp == ':')
lpLast = lp;
if (lpLast) {
*lpLast++ = 0;
PRINT(BF_PARMTRACE, "OUT: szTitle=%s", szTitle);
PRINT(BF_PARMTRACE, "OUT: window#=%s", lpLast);
LEAVE("GetMDIWindowText");
return atoi(lpLast); // return the window number
} else {
TRACE(BF_PARMTRACE, "OUT: window#=0");
LEAVE("GetMDIWindowText");
return 0; // no number on this
}
}
// set the MDI window text and add a ":#" on the end if
// there is another window with the same title. this is to
// avoid confusion when there are multiple MDI children
// with the same title. be sure to use GetMDIWindowText to
// strip off the number stuff.
VOID
APIENTRY
SetMDIWindowText(
HWND hWnd,
LPSTR szTitle
)
{
CHAR szTemp[MAXPATHLEN];
CHAR szNumber[20];
HWND hwnd;
INT num, max_num;
ENTER("SetMDIWindowText");
PRINT(BF_PARMTRACE, "hWnd=%lx", hWnd);
PRINT(BF_PARMTRACE, "IN: szTitle=%s", szTitle);
max_num = 0;
for (hwnd = GetWindow(hwndMDIClient, GW_CHILD); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT)) {
num = GetMDIWindowText(hwnd, szTemp, sizeof(szTemp));
if (!lstrcmp(szTemp, szTitle)) {
if (hwnd == hWnd)
continue;
if (!num) {
lstrcat(szTemp, ":1");
// if (wTextAttribs & TA_LOWERCASE)
// AnsiLower(szTemp);
SetWindowText(hwnd, szTemp);
num = 1;
}
max_num = max(max_num, num);
}
}
if (max_num) {
wsprintf(szNumber, ":%d", max_num+1);
lstrcat(szTitle, szNumber);
}
// if (wTextAttribs & TA_LOWERCASE)
// AnsiLower(szTitle);
SetWindowText(hWnd, szTitle);
PRINT(BF_PARMTRACE, "OUT: szTitle=%s", szTitle);
LEAVE("SetMDIWindowText");
}
#define ISDIGIT(c) ((c) >= '0' && (c) <= '9')
#ifdef INLIBRARY
INT
APIENTRY
atoi(
LPSTR sz
)
{
INT n = 0;
BOOL bNeg = FALSE;
if (*sz == '-') {
bNeg = TRUE;
sz++;
}
while (ISDIGIT(*sz)) {
n *= 10;
n += *sz - '0';
sz++;
}
return bNeg ? -n : n;
}
#endif
// fills in rgiDrive[] and returns the number of drives
INT
APIENTRY
UpdateDriveList()
{
INT i, cRealDrives = 0;
DWORD dwDrives;
dwDrives = GetLogicalDrives();
for (i = 0; i < 26; i++) {
if ((1 << i) & dwDrives) {
rgiDrive[cRealDrives++] = i;
rgiDriveType[i] = MGetDriveType(i);
} else {
rgiDrive[i] = 0;
rgiDriveType[i] = -1; // invalidate the drivetype
}
if (apVolInfo[i]) { // sothat volinfo is refreshed
LocalFree(apVolInfo[i]);
apVolInfo[i] = NULL;
}
}
return cRealDrives;
}
int
GetBootDisk()
{
CHAR szTemp[MAXPATHLEN];
// well, close enough...
if (GetWindowsDirectory(szTemp, sizeof(szTemp))) {
return szTemp[0] - 'A';
} else {
return 'a';
}
}
//
// IsCDROM() - determine if a drive is a CDROM drive
//
// iDrive drive index (0=A, 1=B, ...)
//
// return TRUE/FALSE
//
WORD
APIENTRY
IsCDRomDrive(
INT iDrive
)
{
if (rgiDriveType[iDrive] == DRIVE_CDROM)
return (TRUE);
return (FALSE);
}
// this is called for every drive at init time so it must
// be sure to not trigget things like the phantom B: drive support
//
// iDrive is a zero based drive number (0 = A, 1 = B)
WORD
APIENTRY
IsNetDrive(
INT iDrive
)
{
INT err;
CHAR szDrive[3];
CHAR szConn[64]; // this really should be WNBD_MAX_LENGTH
// but this change would have to be many everywhere
szDrive[0] = (CHAR)(iDrive+'A');
szDrive[1] = ':';
szDrive[2] = (CHAR)0;
if (IsCDRomDrive(iDrive)) // this is bogus... move this out
return 0;
err = WFGetConnection(szDrive, szConn, TRUE);
if (err == WN_SUCCESS)
return 1;
if (err == WN_CONNECTION_CLOSED || err == WN_DEVICE_ERROR)
return 2;
return 0;
}
BOOL
APIENTRY
IsRemovableDrive(
INT iDrive
)
{
return DriveType(iDrive) == DRIVE_REMOVABLE;
}
BOOL
APIENTRY
IsRemoteDrive(
INT iDrive
)
{
return DriveType(iDrive) == DRIVE_REMOTE;
}
// iDrive zero based drive number (A = 0)
BOOL
APIENTRY
IsRamDrive(
INT iDrive
)
{
return DriveType(iDrive) == DRIVE_RAMDISK;
}
// get interesting stuff about a drive
//
// zero based drive numbers (0 = A, 1 = B)
//
DWORD
APIENTRY
GetClusterInfo(
WORD drive
)
{
UNREFERENCED_PARAMETER(drive);
return 0;
}
BOOL
APIENTRY
IsValidDisk(
INT iDrive
)
{
if (apVolInfo[iDrive] == NULL)
FillVolumeInfo(iDrive);
return (apVolInfo[iDrive] != NULL);
}
VOID
APIENTRY
GetVolShare(
WORD wDrive,
LPSTR szVolShare
)
{
CHAR szDrive[5];
szVolShare[0] = TEXT('\0');
lstrcpy(szVolShare, "Objects");
}
/*--------------------------------------------------------------------------*/
/* */
/* IsLFNSelected() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL
APIENTRY
IsLFNSelected()
{
HWND hwndActive;
BOOL fDir;
LPSTR p;
hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
p = (LPSTR)SendMessage(hwndActive, FS_GETSELECTION, 2, (LPARAM)&fDir);
if (p) {
LocalFree((HANDLE)p);
}
return (fDir);
}
/*--------------------------------------------------------------------------*/
/* */
/* GetSelection() - */
// caller must free lpstr returned.
/* */
/*--------------------------------------------------------------------------*/
LPSTR
APIENTRY
GetSelection(
INT iSelType
)
{
HWND hwndActive;
hwndActive = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
return (LPSTR)SendMessage(hwndActive,FS_GETSELECTION, (WPARAM)iSelType, 0L);
}
//
// in:
// pFrom pointer that is used as start of selection search.
// on subsequent calls pass in the previous non NULL
// return value
//
// out:
// pTo buffer that receives the next file in the list
// for non NULL return
//
// returns:
// NULL if no more files in this list (szFile) is undefined
// pointer to be passed to subsequent calls to this function
// to enumerate thorough the file list
//
LPSTR
APIENTRY
GetNextFile(
LPSTR pFrom,
LPSTR pTo,
INT cbMax
)
{
INT i;
ENTER("GetNextFile");
PRINT(BF_PARMTRACE, "IN: pFrom=%s", pFrom);
if (!pFrom)
return NULL;
/* Skip over leading spaces and commas. */
while (*pFrom && (*pFrom == ' ' || *pFrom == ','))
pFrom = (LPSTR)AnsiNext(pFrom);
if (!*pFrom)
return (NULL);
if (*pFrom == '\"') {
pFrom = (LPSTR)AnsiNext(pFrom);
/* Find the next quote */
for (i=0; *pFrom && *pFrom != '\"';) {
if (*pFrom == '^') {
pFrom = (LPSTR)AnsiNext(pFrom);
if (!*pFrom)
break;
}
if (i < cbMax - 1) {
i++;
if (IsDBCSLeadByte(*pTo++ = *pFrom++)) {
i++;
*pTo++ = *pFrom++;
}
}
}
pFrom = (LPSTR)AnsiNext(pFrom);
} else {
/* Find the next space or comma. */
for (i=0; *pFrom && *pFrom != ' ' && *pFrom != ',';) {
if (*pFrom == '^') {
pFrom = (LPSTR)AnsiNext(pFrom);
if (!*pFrom)
break;
}
if (i < cbMax - 1) {
i++;
if (IsDBCSLeadByte(*pTo++ = *pFrom++)) {
i++;
*pTo++ = *pFrom++;
}
}
}
}
*pTo = TEXT('\0');
PRINT(BF_PARMTRACE, pTo ? "OUT: pTo=%s" : "OUT: pTo=NULL", pTo);
LEAVE("GetNextFile");
return (pFrom);
}
// sets the DOS current directory based on the currently active window
VOID
APIENTRY
SetWindowDirectory()
{
CHAR szTemp[MAXPATHLEN];
GetSelectedDirectory(0, szTemp);
FixAnsiPathForDos(szTemp);
SheChangeDir(szTemp);
}
/*--------------------------------------------------------------------------*/
/* */
/* SetDlgDirectory() - */
/* */
/*--------------------------------------------------------------------------*/
/* Sets the IDD_DIR field of 'hDlg' to whatever the active window says is the
* active directory.
*
* this does not really change the DOS current directory
*/
VOID
APIENTRY
SetDlgDirectory(
HWND hDlg,
PSTR pszPath
)
{
HDC hDC;
INT dx;
RECT rc;
HWND hDlgItem;
HANDLE hFont;
CHAR szPath[MAXPATHLEN+5];
CHAR szTemp[MAXPATHLEN+20];
ENTER("SetDlgDirectory");
if (pszPath)
lstrcpy(szPath, pszPath);
else
GetSelectedDirectory(0, szPath);
/* Make sure that the current directory fits inside the static text field. */
hDlgItem = GetDlgItem(hDlg, IDD_DIR);
GetClientRect(hDlgItem, &rc);
if (LoadString(hAppInstance, IDS_CURDIRIS, szMessage, sizeof(szMessage))) {
hDC = GetDC(hDlg);
hFont = (HANDLE)SendMessage(hDlgItem, WM_GETFONT, 0, 0L);
if (hFont = SelectObject(hDC, hFont)) {
MGetTextExtent(hDC, szMessage, lstrlen(szMessage), &dx, NULL);
CompactPath(hDC, szPath, (WORD)(rc.right-rc.left-dx));
}
SelectObject(hDC, hFont);
ReleaseDC(hDlg, hDC);
wsprintf(szTemp, szMessage, (LPSTR)szPath);
SetDlgItemText(hDlg, IDD_DIR, szTemp);
}
LEAVE("SetDlgDirectory");
}
/*--------------------------------------------------------------------------*/
/* */
/* WritePrivateProfileBool() - */
/* */
/*--------------------------------------------------------------------------*/
VOID
APIENTRY
WritePrivateProfileBool(
LPSTR szKey,
BOOL bParam
)
{
CHAR szBool[6];
wsprintf(szBool, "%d", bParam);
WritePrivateProfileString(szSettings, szKey, szBool, szTheINIFile);
}
/*--------------------------------------------------------------------------*/
/* */
/* WFQueryAbort() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL
APIENTRY
WFQueryAbort()
{
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, TRUE)) {
if (!IsDialogMessage(hdlgProgress, &msg))
DispatchMessage(&msg);
}
return (bUserAbort);
}
/*--------------------------------------------------------------------------*/
/* */
/* IsWild() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns TRUE iff the path contains * or ? */
BOOL
APIENTRY
IsWild(
LPSTR lpszPath
)
{
while (*lpszPath) {
if (*lpszPath == '?' || *lpszPath == '*')
return (TRUE);
lpszPath = AnsiNext(lpszPath);
}
return (FALSE);
}
/*--------------------------------------------------------------------------*/
/* */
/* CheckSlashies() - */
/* */
/*--------------------------------------------------------------------------*/
/* Replaces frontslashes (evil) with backslashes (good). */
VOID
APIENTRY
CheckSlashies(
LPSTR lpT
)
{
while (*lpT) {
if (*lpT == '/')
*lpT = '\\';
lpT = AnsiNext(lpT);
}
}
/*--------------------------------------------------------------------------*/
/* */
/* AddBackslash() - */
/* */
/*--------------------------------------------------------------------------*/
/* Ensures that a path ends with a backslash. */
VOID
APIENTRY
AddBackslash(
LPSTR lpszPath
)
{
ENTER("AddBackslash");
PRINT(BF_PARMTRACE, "IN: lpszPath=%s", lpszPath);
if (*AnsiPrev(lpszPath,lpszPath+lstrlen(lpszPath)) != '\\')
lstrcat(lpszPath, "\\");
PRINT(BF_PARMTRACE, "OUT: lpszPath=%s", lpszPath);
LEAVE("AddBackslash");
}
/*--------------------------------------------------------------------------*/
/* */
/* StripBackslash() - */
/* */
/*--------------------------------------------------------------------------*/
/* Removes a trailing backslash from a proper directory name UNLESS it is
* the root directory. Assumes a fully qualified directory path.
*/
VOID
APIENTRY
StripBackslash(
LPSTR lpszPath
)
{
register WORD len;
len = lstrlen(lpszPath) - (IsDBCSLeadByte(*AnsiPrev(lpszPath,lpszPath+lstrlen(lpszPath))) ? 2 : 1);
if ((len == 2) || (lpszPath[len] != '\\'))
return;
lpszPath[len] = TEXT('\0');
}
/*--------------------------------------------------------------------------*/
/* */
/* StripFilespec() - */
/* */
/*--------------------------------------------------------------------------*/
/* Remove the filespec portion from a path (including the backslash). */
VOID
APIENTRY
StripFilespec(
LPSTR lpszPath
)
{
LPSTR p;
p = lpszPath + lstrlen(lpszPath);
while ((*p != '\\') && (*p != ':') && (p != lpszPath))
p = AnsiPrev(lpszPath, p);
if (*p == ':')
p++;
/* Don't strip backslash from root directory entry. */
if (p != lpszPath) {
if ((*p == '\\') && (*(p-1) == ':'))
p++;
} else
p++;
*p = TEXT('\0');
}
/*--------------------------------------------------------------------------*/
/* */
/* StripPath() - */
/* */
/*--------------------------------------------------------------------------*/
/* Extract only the filespec portion from a path. */
VOID
APIENTRY
StripPath(
LPSTR lpszPath
)
{
LPSTR p;
ENTER("StripPath");
PRINT(BF_PARMTRACE, "IN: lpszPath=%s", lpszPath);
p = lpszPath + lstrlen(lpszPath);
while ((*p != '\\') && (*p != ':') && (p != lpszPath))
p = AnsiPrev(lpszPath, p);
if (p != lpszPath || *p == '\\')
p++;
if (p != lpszPath)
lstrcpy(lpszPath, p);
PRINT(BF_PARMTRACE, "OUT: lpszPath=%s", lpszPath);
LEAVE("StripPath");
}
/*--------------------------------------------------------------------------*/
/* */
/* GetExtension() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns the extension part of a filename. */
LPSTR
APIENTRY
GetExtension(
LPSTR pszFile
)
{
PSTR p, pSave = NULL;
p = pszFile;
while (*p) {
if (*p == '.')
pSave = p;
p = (LPSTR)AnsiNext(p);
}
if (!pSave)
return (p);
return (LPSTR)AnsiNext(pSave);
}
/*--------------------------------------------------------------------------*/
/* */
/* FindExtensionInList() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns TRUE if 'lpszExt' is somewhere in 'pszList'. */
BOOL
APIENTRY
FindExtensionInList(
LPSTR pszExt,
LPSTR pszList
)
{
LPSTR p2;
CHAR ch;
while (*pszList) {
/* Move to the next item in the list. */
while ((*pszList) && (*pszList == ' '))
pszList = (LPSTR)AnsiNext(pszList);
if (!*pszList)
break;
/* NULL-terminate this item. */
p2 = (LPSTR)AnsiNext(pszList);
while ((*p2) && (*p2 != ' '))
p2 = (LPSTR)AnsiNext(p2);
ch = *p2;
*p2 = TEXT('\0');
if (!lstrcmpi(pszExt, pszList)) {
*p2 = ch;
return (TRUE);
}
*p2 = ch;
pszList = p2;
}
return (FALSE);
}
/*--------------------------------------------------------------------------*/
/* */
/* MyMessageBox() - */
/* */
/*--------------------------------------------------------------------------*/
INT
APIENTRY
MyMessageBox(
HWND hWnd,
WORD idTitle,
WORD idMessage,
WORD wStyle
)
{
CHAR szTemp[MAXMESSAGELEN];
HWND hwndT;
LoadString(hAppInstance, idTitle, szTitle, sizeof(szTitle));
if (idMessage < 32) {
LoadString(hAppInstance, IDS_UNKNOWNMSG, szTemp, sizeof(szTemp));
wsprintf(szMessage, szTemp, idMessage);
} else
LoadString(hAppInstance, idMessage, szMessage, sizeof(szMessage));
if (hWnd)
hwndT = GetLastActivePopup(hWnd);
else
hwndT = hWnd;
return MessageBox(hwndT, szMessage, szTitle, wStyle | MB_TASKMODAL);
}
/*--------------------------------------------------------------------------*/
/* */
/* ExecProgram() - */
/* */
/* all strings are OEM */
/*--------------------------------------------------------------------------*/
/* Returns 0 for success. Otherwise returns a IDS_ string code. */
WORD
APIENTRY
ExecProgram(
LPSTR lpPath,
LPSTR lpParms,
LPSTR lpDir,
BOOL bLoadIt
)
{
WORD ret;
INT iCurCount;
INT i;
HCURSOR hCursor;
ENTER("ExecProgram");
ret = 0;
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
iCurCount = ShowCursor(TRUE) - 1;
/* open the object
*/
if (lpPath)
OemToAnsi(lpPath, lpPath);
if (lpParms)
OemToAnsi(lpParms, lpParms);
if (lpDir)
OemToAnsi(lpDir, lpDir);
// Shell Execute takes ansi string.
//
ret = (WORD)RealShellExecute(hwndFrame, NULL, lpPath, lpParms, lpDir, NULL, NULL, NULL, (WORD)(bLoadIt ? SW_SHOWMINNOACTIVE : SW_SHOWNORMAL), NULL);
DosResetDTAAddress(); // undo any bad things COMMDLG did
if (lpPath)
AnsiToOem(lpPath, lpPath);
if (lpParms)
AnsiToOem(lpParms, lpParms);
if (lpDir)
AnsiToOem(lpDir, lpDir);
switch (ret) {
case 0:
case 8:
ret = IDS_NOMEMORYMSG;
break;
case 2:
ret = IDS_FILENOTFOUNDMSG;
break;
case 3:
case 5: // access denied
ret = IDS_BADPATHMSG;
break;
case 4:
ret = IDS_MANYOPENFILESMSG;
break;
case 10:
ret = IDS_NEWWINDOWSMSG;
break;
case 12:
ret = IDS_OS2APPMSG;
break;
case 15:
/* KERNEL has already put up a messagebox for this one. */
ret = 0;
break;
case 16:
ret = IDS_MULTIPLEDSMSG;
break;
case 18:
ret = IDS_PMODEONLYMSG;
break;
case 19:
ret = IDS_COMPRESSEDEXE;
break;
case 20:
ret = IDS_INVALIDDLL;
break;
case SE_ERR_SHARE:
ret = IDS_SHAREERROR;
break;
case SE_ERR_ASSOCINCOMPLETE:
ret = IDS_ASSOCINCOMPLETE;
break;
case SE_ERR_DDETIMEOUT:
case SE_ERR_DDEFAIL:
case SE_ERR_DDEBUSY:
ret = IDS_DDEFAIL;
break;
case SE_ERR_NOASSOC:
ret = IDS_NOASSOCMSG;
break;
default:
if (ret < 32)
goto EPExit;
if (bMinOnRun && !bLoadIt)
ShowWindow(hwndFrame, SW_SHOWMINNOACTIVE);
ret = 0;
}
EPExit:
i = ShowCursor(FALSE);
#if 0
/* Make sure that the cursor count is still balanced. */
if (i != iCurCount)
ShowCursor(TRUE);
#endif
SetCursor(hCursor);
PRINT(BF_PARMTRACE, "OUT: ret=%ud", ret);
LEAVE("ExecProgram");
return ret;
}
/*--------------------------------------------------------------------------*/
/* */
/* IsProgramFile() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns TRUE is the Path points to a file which has one of the extentions
* listed in the "Programs=" portions of WIN.INI.
*/
BOOL
APIENTRY
IsProgramFile(
LPSTR lpszPath
)
{
LPSTR szExt;
CHAR szTemp[MAXPATHLEN];
/* Move the string into our own DS. */
lstrcpy(szTemp, lpszPath);
/* Get the file's extension. */
StripPath(szTemp);
szExt = GetExtension(szTemp);
if (!*szExt) {
/* The specified path didn't have an extention. It can't be a program. */
return (FALSE);
}
return FindExtensionInList(szExt, szPrograms);
}
/*--------------------------------------------------------------------------*/
/* */
/* IsDocument() - */
/* */
/*--------------------------------------------------------------------------*/
/* Returns TRUE is the Path points to a file which has one of the extentions
* listed in the "Documents=" portions of WIN.INI or one which has an Association.
*/
BOOL
APIENTRY
IsDocument(
LPSTR lpszPath
)
{
LPSTR szExt;
CHAR szTemp[MAXPATHLEN];
/* Move the string into our own DS. */
lstrcpy(szTemp, lpszPath);
/* Get the file's extension. */
StripPath(szTemp);
szExt = GetExtension(szTemp);
if (!*szExt) {
/* The specified path didn't have an extention. It can't be a program. */
return (FALSE);
}
return FindExtensionInList(szExt, szDocuments);
}