path.c File Reference

#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "wine/unicode.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winreg.h"
#include "winternl.h"
#include "shlwapi.h"
#include "wine/debug.h"

Include dependency graph for path.c:

Go to the source code of this file.

Macros
#define	NO_SHLWAPI_STREAM
#define	GET_FUNC(func, module, name, fail)

Typedefs
typedef BOOL(WINAPI *	fnpIsNetDrive) (int)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
HRESULT WINAPI	SHGetWebFolderFilePathW (LPCWSTR, LPWSTR, DWORD)
LPSTR WINAPI	PathBuildRootA (LPSTR lpszPath, int drive)
LPWSTR WINAPI	PathBuildRootW (LPWSTR lpszPath, int drive)
void WINAPI	PathRemoveArgsA (LPSTR lpszPath)
void WINAPI	PathRemoveArgsW (LPWSTR lpszPath)
BOOL WINAPI	PathFileExistsDefExtW (LPWSTR lpszPath, DWORD dwWhich)
BOOL WINAPI	PathFileExistsDefExtA (LPSTR lpszPath, DWORD dwWhich)
static BOOL	SHLWAPI_PathFindInOtherDirs (LPWSTR lpszFile, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathExA (LPSTR lpszFile, LPCSTR *lppszOtherDirs, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathExW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
BOOL WINAPI	PathFindOnPathA (LPSTR lpszFile, LPCSTR *lppszOtherDirs)
BOOL WINAPI	PathFindOnPathW (LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
BOOL WINAPI	PathCompactPathExA (LPSTR lpszDest, LPCSTR lpszPath, UINT cchMax, DWORD dwFlags)
BOOL WINAPI	PathCompactPathExW (LPWSTR lpszDest, LPCWSTR lpszPath, UINT cchMax, DWORD dwFlags)
BOOL WINAPI	PathIsDirectoryA (LPCSTR lpszPath)
BOOL WINAPI	PathIsDirectoryW (LPCWSTR lpszPath)
BOOL WINAPI	PathFileExistsAndAttributesA (LPCSTR lpszPath, DWORD *dwAttr)
BOOL WINAPI	PathFileExistsAndAttributesW (LPCWSTR lpszPath, DWORD *dwAttr)
BOOL WINAPI	PathIsContentTypeA (LPCSTR path, LPCSTR content_type)
BOOL WINAPI	PathIsContentTypeW (LPCWSTR lpszPath, LPCWSTR lpszContentType)
BOOL WINAPI	PathIsSystemFolderA (LPCSTR lpszPath, DWORD dwAttrib)
BOOL WINAPI	PathIsSystemFolderW (LPCWSTR lpszPath, DWORD dwAttrib)
BOOL WINAPI	PathMakePrettyA (LPSTR lpszPath)
BOOL WINAPI	PathMakePrettyW (LPWSTR lpszPath)
BOOL WINAPI	PathCompactPathA (HDC hDC, LPSTR lpszPath, UINT dx)
BOOL WINAPI	PathCompactPathW (HDC hDC, LPWSTR lpszPath, UINT dx)
static BOOL	SHLWAPI_UseSystemForSystemFolders (void)
BOOL WINAPI	PathMakeSystemFolderA (LPCSTR lpszPath)
BOOL WINAPI	PathMakeSystemFolderW (LPCWSTR lpszPath)
BOOL WINAPI	PathUnmakeSystemFolderA (LPCSTR lpszPath)
BOOL WINAPI	PathUnmakeSystemFolderW (LPCWSTR lpszPath)
VOID WINAPI	PathSetDlgItemPathA (HWND hDlg, int id, LPCSTR lpszPath)
VOID WINAPI	PathSetDlgItemPathW (HWND hDlg, int id, LPCWSTR lpszPath)
BOOL WINAPI	PathIsNetworkPathA (LPCSTR lpszPath)
BOOL WINAPI	PathIsNetworkPathW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsDirectoryEmptyA (LPCSTR lpszPath)
BOOL WINAPI	PathIsDirectoryEmptyW (LPCWSTR lpszPath)
LPCSTR WINAPI	PathFindSuffixArrayA (LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
LPCWSTR WINAPI	PathFindSuffixArrayW (LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
void WINAPI	PathUndecorateA (char *path)
void WINAPI	PathUndecorateW (WCHAR *path)
HRESULT WINAPI	SHGetWebFolderFilePathA (LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)

Variables
static HMODULE	SHLWAPI_hshell32
static fnpIsNetDrive	pIsNetDrive

Macro Definition Documentation

GET_FUNC

#define GET_FUNC	(		func,
			module,
			name,
			fail
	)

Value:

  do { \
    if (!func) { \
      if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
      func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
      if (!func) return fail; \
    } \
  } while (0)

Definition at line 52 of file path.c.

NO_SHLWAPI_STREAM

#define NO_SHLWAPI_STREAM

Definition at line 33 of file path.c.

Typedef Documentation

fnpIsNetDrive

typedef BOOL(WINAPI * fnpIsNetDrive) (int)

Definition at line 65 of file path.c.

Function Documentation

PathBuildRootA()

LPSTR WINAPI PathBuildRootA	(	LPSTR	lpszPath,
		int	drive
	)

Definition at line 86 of file path.c.

{
  TRACE("(%p,%d)\n", lpszPath, drive);
 
  if (lpszPath && drive >= 0 && drive < 26)
  {
    lpszPath[0] = 'A' + drive;
    lpszPath[1] = ':';
    lpszPath[2] = '\\';
    lpszPath[3] = '\0';
  }
  return lpszPath;
}

Referenced by ATL::CPathT< StringType >::PathBuildRootX(), and test_PathBuildRootA().

PathBuildRootW()

LPWSTR WINAPI PathBuildRootW	(	LPWSTR	lpszPath,
		int	drive
	)

Definition at line 105 of file path.c.

{
  TRACE("(%p,%d)\n", lpszPath, drive);
 
  if (lpszPath && drive >= 0 && drive < 26)
  {
    lpszPath[0] = 'A' + drive;
    lpszPath[1] = ':';
    lpszPath[2] = '\\';
    lpszPath[3] = '\0';
  }
  return lpszPath;
}

Referenced by IsLFNDriveW(), CDesktopBrowser::OnDeviceChange(), CDrivesFolder::ParseDisplayName(), CAddressEditBox::ParseNow(), ATL::CPathT< StringType >::PathBuildRootX(), and PathQualifyExW().

PathCompactPathA()

BOOL WINAPI PathCompactPathA	(	HDC	hDC,
		LPSTR	lpszPath,
		UINT	dx
	)

Definition at line 950 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathCompactPathW(hDC, szPath, dx);
    WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
  }
  return bRet;
}

Referenced by ATL::CPathT< StringType >::PathCompactPathX().

PathCompactPathExA()

BOOL WINAPI PathCompactPathExA	(	LPSTR	lpszDest,
		LPCSTR	lpszPath,
		UINT	cchMax,
		DWORD	dwFlags
	)

Definition at line 488 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
 
  if (lpszPath && lpszDest)
  {
    WCHAR szPath[MAX_PATH];
    WCHAR szDest[MAX_PATH];
 
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    szDest[0] = '\0';
    bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
    WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
  }
  return bRet;
}

Referenced by ATL::CPathT< StringType >::PathCompactPathExX().

PathCompactPathExW()

BOOL WINAPI PathCompactPathExW	(	LPWSTR	lpszDest,
		LPCWSTR	lpszPath,
		UINT	cchMax,
		DWORD	dwFlags
	)

Definition at line 513 of file path.c.

{
  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
  LPCWSTR lpszFile;
  DWORD dwLen, dwFileLen = 0;
 
  TRACE("(%p,%s,%d,0x%08lx)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
 
  if (!lpszPath)
    return FALSE;
 
  if (!lpszDest)
  {
    WARN("Invalid lpszDest would crash under Win32!\n");
    return FALSE;
  }
 
  *lpszDest = '\0';
 
  if (cchMax < 2)
    return TRUE;
 
  dwLen = lstrlenW(lpszPath) + 1;
 
  if (dwLen < cchMax)
  {
    /* Don't need to compact */
    memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
    return TRUE;
  }
 
  /* Path must be compacted to fit into lpszDest */
  lpszFile = PathFindFileNameW(lpszPath);
  dwFileLen = lpszPath + dwLen - lpszFile;
 
  if (dwFileLen == dwLen)
  {
    /* No root in psth */
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    /* Compact the file name with ellipses at the end */
    cchMax -= 4;
    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
    lstrcpyW(lpszDest + cchMax, szEllipses);
    return TRUE;
  }
  /* We have a root in the path */
  lpszFile--; /* Start compacted filename with the path separator */
  dwFileLen++;
 
  if (dwFileLen + 3 > cchMax)
  {
    /* Compact the file name */
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    lstrcpyW(lpszDest, szEllipses);
    lpszDest += 3;
    cchMax -= 4;
    *lpszDest++ = *lpszFile++;
    if (cchMax <= 4)
    {
      while (--cchMax > 0) /* No room left for anything but ellipses */
        *lpszDest++ = '.';
      *lpszDest = '\0';
      return TRUE;
    }
    cchMax -= 4;
    memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
    lstrcpyW(lpszDest + cchMax, szEllipses);
    return TRUE;
  }
 
  /* Only the root needs to be Compacted */
  dwLen = cchMax - dwFileLen - 3;
  memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
  lstrcpyW(lpszDest + dwLen, szEllipses);
  lstrcpyW(lpszDest + dwLen + 3, lpszFile);
  return TRUE;
}

Referenced by PathCompactPathExA(), and ATL::CPathT< StringType >::PathCompactPathExX().

PathCompactPathW()

BOOL WINAPI PathCompactPathW	(	HDC	hDC,
		LPWSTR	lpszPath,
		UINT	dx
	)

Definition at line 971 of file path.c.

{
  static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
  BOOL bRet = TRUE;
  HDC hdc = 0;
  WCHAR buff[MAX_PATH];
  SIZE size;
  DWORD dwLen;
 
  TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
 
  if (!lpszPath)
    return FALSE;
 
  if (!hDC)
    hdc = hDC = GetDC(0);
 
  /* Get the length of the whole path */
  dwLen = lstrlenW(lpszPath);
  GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
 
  if ((UINT)size.cx > dx)
  {
    /* Path too big, must reduce it */
    LPWSTR sFile;
    DWORD dwEllipsesLen = 0, dwPathLen = 0;
 
    sFile = PathFindFileNameW(lpszPath);
    if (sFile != lpszPath) sFile--;
 
    /* Get the size of ellipses */
    GetTextExtentPointW(hDC, szEllipses, 3, &size);
    dwEllipsesLen = size.cx;
    /* Get the size of the file name */
    GetTextExtentPointW(hDC, sFile, lstrlenW(sFile), &size);
    dwPathLen = size.cx;
 
    if (sFile != lpszPath)
    {
      LPWSTR sPath = sFile;
      BOOL bEllipses = FALSE;
 
      /* The path includes a file name. Include as much of the path prior to
       * the file name as possible, allowing for the ellipses, e.g:
       * c:\some very long path\filename ==> c:\some v...\filename
       */
      lstrcpynW(buff, sFile, MAX_PATH);
 
      do
      {
        DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
 
        GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
        dwTotalLen += size.cx;
        if (dwTotalLen <= dx)
          break;
        sPath--;
        if (!bEllipses)
        {
          bEllipses = TRUE;
          sPath -= 2;
        }
      } while (sPath > lpszPath);
 
      if (sPath > lpszPath)
      {
        if (bEllipses)
        {
          lstrcpyW(sPath, szEllipses);
          lstrcpyW(sPath+3, buff);
        }
        bRet = TRUE;
        goto end;
      }
      lstrcpyW(lpszPath, szEllipses);
      lstrcpyW(lpszPath+3, buff);
      bRet = FALSE;
      goto end;
    }
 
    /* Trim the path by adding ellipses to the end, e.g:
     * A very long file name.txt ==> A very...
     */
    dwLen = lstrlenW(lpszPath);
 
    if (dwLen > MAX_PATH - 3)
      dwLen =  MAX_PATH - 3;
    lstrcpynW(buff, sFile, dwLen);
 
    do {
      dwLen--;
      GetTextExtentPointW(hDC, buff, dwLen, &size);
    } while (dwLen && size.cx + dwEllipsesLen > dx);
 
   if (!dwLen)
   {
     DWORD dwWritten = 0;
 
     dwEllipsesLen /= 3; /* Size of a single '.' */
 
     /* Write as much of the Ellipses string as possible */
     while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
     {
       *lpszPath++ = '.';
       dwWritten += dwEllipsesLen;
       dwLen++;
     }
     *lpszPath = '\0';
     bRet = FALSE;
   }
   else
   {
     lstrcpyW(buff + dwLen, szEllipses);
     lstrcpyW(lpszPath, buff);
    }
  }
 
end:
  if (hdc)
    ReleaseDC(0, hdc);
 
  return bRet;
}

Referenced by CZipExtract::CCompleteSettingsPage::OnSetActive(), PathCompactPathA(), ATL::CPathT< StringType >::PathCompactPathX(), and PathSetDlgItemPathW().

PathFileExistsAndAttributesA()

BOOL WINAPI PathFileExistsAndAttributesA	(	LPCSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 721 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal = 0;
 
  TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
 
  if (dwAttr)
    *dwAttr = INVALID_FILE_ATTRIBUTES;
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesA(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

PathFileExistsAndAttributesW()

BOOL WINAPI PathFileExistsAndAttributesW	(	LPCWSTR	lpszPath,
		DWORD *	dwAttr
	)

Definition at line 747 of file path.c.

{
  UINT iPrevErrMode;
  DWORD dwVal;
 
  TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
 
  if (!lpszPath)
    return FALSE;
 
  iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
  dwVal = GetFileAttributesW(lpszPath);
  SetErrorMode(iPrevErrMode);
  if (dwAttr)
    *dwAttr = dwVal;
  return (dwVal != INVALID_FILE_ATTRIBUTES);
}

Referenced by GetTypeDescriptionByPath(), PathFileExistsDefExtAndAttributesW(), PathResolveW(), and SHGetFileDescriptionW().

PathFileExistsDefExtA()

BOOL WINAPI PathFileExistsDefExtA	(	LPSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 248 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s,%ld)\n", debugstr_a(lpszPath), dwWhich);
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathFileExistsDefExtW(szPath, dwWhich);
    if (bRet)
      WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
  }
  return bRet;
}

PathFileExistsDefExtW()

BOOL WINAPI PathFileExistsDefExtW	(	LPWSTR	lpszPath,
		DWORD	dwWhich
	)

Definition at line 170 of file path.c.

{
  static const WCHAR pszExts[][5]  = { { '.', 'p', 'i', 'f', 0},
                                       { '.', 'c', 'o', 'm', 0},
                                       { '.', 'e', 'x', 'e', 0},
                                       { '.', 'b', 'a', 't', 0},
                                       { '.', 'l', 'n', 'k', 0},
                                       { '.', 'c', 'm', 'd', 0},
                                       { 0, 0, 0, 0, 0} };
 
  TRACE("(%s,%ld)\n", debugstr_w(lpszPath), dwWhich);
 
  if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
    return FALSE;
 
  if (dwWhich)
  {
    LPCWSTR szExt = PathFindExtensionW(lpszPath);
#ifndef __REACTOS__
    if (!*szExt || dwWhich & 0x40)
#else
    if (!*szExt || dwWhich & WHICH_OPTIONAL)
#endif
    {
      size_t iChoose = 0;
      int iLen = lstrlenW(lpszPath);
      if (iLen > (MAX_PATH - 5))
        return FALSE;
#ifndef __REACTOS__
      while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
#else
      while (pszExts[iChoose][0])
#endif
      {
#ifdef __REACTOS__
        if (dwWhich & 0x1)
        {
        if (GetFileAttributes(lpszPath) != FILE_ATTRIBUTE_DIRECTORY)
#endif
        lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
        if (PathFileExistsW(lpszPath))
          return TRUE;
#ifdef __REACTOS__
        }
#endif
        iChoose++;
        dwWhich >>= 1;
      }
      *(lpszPath + iLen) = (WCHAR)'\0';
      return FALSE;
    }
  }
  return PathFileExistsW(lpszPath);
}

Referenced by PathFileExistsDefExtA(), PathFileExistsDefExtAndAttributesW(), PathFindOnPathExA(), PathFindOnPathExW(), PathSearchOnExtensionsW(), and SHLWAPI_PathFindInOtherDirs().

PathFindOnPathA()

BOOL WINAPI PathFindOnPathA	(	LPSTR	lpszFile,
		LPCSTR *	lppszOtherDirs
	)

Definition at line 445 of file path.c.

{
  TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
  return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
 }

PathFindOnPathExA()

BOOL WINAPI PathFindOnPathExA	(	LPSTR	lpszFile,
		LPCSTR *	lppszOtherDirs,
		DWORD	dwWhich
	)

Definition at line 360 of file path.c.

{
  WCHAR szFile[MAX_PATH];
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%p,%08lx)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
 
  if (!lpszFile || !PathIsFileSpecA(lpszFile))
    return FALSE;
 
  MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
 
  /* Search provided directories first */
  if (lppszOtherDirs && *lppszOtherDirs)
  {
    WCHAR szOther[MAX_PATH];
    LPCSTR *lpszOtherPath = lppszOtherDirs;
 
    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
    {
      MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
      PathCombineW(buff, szOther, szFile);
      if (PathFileExistsDefExtW(buff, dwWhich))
      {
        WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
        return TRUE;
      }
      lpszOtherPath++;
    }
  }
  /* Not found, try system and path dirs */
  if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
  {
    WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
    return TRUE;
  }
  return FALSE;
}

Referenced by PathFindOnPathA().

PathFindOnPathExW()

BOOL WINAPI PathFindOnPathExW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs,
		DWORD	dwWhich
	)

