/****************************************************************************/ /* */ /* 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); }