Definition at line 404 of file path.c.

{
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%p,%08lx)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
 
  if (!lpszFile || !PathIsFileSpecW(lpszFile))
    return FALSE;
 
  /* Search provided directories first */
  if (lppszOtherDirs && *lppszOtherDirs)
  {
    LPCWSTR *lpszOtherPath = lppszOtherDirs;
    while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
    {
      PathCombineW(buff, *lpszOtherPath, lpszFile);
      if (PathFileExistsDefExtW(buff, dwWhich))
      {
        lstrcpyW(lpszFile, buff);
        return TRUE;
      }
      lpszOtherPath++;
    }
  }
  /* Not found, try system and path dirs */
  return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
}

Referenced by PathFindOnPathW(), PathSearchOnExtensionsW(), ShellExecCmdLine(), SHEvaluateSystemCommandTemplate(), and WelcomeDlgProc().

PathFindOnPathW()

BOOL WINAPI PathFindOnPathW	(	LPWSTR	lpszFile,
		LPCWSTR *	lppszOtherDirs
	)

Definition at line 456 of file path.c.

{
  TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
  return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
}

Referenced by DoEntry(), PathResolveW(), and SHELL_FindExecutable().

PathFindSuffixArrayA()

LPCSTR WINAPI PathFindSuffixArrayA	(	LPCSTR	lpszSuffix,
		LPCSTR *	lppszArray,
		int	dwCount
	)

Definition at line 1449 of file path.c.

{
  size_t dwLen;
  int dwRet = 0;
 
  TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
 
  if (lpszSuffix && lppszArray && dwCount > 0)
  {
    dwLen = strlen(lpszSuffix);
 
    while (dwRet < dwCount)
    {
      size_t dwCompareLen = strlen(*lppszArray);
      if (dwCompareLen < dwLen)
      {
        if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
          return *lppszArray; /* Found */
      }
      dwRet++;
      lppszArray++;
    }
  }
  return NULL;
}

PathFindSuffixArrayW()

LPCWSTR WINAPI PathFindSuffixArrayW	(	LPCWSTR	lpszSuffix,
		LPCWSTR *	lppszArray,
		int	dwCount
	)

Definition at line 1480 of file path.c.

{
  size_t dwLen;
  int dwRet = 0;
 
  TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
 
  if (lpszSuffix && lppszArray && dwCount > 0)
  {
    dwLen = lstrlenW(lpszSuffix);
 
    while (dwRet < dwCount)
    {
      size_t dwCompareLen = lstrlenW(*lppszArray);
      if (dwCompareLen < dwLen)
      {
        if (!wcscmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
          return *lppszArray; /* Found */
      }
      dwRet++;
      lppszArray++;
    }
  }
  return NULL;
}

PathIsContentTypeA()

BOOL WINAPI PathIsContentTypeA	(	LPCSTR	path,
		LPCSTR	content_type
	)

Definition at line 783 of file path.c.

{
    char buf[MAX_PATH];
    DWORD size = sizeof(buf);
    LPCSTR ext;
 
    TRACE("(%s,%s)\n", debugstr_a(path), debugstr_a(content_type));
 
    if(!path) return FALSE;
    if(!(ext = PathFindExtensionA(path)) || !*ext) return FALSE;
    if(SHGetValueA(HKEY_CLASSES_ROOT, ext, "Content Type", NULL, buf, &size)) return FALSE;
    return !lstrcmpiA(content_type, buf);
}

PathIsContentTypeW()

BOOL WINAPI PathIsContentTypeW	(	LPCWSTR	lpszPath,
		LPCWSTR	lpszContentType
	)

Definition at line 802 of file path.c.

{
  static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
  LPCWSTR szExt;
  DWORD dwDummy;
  WCHAR szBuff[MAX_PATH];
 
  TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
 
  if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
      !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
                   REG_NONE, szBuff, &dwDummy) &&
      !wcsicmp(lpszContentType, szBuff))
  {
    return TRUE;
  }
  return FALSE;
}

PathIsDirectoryA()

BOOL WINAPI PathIsDirectoryA

(

LPCSTR

lpszPath

)

Definition at line 625 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath || PathIsUNCServerA(lpszPath))
    return FALSE;
 
  if (PathIsUNCServerShareA(lpszPath))
  {
#ifdef __REACTOS__
    LPSTR lpSystem = NULL;
    BYTE buffer[512] = {0};
    DWORD cbBuffer = sizeof(buffer);
    LPNETRESOURCEA pNetRes = (LPNETRESOURCEA)buffer;
    DWORD dwError;
 
    pNetRes->dwScope      = RESOURCE_GLOBALNET;
    pNetRes->dwType       = RESOURCETYPE_ANY;
    pNetRes->lpRemoteName = (LPSTR)lpszPath;
 
    dwError = WNetGetResourceInformationA(pNetRes, pNetRes, &cbBuffer, &lpSystem);
    if (dwError == NO_ERROR && pNetRes->dwDisplayType != RESOURCEDISPLAYTYPE_GENERIC)
    {
      return (pNetRes->dwDisplayType == RESOURCEDISPLAYTYPE_SHARE) &&
             (pNetRes->dwType == RESOURCETYPE_ANY || pNetRes->dwType == RESOURCETYPE_DISK);
    }
#else
    FIXME("UNC Server Share not yet supported - FAILING\n");
    return FALSE;
#endif
  }
 
  if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}

Referenced by ATL::CPathT< StringType >::PathIsDirectoryX().

PathIsDirectoryEmptyA()

BOOL WINAPI PathIsDirectoryEmptyA

(

LPCSTR

lpszPath

)

Definition at line 1367 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathIsDirectoryEmptyW(szPath);
  }
  return bRet;
}

PathIsDirectoryEmptyW()

BOOL WINAPI PathIsDirectoryEmptyW

(

LPCWSTR

lpszPath

)

Definition at line 1387 of file path.c.

{
  static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
  WCHAR szSearch[MAX_PATH];
  DWORD dwLen;
  HANDLE hfind;
  BOOL retVal = TRUE;
  WIN32_FIND_DATAW find_data;
 
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if (!lpszPath || !PathIsDirectoryW(lpszPath))
    return FALSE;
 
  lstrcpynW(szSearch, lpszPath, MAX_PATH);
  PathAddBackslashW(szSearch);
  dwLen = lstrlenW(szSearch);
  if (dwLen > MAX_PATH - 4)
    return FALSE;
 
  lstrcpyW(szSearch + dwLen, szAllFiles);
  hfind = FindFirstFileW(szSearch, &find_data);
  if (hfind == INVALID_HANDLE_VALUE)
    return FALSE;
 
  do
  {
    if (find_data.cFileName[0] == '.')
    {
      if (find_data.cFileName[1] == '\0') continue;
      if (find_data.cFileName[1] == '.' && find_data.cFileName[2] == '\0') continue;
    }
 
    retVal = FALSE;
    break;
  }
  while (FindNextFileW(hfind, &find_data));
 
  FindClose(hfind);
  return retVal;
}

Referenced by move_dir_to_dir(), and PathIsDirectoryEmptyA().

PathIsDirectoryW()

BOOL WINAPI PathIsDirectoryW

(

LPCWSTR

lpszPath

)

Definition at line 669 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || PathIsUNCServerW(lpszPath))
    return FALSE;
 
  if (PathIsUNCServerShareW(lpszPath))
  {
#ifdef __REACTOS__
    LPWSTR lpSystem = NULL;
    BYTE buffer[1024] = {0};
    DWORD cbBuffer = sizeof(buffer);
    LPNETRESOURCEW pNetRes = (LPNETRESOURCEW)buffer;
    DWORD dwError;
 
    pNetRes->dwScope      = RESOURCE_GLOBALNET;
    pNetRes->dwType       = RESOURCETYPE_ANY;
    pNetRes->lpRemoteName = (LPWSTR)lpszPath;
 
    dwError = WNetGetResourceInformationW(pNetRes, pNetRes, &cbBuffer, &lpSystem);
    if (dwError == NO_ERROR && pNetRes->dwDisplayType != RESOURCEDISPLAYTYPE_GENERIC)
    {
      return (pNetRes->dwDisplayType == RESOURCEDISPLAYTYPE_SHARE) &&
             (pNetRes->dwType == RESOURCETYPE_ANY || pNetRes->dwType == RESOURCETYPE_DISK);
    }
#else
    FIXME("UNC Server Share not yet supported - FAILING\n");
    return FALSE;
#endif
  }
 
  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
  return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
}

Referenced by CDirectoryList::AddPathsFromDirectory(), BrFolder_OnOK(), copy_file(), create_target_directory(), CreateDirectoryWatcherFromRegEntry(), DetermineDialogBoxType(), CAppScrnshotPreview::DisplayImage(), DoAddFilesFromItem(), DoBuildFilesAndDirs(), DoTestEntry(), CDeskLinkDropHandler::Drop(), CAddressEditBox::ExecuteCommandLine(), FILEDLG95_InitControls(), CFSFolder::GetCustomViewInfo(), getIconLocationForFolder(), CFileDefExt::Initialize(), InstallFontFiles(), PathIsDirectoryEmptyW(), ATL::CPathT< StringType >::PathIsDirectoryX(), CDirectoryWatcher::ProcessNotification(), SHAddToRecentDocs(), SHELL_execute(), SHExplorerParseCmdLine(), ShowCreateShortcutWizard(), WindowProc(), and wWinMain().

PathIsNetworkPathA()

BOOL WINAPI PathIsNetworkPathA

(

LPCSTR

lpszPath

)

Definition at line 1308 of file path.c.

{
  int dwDriveNum;
 
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
    return TRUE;
  dwDriveNum = PathGetDriveNumberA(lpszPath);
  if (dwDriveNum == -1)
    return FALSE;
#ifdef __REACTOS__
  return IsNetDrive(dwDriveNum);
#else
  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
  return pIsNetDrive(dwDriveNum);
#endif
}

PathIsNetworkPathW()

BOOL WINAPI PathIsNetworkPathW

(

LPCWSTR

lpszPath

)

Definition at line 1334 of file path.c.

{
  int dwDriveNum;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath)
    return FALSE;
  if (*lpszPath == '\\' && lpszPath[1] == '\\')
    return TRUE;
  dwDriveNum = PathGetDriveNumberW(lpszPath);
  if (dwDriveNum == -1)
    return FALSE;
#ifdef __REACTOS__
  return IsNetDrive(dwDriveNum);
#else
  GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
  return pIsNetDrive(dwDriveNum);
#endif
}

PathIsSystemFolderA()

BOOL WINAPI PathIsSystemFolderA	(	LPCSTR	lpszPath,
		DWORD	dwAttrib
	)

Definition at line 834 of file path.c.

{
  TRACE("(%s,0x%08lx)\n", debugstr_a(lpszPath), dwAttrib);
 
  if (lpszPath && *lpszPath)
    dwAttrib = GetFileAttributesA(lpszPath);
 
  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
    return FALSE;
  return TRUE;
}

PathIsSystemFolderW()

BOOL WINAPI PathIsSystemFolderW	(	LPCWSTR	lpszPath,
		DWORD	dwAttrib
	)

Definition at line 852 of file path.c.

{
  TRACE("(%s,0x%08lx)\n", debugstr_w(lpszPath), dwAttrib);
 
  if (lpszPath && *lpszPath)
    dwAttrib = GetFileAttributesW(lpszPath);
 
  if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
      !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
    return FALSE;
  return TRUE;
}

Referenced by CViewStatePropertyBag::_IsSystemFolder().

PathMakePrettyA()

BOOL WINAPI PathMakePrettyA

(

LPSTR

lpszPath

)

Definition at line 877 of file path.c.

{
  LPSTR pszIter = lpszPath;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!pszIter)
    return FALSE;
 
  if (*pszIter)
  {
    do
    {
      if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
        return FALSE; /* Not DOS path */
      pszIter++;
    } while (*pszIter);
    pszIter = lpszPath + 1;
    while (*pszIter)
    {
      *pszIter = tolower(*pszIter);
      pszIter++;
    }
  }
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathMakePrettyX(), and test_PathMakePretty().

PathMakePrettyW()

BOOL WINAPI PathMakePrettyW

(

LPWSTR

lpszPath

)

Definition at line 909 of file path.c.

{
  LPWSTR pszIter = lpszPath;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!pszIter)
    return FALSE;
 
  if (*pszIter)
  {
    do
    {
      if (iswlower(*pszIter))
        return FALSE; /* Not DOS path */
      pszIter++;
    } while (*pszIter);
    pszIter = lpszPath + 1;
    while (*pszIter)
    {
      *pszIter = towlower(*pszIter);
      pszIter++;
    }
  }
  return TRUE;
}

Referenced by ATL::CPathT< StringType >::PathMakePrettyX().

PathMakeSystemFolderA()

BOOL WINAPI PathMakeSystemFolderA

(

LPCSTR

lpszPath

)

Definition at line 1130 of file path.c.

{
  BOOL bRet = FALSE;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (lpszPath && *lpszPath)
  {
    WCHAR szPath[MAX_PATH];
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
    bRet = PathMakeSystemFolderW(szPath);
  }
  return bRet;
}

PathMakeSystemFolderW()

BOOL WINAPI PathMakeSystemFolderW

(

LPCWSTR

lpszPath

)

Definition at line 1150 of file path.c.

{
  DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath)
    return FALSE;
 
  /* If the directory is already a system directory, don't do anything */
  GetSystemDirectoryW(buff, MAX_PATH);
  if (!wcscmp(buff, lpszPath))
    return TRUE;
 
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!wcscmp(buff, lpszPath))
    return TRUE;
 
  /* "UseSystemForSystemFolders" Tells Win what attributes to use */
  if (SHLWAPI_UseSystemForSystemFolders())
    dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
 
  if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
    return FALSE;
 
  /* Change file attributes to system attributes */
  dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
  return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
}

Referenced by PathMakeSystemFolderA(), and SHCreatePropertyBagOnProfileSection().

PathRemoveArgsA()

void WINAPI PathRemoveArgsA

(

LPSTR

lpszPath

)

Definition at line 130 of file path.c.

{
  TRACE("(%s)\n",debugstr_a(lpszPath));
 
  if(lpszPath)
  {
    LPSTR lpszArgs = PathGetArgsA(lpszPath);
    if (*lpszArgs)
      lpszArgs[-1] = '\0';
    else
    {
      LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
      if(*lpszLastChar == ' ')
        *lpszLastChar = '\0';
    }
  }
}

Referenced by ATL::CPathT< StringType >::PathRemoveArgsX().

PathRemoveArgsW()

void WINAPI PathRemoveArgsW

(

LPWSTR

lpszPath

)

Definition at line 153 of file path.c.

{
  TRACE("(%s)\n",debugstr_w(lpszPath));
 
  if(lpszPath)
  {
    LPWSTR lpszArgs = PathGetArgsW(lpszPath);
    if (*lpszArgs || (lpszArgs > lpszPath && lpszArgs[-1] == ' '))
      lpszArgs[-1] = '\0';
  }
}

Referenced by RunOnceExEntry::Exec(), CAddressEditBox::ExecuteCommandLine(), CShellLink::OnNotify(), OpensWithExplorer(), ATL::CPathT< StringType >::PathRemoveArgsX(), SHELL_execute(), SHELL_translate_idlist(), ShellExecuteCommand(), and WelcomeDlgProc().

PathSetDlgItemPathA()

VOID WINAPI PathSetDlgItemPathA	(	HWND	hDlg,
		int	id,
		LPCSTR	lpszPath
	)

Definition at line 1246 of file path.c.

{
  WCHAR szPath[MAX_PATH];
 
  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
 
  if (lpszPath)
    MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
  else
    szPath[0] = '\0';
  PathSetDlgItemPathW(hDlg, id, szPath);
}

PathSetDlgItemPathW()

VOID WINAPI PathSetDlgItemPathW	(	HWND	hDlg,
		int	id,
		LPCWSTR	lpszPath
	)

Definition at line 1264 of file path.c.

{
  WCHAR path[MAX_PATH + 1];
  HWND hwItem;
  RECT rect;
  HDC hdc;
  HGDIOBJ hPrevObj;
 
  TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
 
  if (!(hwItem = GetDlgItem(hDlg, id)))
    return;
 
  if (lpszPath)
    lstrcpynW(path, lpszPath, ARRAY_SIZE(path));
  else
    path[0] = '\0';
 
  GetClientRect(hwItem, &rect);
  hdc = GetDC(hDlg);
  hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
 
  if (hPrevObj)
  {
    PathCompactPathW(hdc, path, rect.right);
    SelectObject(hdc, hPrevObj);
  }
 
  ReleaseDC(hDlg, hdc);
  SetWindowTextW(hwItem, path);
}

Referenced by PathSetDlgItemPathA().

PathUndecorateA()

void WINAPI PathUndecorateA

(

char *

path

)

Definition at line 1520 of file path.c.

{
  char *ext, *skip;
 
  TRACE("(%s)\n", debugstr_a(path));
 
  if (!path) return;
 
  ext = PathFindExtensionA(path);
  if (ext == path || ext[-1] != ']') return;
 
  skip = ext - 2;
  while (skip > path && '0' <= *skip && *skip <= '9')
      skip--;
 
  if (skip > path && *skip == '[' && skip[-1] != '\\')
      memmove(skip, ext, strlen(ext) + 1);
}

Referenced by test_PathUndecorate().

PathUndecorateW()

void WINAPI PathUndecorateW

(

WCHAR *

path

)

Definition at line 1544 of file path.c.

{
  WCHAR *ext, *skip;
 
  TRACE("(%s)\n", debugstr_w(path));
 
  if (!path) return;
 
  ext = PathFindExtensionW(path);
  if (ext == path || ext[-1] != ']') return;
 
  skip = ext - 2;
  while (skip > path && '0' <= *skip && *skip <= '9')
      skip--;
 
  if (skip > path && *skip == '[' && skip[-1] != '\\')
      memmove(skip, ext, (wcslen(ext) + 1) * sizeof(WCHAR));
}

Referenced by test_PathUndecorate().

PathUnmakeSystemFolderA()

BOOL WINAPI PathUnmakeSystemFolderA

(

LPCSTR

lpszPath

)

Definition at line 1194 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_a(lpszPath));
 
  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
      !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
    return FALSE;
 
  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  return SetFileAttributesA(lpszPath, dwAttr);
}

PathUnmakeSystemFolderW()

BOOL WINAPI PathUnmakeSystemFolderW

(

LPCWSTR

lpszPath

)

Definition at line 1213 of file path.c.

{
  DWORD dwAttr;
 
  TRACE("(%s)\n", debugstr_w(lpszPath));
 
  if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
    !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
    return FALSE;
 
  dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  return SetFileAttributesW(lpszPath, dwAttr);
}

SHGetWebFolderFilePathA()

HRESULT WINAPI SHGetWebFolderFilePathA	(	LPCSTR	lpszFile,
		LPSTR	lpszPath,
		DWORD	dwPathLen
	)

Definition at line 1577 of file path.c.

{
  WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
  HRESULT hRet;
 
  TRACE("(%s,%p,%ld)\n", lpszFile, lpszPath, dwPathLen);
 
  MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
  szPath[0] = '\0';
  hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
  WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
  return hRet;
}

SHGetWebFolderFilePathW()

HRESULT WINAPI SHGetWebFolderFilePathW	(	LPCWSTR	lpszFile,
		LPWSTR	lpszPath,
		DWORD	dwPathLen
	)

Definition at line 1596 of file path.c.

{
  static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'};
  static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'};
  DWORD dwLen, dwFileLen;
  LANGID lidSystem, lidUser;
 
  TRACE("(%s,%p,%ld)\n", debugstr_w(lpszFile), lpszPath, dwPathLen);
 
  /* Get base directory for web content */
  dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
  if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
    dwLen--;
 
  dwFileLen = lstrlenW(lpszFile);
 
  if (dwLen + dwFileLen + ARRAY_SIZE(szWeb) >= dwPathLen)
    return E_FAIL; /* lpszPath too short */
 
  lstrcpyW(lpszPath+dwLen, szWeb);
  dwLen += ARRAY_SIZE(szWeb);
  dwPathLen = dwPathLen - dwLen; /* Remaining space */
 
  lidSystem = GetSystemDefaultUILanguage();
  lidUser = GetUserDefaultUILanguage();
 
  if (lidSystem != lidUser)
  {
    if (dwFileLen + ARRAY_SIZE(szWebMui) < dwPathLen)
    {
      /* Use localised content in the users UI language if present */
      wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
      lstrcpyW(lpszPath + dwLen + ARRAY_SIZE(szWebMui), lpszFile);
      if (PathFileExistsW(lpszPath))
        return S_OK;
    }
  }
 
  /* Fall back to OS default installed content */
  lstrcpyW(lpszPath + dwLen, lpszFile);
  if (PathFileExistsW(lpszPath))
    return S_OK;
  return E_FAIL;
}

Referenced by SHGetWebFolderFilePathA().

SHLWAPI_PathFindInOtherDirs()

static BOOL SHLWAPI_PathFindInOtherDirs ( LPWSTR  lpszFile, DWORD  dwWhich  )

static

Definition at line 270 of file path.c.

{
  static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
  static const WCHAR szPath[] = { 'P','A','T','H','\0'};
  DWORD dwLenPATH;
  LPCWSTR lpszCurr;
  WCHAR *lpszPATH;
  WCHAR buff[MAX_PATH];
 
  TRACE("(%s,%08lx)\n", debugstr_w(lpszFile), dwWhich);
 
  /* Try system directories */
  GetSystemDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, lpszFile))
     return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    lstrcpyW(lpszFile, buff);
    return TRUE;
  }
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
    return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    lstrcpyW(lpszFile, buff);
    return TRUE;
  }
  GetWindowsDirectoryW(buff, MAX_PATH);
  if (!PathAppendW(buff, lpszFile))
    return FALSE;
  if (PathFileExistsDefExtW(buff, dwWhich))
  {
    lstrcpyW(lpszFile, buff);
    return TRUE;
  }
  /* Try dirs listed in %PATH% */
  dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
 
  if (!dwLenPATH || !(lpszPATH = malloc((dwLenPATH + 1) * sizeof (WCHAR))))
    return FALSE;
 
  GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
  lpszCurr = lpszPATH;
  while (lpszCurr)
  {
    LPCWSTR lpszEnd = lpszCurr;
    LPWSTR pBuff = buff;
 
    while (*lpszEnd == ' ')
      lpszEnd++;
    while (*lpszEnd && *lpszEnd != ';')
      *pBuff++ = *lpszEnd++;
    *pBuff = '\0';
 
    if (*lpszEnd)
      lpszCurr = lpszEnd + 1;
    else
      lpszCurr = NULL; /* Last Path, terminate after this */
 
    if (!PathAppendW(buff, lpszFile))
    {
      free(lpszPATH);
      return FALSE;
    }
    if (PathFileExistsDefExtW(buff, dwWhich))
    {
      lstrcpyW(lpszFile, buff);
      free(lpszPATH);
      return TRUE;
    }
  }
  free(lpszPATH);
  return FALSE;
}

Referenced by PathFindOnPathExA(), and PathFindOnPathExW().

SHLWAPI_UseSystemForSystemFolders()

static BOOL SHLWAPI_UseSystemForSystemFolders ( void  )

static

Definition at line 1100 of file path.c.

{
  static BOOL bCheckedReg = FALSE;
  static BOOL bUseSystemForSystemFolders = FALSE;
 
  if (!bCheckedReg)
  {
    bCheckedReg = TRUE;
 
    /* Key tells Win what file attributes to use on system folders */
    if (SHGetValueA(HKEY_LOCAL_MACHINE,
        "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
        "UseSystemForSystemFolders", 0, 0, 0))
      bUseSystemForSystemFolders = TRUE;
  }
  return bUseSystemForSystemFolders;
}

Referenced by PathMakeSystemFolderW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

pIsNetDrive

fnpIsNetDrive pIsNetDrive

static

Definition at line 66 of file path.c.

Referenced by PathIsNetworkPathA(), and PathIsNetworkPathW().

SHLWAPI_hshell32

HMODULE SHLWAPI_hshell32

static

Definition at line 62 of file path.c.