#include <wine/config.h>
#include <windef.h>
#include <winbase.h>
#include <shlobj.h>
#include <undocshell.h>
#include <shlwapi.h>
#include <sddl.h>
#include <strsafe.h>
#include <wine/debug.h>
#include <wine/unicode.h>
#include <shlwapi_undoc.h>
#include <shellutils.h>
#include <userenv.h>
#include "pidl.h"
#include "shell32_main.h"
#include "shresdef.h"

Include dependency graph for shellpath.c:

Classes
struct	CSIDL_DATA

Macros
#define	WIN32_NO_STATUS

#define	_INC_WINDOWS

#define	COBJMACROS

#define	CSIDL_CONTACTS 0x0043

#define	CSIDL_DOWNLOADS 0x0047

#define	CSIDL_LINKS 0x004d

#define	CSIDL_APPDATA_LOCALLOW 0x004e

#define	CSIDL_SAVED_GAMES 0x0062

#define	CSIDL_SEARCHES 0x0063

Typedefs
typedef enum _CSIDL_Type	CSIDL_Type

Enumerations
enum	_CSIDL_Type { CSIDL_Type_User, CSIDL_Type_AllUsers, CSIDL_Type_CurrVer, CSIDL_Type_Disallowed, CSIDL_Type_NonExistent, CSIDL_Type_WindowsPath, CSIDL_Type_SystemPath, CSIDL_Type_SystemX86Path }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)

BOOL WINAPI	PathAppendAW (LPVOID lpszPath1, LPCVOID lpszPath2)

static LPSTR	PathGetExtensionA (LPCSTR lpszPath)

static LPWSTR	PathGetExtensionW (LPCWSTR lpszPath)

LPVOID WINAPI	SHPathGetExtensionW (LPCWSTR lpszPath, DWORD void1, DWORD void2)

BOOL WINAPI	PathRemoveFileSpecAW (LPVOID lpszPath)

static void	PathGetShortPathA (LPSTR pszPath)

static void	PathGetShortPathW (LPWSTR pszPath)

VOID WINAPI	PathGetShortPathAW (LPVOID pszPath)

BOOL WINAPI	PathIsRootAW (LPCVOID lpszPath)

static BOOL	PathIsExeA (LPCSTR lpszPath)

BOOL	PathIsExeW (LPCWSTR lpszPath)

BOOL WINAPI	PathIsExeAW (LPCVOID path)

BOOL WINAPI	PathFileExistsAW (LPCVOID lpszPath)

BOOL WINAPI	IsLFNDriveA (LPCSTR lpszPath)

BOOL WINAPI	IsLFNDriveW (LPCWSTR lpszPath)

BOOL WINAPI	IsLFNDriveAW (LPCVOID lpszPath)

static BOOL	PathMakeUniqueNameA (LPSTR lpszBuffer, DWORD dwBuffSize, LPCSTR lpszShortName, LPCSTR lpszLongName, LPCSTR lpszPathName)

static BOOL	PathMakeUniqueNameW (LPWSTR lpszBuffer, DWORD dwBuffSize, LPCWSTR lpszShortName, LPCWSTR lpszLongName, LPCWSTR lpszPathName)

BOOL WINAPI	PathMakeUniqueNameAW (LPVOID lpszBuffer, DWORD dwBuffSize, LPCVOID lpszShortName, LPCVOID lpszLongName, LPCVOID lpszPathName)

BOOL WINAPI	PathYetAnotherMakeUniqueName (LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)

int WINAPI	PathCleanupSpec (LPCWSTR lpszPathW, LPWSTR lpszFileW)

static BOOL	PathQualifyA (LPCSTR pszPath)

static BOOL	PathQualifyW (LPCWSTR pszPath)

BOOL WINAPI	PathQualifyAW (LPCVOID pszPath)

static BOOL	PathResolveA (LPSTR path, LPCSTR *paths, DWORD flags)

static BOOL	PathResolveW (LPWSTR path, LPCWSTR *paths, DWORD flags)

BOOL WINAPI	PathResolveAW (LPVOID path, LPCVOID *paths, DWORD flags)

static LONG	PathProcessCommandA (LPCSTR lpszPath, LPSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

static LONG	PathProcessCommandW (LPCWSTR lpszPath, LPWSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

LONG WINAPI	PathProcessCommandAW (LPCVOID lpszPath, LPVOID lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

static HRESULT	_SHExpandEnvironmentStrings (LPCWSTR szSrc, LPWSTR szDest)

static HRESULT	_SHGetUserShellFolderPath (HKEY rootKey, LPCWSTR userPrefix, LPCWSTR value, LPWSTR path)

BOOL	_SHGetUserProfileDirectoryW (HANDLE hToken, LPWSTR szPath, LPDWORD lpcchPath)

static HRESULT	_SHGetDefaultValue (BYTE folder, LPWSTR pszPath)

static HRESULT	_SHGetCurrentVersionPath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static LPWSTR	_GetUserSidStringFromToken (HANDLE Token)

static HRESULT	_SHGetUserProfilePath (HANDLE hToken, DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static HRESULT	_SHGetAllUsersProfilePath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static HRESULT	_SHOpenProfilesKey (PHKEY pKey)

static HRESULT	_SHGetProfilesValue (HKEY profilesKey, LPCWSTR szValueName, LPWSTR szValue, LPCWSTR szDefault)

HRESULT WINAPI	SHGetFolderPathW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath)

HRESULT WINAPI	SHGetFolderPathAndSubDirA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubPath, LPSTR pszPath)

HRESULT WINAPI	SHGetFolderPathAndSubDirW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubPath, LPWSTR pszPath)

HRESULT WINAPI	SHGetFolderPathA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPSTR pszPath)

static HRESULT	_SHRegisterFolders (HKEY hRootKey, HANDLE hToken, LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[], UINT foldersLen)

static HRESULT	_SHRegisterUserShellFolders (BOOL bDefault)

static HRESULT	_SHRegisterCommonShellFolders (void)

HRESULT	SHELL_RegisterShellFolders (void)

BOOL WINAPI	SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)

BOOL WINAPI	SHGetSpecialFolderPathW (HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)

HRESULT WINAPI	SHGetFolderLocation (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)

HRESULT WINAPI	SHGetSpecialFolderLocation (HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)

Variables
static const BOOL	is_win64 = sizeof(void *) > sizeof(int)

static const WCHAR	szCurrentVersion [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0'}

static const WCHAR	Administrative_ToolsW [] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static const WCHAR	AppDataW [] = {'A','p','p','D','a','t','a','\0'}

static const WCHAR	AppData_LocalLowW [] = {'A','p','p','D','a','t','a','\\','L','o','c','a','l','L','o','w','\0'}

static const WCHAR	Application_DataW [] = {'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static const WCHAR	CacheW [] = {'C','a','c','h','e','\0'}

static const WCHAR	CD_BurningW [] = {'C','D',' ','B','u','r','n','i','n','g','\0'}

static const WCHAR	Common_Administrative_ToolsW [] = {'C','o','m','m','o','n',' ','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static const WCHAR	Common_AppDataW [] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'}

static const WCHAR	Common_DesktopW [] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'}

static const WCHAR	Common_DocumentsW [] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'}

static const WCHAR	Common_FavoritesW [] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'}

static const WCHAR	CommonFilesDirW [] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'}

static const WCHAR	CommonFilesDirX86W [] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'}

static const WCHAR	CommonMusicW [] = {'C','o','m','m','o','n','M','u','s','i','c','\0'}

static const WCHAR	CommonPicturesW [] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Common_ProgramsW [] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'}

static const WCHAR	Common_StartUpW [] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'}

static const WCHAR	Common_Start_MenuW [] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'}

static const WCHAR	Common_TemplatesW [] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'}

static const WCHAR	CommonVideoW [] = {'C','o','m','m','o','n','V','i','d','e','o','\0'}

static const WCHAR	ContactsW [] = {'C','o','n','t','a','c','t','s','\0'}

static const WCHAR	CookiesW [] = {'C','o','o','k','i','e','s','\0'}

static const WCHAR	DesktopW [] = {'D','e','s','k','t','o','p','\0'}

static const WCHAR	DocumentsW [] = {'D','o','c','u','m','e','n','t','s','\0'}

static const WCHAR	DownloadsW [] = {'D','o','w','n','l','o','a','d','s','\0'}

static const WCHAR	FavoritesW [] = {'F','a','v','o','r','i','t','e','s','\0'}

static const WCHAR	FontsW [] = {'F','o','n','t','s','\0'}

static const WCHAR	HistoryW [] = {'H','i','s','t','o','r','y','\0'}

static const WCHAR	LinksW [] = {'L','i','n','k','s','\0'}

static const WCHAR	Local_AppDataW [] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'}

static const WCHAR	Local_Settings_Application_DataW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static const WCHAR	Local_Settings_CD_BurningW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\\','M','i','c','r','o','s','o','f','t','\\','C','D',' ','B','u','r','n','i','n','g','\0'}

static const WCHAR	Local_Settings_HistoryW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','H','i','s','t','o','r','y','\0'}

static const WCHAR	Local_Settings_Temporary_Internet_FilesW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','T','e','m','p','o','r','a','r','y',' ','I','n','t','e','r','n','e','t',' ','F','i','l','e','s','\0'}

static const WCHAR	Microsoft_Windows_GameExplorerW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','G','a','m','e','E','x','p','l','o','r','e','r','\0'}

static const WCHAR	Microsoft_Windows_LibrariesW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','L','i','b','r','a','r','i','e','s','\0'}

static const WCHAR	Microsoft_Windows_RingtonesW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','R','i','n','g','t','o','n','e','s','\0'}

static const WCHAR	MusicW [] = {'M','u','s','i','c','\0'}

static const WCHAR	Music_PlaylistsW [] = {'M','u','s','i','c','\\','P','l','a','y','l','i','s','t','s','\0'}

static const WCHAR	Music_Sample_MusicW [] = {'M','u','s','i','c','\\','S','a','m','p','l','e',' ','M','u','s','i','c','\0'}

static const WCHAR	Music_Sample_PlaylistsW [] = {'M','u','s','i','c','\\','S','a','m','p','l','e',' ','P','l','a','y','l','i','s','t','s','\0'}

static const WCHAR	My_MusicW [] = {'M','y',' ','M','u','s','i','c','\0'}

static const WCHAR	My_PicturesW [] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	My_VideoW [] = {'M','y',' ','V','i','d','e','o','\0'}

static const WCHAR	NetHoodW [] = {'N','e','t','H','o','o','d','\0'}

static const WCHAR	OEM_LinksW [] = {'O','E','M',' ','L','i','n','k','s','\0'}

static const WCHAR	PersonalW [] = {'P','e','r','s','o','n','a','l','\0'}

static const WCHAR	PicturesW [] = {'P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Pictures_Sample_PicturesW [] = {'P','i','c','t','u','r','e','s','\\','S','a','m','p','l','e',' ','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Pictures_Slide_ShowsW [] = {'P','i','c','t','u','r','e','s','\\','S','l','i','d','e',' ','S','h','o','w','s','\0'}

static const WCHAR	PrintHoodW [] = {'P','r','i','n','t','H','o','o','d','\0'}

static const WCHAR	Program_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\0'}

static const WCHAR	Program_Files_Common_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'}

static const WCHAR	Program_Files_x86W [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\0'}

static const WCHAR	Program_Files_x86_Common_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'}

static const WCHAR	ProgramFilesDirW [] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'}

static const WCHAR	ProgramFilesDirX86W [] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'}

static const WCHAR	ProgramsW [] = {'P','r','o','g','r','a','m','s','\0'}

static const WCHAR	PublicW [] = {'P','u','b','l','i','c',0}

static const WCHAR	RecentW [] = {'R','e','c','e','n','t','\0'}

static const WCHAR	ResourcesW [] = {'R','e','s','o','u','r','c','e','s','\0'}

static const WCHAR	Saved_GamesW [] = {'S','a','v','e','d',' ','G','a','m','e','s','\0'}

static const WCHAR	SearchesW [] = {'S','e','a','r','c','h','e','s','\0'}

static const WCHAR	SendToW [] = {'S','e','n','d','T','o','\0'}

static const WCHAR	StartUpW [] = {'S','t','a','r','t','U','p','\0'}

static const WCHAR	Start_MenuW [] = {'S','t','a','r','t',' ','M','e','n','u','\0'}

static const WCHAR	Start_Menu_ProgramsW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\0'}

static const WCHAR	Start_Menu_Admin_ToolsW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static const WCHAR	Start_Menu_StartupW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\','S','t','a','r','t','U','p','\0'}

static const WCHAR	TemplatesW [] = {'T','e','m','p','l','a','t','e','s','\0'}

static const WCHAR	UsersW [] = {'U','s','e','r','s','\0'}

static const WCHAR	UsersPublicW [] = {'U','s','e','r','s','\\','P','u','b','l','i','c','\0'}

static const WCHAR	VideosW [] = {'V','i','d','e','o','s','\0'}

static const WCHAR	Videos_Sample_VideosW [] = {'V','i','d','e','o','s','\\','S','a','m','p','l','e',' ','V','i','d','e','o','s','\0'}

static const WCHAR	DefaultW [] = {'.','D','e','f','a','u','l','t','\0'}

static const WCHAR	AllUsersProfileW [] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'}

static const WCHAR	PublicProfileW [] = {'%','P','U','B','L','I','C','%',0}

static const WCHAR	UserProfileW [] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'}

static const WCHAR	SystemDriveW [] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'}

static const WCHAR	ProfileListW [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','P','r','o','f','i','l','e','L','i','s','t',0}

static const WCHAR	ProfilesDirectoryW [] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0}

static const WCHAR	AllUsersProfileValueW [] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'}

static const WCHAR	szSHFolders [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'}

static const WCHAR	szSHUserFolders [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'}

static const WCHAR	szDefaultProfileDirW [] = {'u','s','e','r','s',0}

static const WCHAR	szKnownFolderDescriptions [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','F','o','l','d','e','r','D','e','s','c','r','i','p','t','i','o','n','s','\0'}

static const WCHAR	szKnownFolderRedirections [] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s',0}

static const WCHAR	AllUsersW [] = {'P','u','b','l','i','c',0}

static const CSIDL_DATA	CSIDL_Data []

Macro Definition Documentation

◆ _INC_WINDOWS

#define _INC_WINDOWS

Definition at line 29 of file shellpath.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 30 of file shellpath.c.

◆ CSIDL_APPDATA_LOCALLOW

#define CSIDL_APPDATA_LOCALLOW 0x004e

Definition at line 665 of file shellpath.c.

◆ CSIDL_CONTACTS

#define CSIDL_CONTACTS 0x0043

Definition at line 662 of file shellpath.c.

◆ CSIDL_DOWNLOADS

#define CSIDL_DOWNLOADS 0x0047

Definition at line 663 of file shellpath.c.

◆ CSIDL_LINKS

#define CSIDL_LINKS 0x004d

Definition at line 664 of file shellpath.c.

◆ CSIDL_SAVED_GAMES

#define CSIDL_SAVED_GAMES 0x0062

Definition at line 666 of file shellpath.c.

◆ CSIDL_SEARCHES

#define CSIDL_SEARCHES 0x0063

Definition at line 667 of file shellpath.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file shellpath.c.

Typedef Documentation

◆ CSIDL_Type

typedef enum _CSIDL_Type CSIDL_Type

Enumeration Type Documentation

◆ _CSIDL_Type

enum _CSIDL_Type

Enumerator
CSIDL_Type_User
CSIDL_Type_AllUsers
CSIDL_Type_CurrVer
CSIDL_Type_Disallowed
CSIDL_Type_NonExistent
CSIDL_Type_WindowsPath
CSIDL_Type_SystemPath
CSIDL_Type_SystemX86Path

Definition at line 649 of file shellpath.c.

                          {
     CSIDL_Type_User,
     CSIDL_Type_AllUsers,
     CSIDL_Type_CurrVer,
     CSIDL_Type_Disallowed,
     CSIDL_Type_NonExistent,
     CSIDL_Type_WindowsPath,
     CSIDL_Type_SystemPath,
     CSIDL_Type_SystemX86Path,
 } CSIDL_Type;

Function Documentation

◆ _GetUserSidStringFromToken()

static LPWSTR _GetUserSidStringFromToken ( HANDLE Token )

static

Definition at line 1707 of file shellpath.c.

 {
     char InfoBuffer[64];
     PTOKEN_USER UserInfo;
     DWORD InfoSize;
     LPWSTR SidStr;
 
     UserInfo = (PTOKEN_USER) InfoBuffer;
     if (! GetTokenInformation(Token, TokenUser, InfoBuffer, sizeof(InfoBuffer),
                               &InfoSize))
     {
         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
             return NULL;
         UserInfo = HeapAlloc(GetProcessHeap(), 0, InfoSize);
         if (UserInfo == NULL)
             return NULL;
         if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
                                   &InfoSize))
         {
             HeapFree(GetProcessHeap(), 0, UserInfo);
             return NULL;
         }
     }
 
     if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
         SidStr = NULL;
 
     if (UserInfo != (PTOKEN_USER) InfoBuffer)
         HeapFree(GetProcessHeap(), 0, UserInfo);
 
     return SidStr;
 }

Referenced by _SHGetUserProfilePath().

◆ _SHExpandEnvironmentStrings()

static HRESULT _SHExpandEnvironmentStrings	(	LPCWSTR	szSrc,
		LPWSTR	szDest
	)

static

Definition at line 1934 of file shellpath.c.

 {
     HRESULT hr;
 #ifndef __REACTOS__
     WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 };
     HKEY key = NULL;
 #else
     WCHAR szTemp[MAX_PATH];
 #endif
 
     TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
 
     if (!szSrc || !szDest) return E_INVALIDARG;
 
     /* short-circuit if there's nothing to expand */
     if (szSrc[0] != '%')
     {
         strcpyW(szDest, szSrc);
         hr = S_OK;
         goto end;
     }
 #ifndef __REACTOS__
     /* Get the profile prefix, we'll probably be needing it */
     hr = _SHOpenProfilesKey(&key);
     if (SUCCEEDED(hr))
     {
         WCHAR def_val[MAX_PATH];
 
         /* get the system drive */
         GetSystemDirectoryW(def_val, MAX_PATH);
         strcpyW( def_val + 3, szDefaultProfileDirW );
 
         hr = _SHGetProfilesValue(key, ProfilesDirectoryW, szProfilesPrefix, def_val );
     }
 #else
     hr = S_OK;
 #endif
 
     *szDest = 0;
     strcpyW(szTemp, szSrc);
     while (SUCCEEDED(hr) && szTemp[0] == '%')
     {
         if (!strncmpiW(szTemp, AllUsersProfileW, strlenW(AllUsersProfileW)))
         {
 #ifndef __REACTOS__
             WCHAR szAllUsers[MAX_PATH];
 
             strcpyW(szDest, szProfilesPrefix);
             hr = _SHGetProfilesValue(key, AllUsersProfileValueW,
                                      szAllUsers, AllUsersW);
             PathAppendW(szDest, szAllUsers);
 #else
             DWORD cchSize = cchDest;
             if (!GetAllUsersProfileDirectoryW(szDest, &cchSize))
                 goto fallback_expand;
 #endif
             PathAppendW(szDest, szTemp + strlenW(AllUsersProfileW));
         }
 #ifndef __REACTOS__
         else if (!strncmpiW(szTemp, PublicProfileW, strlenW(PublicProfileW)))
         {
             WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
 
             GetSystemDirectoryW(def_val, MAX_PATH);
             strcpyW( def_val + 3, UsersPublicW );
 
             hr = _SHGetProfilesValue(key, PublicW, szAllUsers, def_val);
             PathAppendW(szDest, szAllUsers);
             PathAppendW(szDest, szTemp + strlenW(PublicProfileW));
         }
 #endif
         else if (!strncmpiW(szTemp, UserProfileW, strlenW(UserProfileW)))
         {
 #ifndef __REACTOS__
             WCHAR userName[MAX_PATH];
             DWORD userLen = MAX_PATH;
 
             strcpyW(szDest, szProfilesPrefix);
             GetUserNameW(userName, &userLen);
             PathAppendW(szDest, userName);
 #else
             DWORD cchSize = cchDest;
             if (!_SHGetUserProfileDirectoryW(hToken, szDest, &cchSize))
                 goto fallback_expand;
 #endif
             PathAppendW(szDest, szTemp + strlenW(UserProfileW));
         }
         else if (!strncmpiW(szTemp, SystemDriveW, strlenW(SystemDriveW)))
         {
 #ifndef __REACTOS__
             GetSystemDirectoryW(szDest, MAX_PATH);
 #else
             if (!GetSystemDirectoryW(szDest, cchDest))
                 goto fallback_expand;
 #endif
             strcpyW(szDest + 3, szTemp + strlenW(SystemDriveW) + 1);
         }
         else
 #ifdef __REACTOS__
 fallback_expand:
 #endif
         {
 #ifndef __REACTOS__
             DWORD ret = ExpandEnvironmentStringsW(szTemp, szDest, MAX_PATH);
 #else
             DWORD ret = SHExpandEnvironmentStringsForUserW(hToken, szTemp, szDest, cchDest);
 #endif
 
 #ifndef __REACTOS__
             if (ret > MAX_PATH)
 #else
             if (ret > cchDest)
 #endif
                 hr = E_NOT_SUFFICIENT_BUFFER;
             else if (ret == 0)
                 hr = HRESULT_FROM_WIN32(GetLastError());
             else if (!strcmpW( szTemp, szDest )) break;  /* nothing expanded */
         }
         if (SUCCEEDED(hr)) strcpyW(szTemp, szDest);
     }
 end:
 #ifndef __REACTOS__
     if (key)
         RegCloseKey(key);
 #endif
     TRACE("returning 0x%08x (input was %s, output is %s)\n", hr,
      debugstr_w(szSrc), debugstr_w(szDest));
     return hr;
 }

Referenced by _SHGetUserShellFolderPath(), and SHGetFolderPathAndSubDirW().

◆ _SHGetAllUsersProfilePath()

static HRESULT _SHGetAllUsersProfilePath	(	DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1829 of file shellpath.c.

 {
     HRESULT hr;
 
     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
         return E_INVALIDARG;
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     else
     {
 #ifndef __REACTOS__
         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
 #else
         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, NULL,
 #endif
          CSIDL_Data[folder].szValueName, pszPath);
         if (FAILED(hr))
 #ifndef __REACTOS__
             hr = _SHGetDefaultValue(folder, pszPath);
 #else
             hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     }
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

◆ _SHGetCurrentVersionPath()

static HRESULT _SHGetCurrentVersionPath	(	DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1638 of file shellpath.c.

 {
     HRESULT hr;
 
     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
         return E_INVALIDARG;
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     else
     {
         HKEY hKey;
 
         if (RegCreateKeyW(HKEY_LOCAL_MACHINE, szCurrentVersion, &hKey))
             hr = E_FAIL;
         else
         {
             DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
 
             if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
              &dwType, (LPBYTE)pszPath, &dwPathLen) ||
              (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
             {
 #ifndef __REACTOS__
                 hr = _SHGetDefaultValue(folder, pszPath);
 #else
                 hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
                 dwType = REG_EXPAND_SZ;
                 switch (folder)
                 {
                 case CSIDL_PROGRAM_FILESX86:
                 case CSIDL_PROGRAM_FILES_COMMONX86:
                     /* these two should never be set on 32-bit setups */
                     if (!is_win64)
                     {
                         BOOL is_wow64;
                         IsWow64Process( GetCurrentProcess(), &is_wow64 );
                         if (!is_wow64) break;
                     }
                     /* fall through */
                 default:
                     RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
                                    (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
                 }
             }
             else
             {
                 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
                 hr = S_OK;
             }
             RegCloseKey(hKey);
         }
     }
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by SHGetFolderPathAndSubDirW().

◆ _SHGetDefaultValue()

static HRESULT _SHGetDefaultValue	(	BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1545 of file shellpath.c.

 {
     HRESULT hr;
     WCHAR resourcePath[MAX_PATH];
 
     TRACE("0x%02x,%p\n", folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
 
     if (!pszPath)
         return E_INVALIDARG;
 
 #ifdef __REACTOS__
     if (hToken != NULL && hToken != (HANDLE)-1)
     {
         FIXME("unsupported for user other than current or default\n");
     }
 #endif
 
     if (!is_win64)
     {
         BOOL is_wow64;
 
         switch (folder)
         {
         case CSIDL_PROGRAM_FILES:
         case CSIDL_PROGRAM_FILESX86:
             IsWow64Process( GetCurrentProcess(), &is_wow64 );
             folder = is_wow64 ? CSIDL_PROGRAM_FILESX86 : CSIDL_PROGRAM_FILES;
             break;
         case CSIDL_PROGRAM_FILES_COMMON:
         case CSIDL_PROGRAM_FILES_COMMONX86:
             IsWow64Process( GetCurrentProcess(), &is_wow64 );
             folder = is_wow64 ? CSIDL_PROGRAM_FILES_COMMONX86 : CSIDL_PROGRAM_FILES_COMMON;
             break;
         }
     }
 
     switch (CSIDL_Data[folder].type)
     {
         case CSIDL_Type_User:
             strcpyW(pszPath, UserProfileW);
             break;
         case CSIDL_Type_AllUsers:
 #ifndef __REACTOS__
             strcpyW(pszPath, PublicProfileW);
 #else
             strcpyW(pszPath, AllUsersProfileW);
 #endif
             break;
         case CSIDL_Type_CurrVer:
             strcpyW(pszPath, SystemDriveW);
             break;
         default:
             ; /* no corresponding env. var, do nothing */
     }
 
     hr = S_OK;
     if (CSIDL_Data[folder].szDefaultPath)
     {
         if (IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
         {
             if (LoadStringW(shell32_hInstance,
                 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
             {
                 PathAppendW(pszPath, resourcePath);
             }
             else
             {
                 ERR("(%d,%s), LoadString failed, missing translation?\n", folder,
                       debugstr_w(pszPath));
                 hr = E_FAIL;
             }
         }
         else
         {
             PathAppendW(pszPath, CSIDL_Data[folder].szDefaultPath);
         }
     }
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHGetAllUsersProfilePath(), _SHGetCurrentVersionPath(), and _SHGetUserProfilePath().

◆ _SHGetProfilesValue()

static HRESULT _SHGetProfilesValue	(	HKEY	profilesKey,
		LPCWSTR	szValueName,
		LPWSTR	szValue,
		LPCWSTR	szDefault
	)

static

Definition at line 1884 of file shellpath.c.

 {
     HRESULT hr;
     DWORD type, dwPathLen = MAX_PATH * sizeof(WCHAR);
     LONG lRet;
 
     TRACE("%p,%s,%p,%s\n", profilesKey, debugstr_w(szValueName), szValue,
      debugstr_w(szDefault));
     lRet = RegQueryValueExW(profilesKey, szValueName, NULL, &type,
      (LPBYTE)szValue, &dwPathLen);
     if (!lRet && (type == REG_SZ || type == REG_EXPAND_SZ) && dwPathLen
      && *szValue)
     {
         dwPathLen /= sizeof(WCHAR);
         szValue[dwPathLen] = '\0';
         hr = S_OK;
     }
     else
     {
         /* Missing or invalid value, set a default */
         lstrcpynW(szValue, szDefault, MAX_PATH);
         TRACE("Setting missing value %s to %s\n", debugstr_w(szValueName),
                                                   debugstr_w(szValue));
         lRet = RegSetValueExW(profilesKey, szValueName, 0, REG_EXPAND_SZ,
                               (LPBYTE)szValue,
                               (strlenW(szValue) + 1) * sizeof(WCHAR));
         if (lRet)
             hr = HRESULT_FROM_WIN32(lRet);
         else
             hr = S_OK;
     }
     TRACE("returning 0x%08x (output value is %s)\n", hr, debugstr_w(szValue));
     return hr;
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHGetUserProfileDirectoryW()

BOOL _SHGetUserProfileDirectoryW	(	HANDLE	hToken,
		LPWSTR	szPath,
		LPDWORD	lpcchPath
	)

Definition at line 1509 of file shellpath.c.

 {
     BOOL result;
     if (!hToken)
     {
         OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken);
         result = GetUserProfileDirectoryW(hToken, szPath, lpcchPath);
         CloseHandle(hToken);
     }
     else if ((INT) hToken == -1)
     {
         result = GetDefaultUserProfileDirectoryW(szPath, lpcchPath);
     }
     else
     {
         result = GetUserProfileDirectoryW(hToken, szPath, lpcchPath);
     }
     TRACE("_SHGetUserProfileDirectoryW returning %S\n", szPath);
     return result;
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHGetUserProfilePath()

static HRESULT _SHGetUserProfilePath	(	HANDLE	hToken,
		DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1748 of file shellpath.c.

 {
     const WCHAR *szValueName;
     WCHAR buffer[40];
     HRESULT hr;
 
     TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if (CSIDL_Data[folder].type != CSIDL_Type_User)
         return E_INVALIDARG;
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
     {
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(hToken, folder, pszPath);
 #endif
     }
     else
     {
         LPCWSTR userPrefix = NULL;
         HKEY hRootKey;
 
         if (hToken == (HANDLE)-1)
         {
             hRootKey = HKEY_USERS;
             userPrefix = DefaultW;
         }
         else if (hToken == NULL)
             hRootKey = HKEY_CURRENT_USER;
         else
         {
             hRootKey = HKEY_USERS;
             userPrefix = _GetUserSidStringFromToken(hToken);
             if (userPrefix == NULL)
             {
                 hr = E_FAIL;
                 goto error;
             }
         }
 
         /* For CSIDL_Type_User we also use the GUID if no szValueName is provided */
         szValueName = CSIDL_Data[folder].szValueName;
         if (!szValueName)
         {
             StringFromGUID2( CSIDL_Data[folder].id, buffer, 39 );
             szValueName = &buffer[0];
         }
 
 #ifndef __REACTOS__
         hr = _SHGetUserShellFolderPath(hRootKey, userPrefix, szValueName, pszPath);
         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, szValueName, pszPath);
         if (FAILED(hr))
             hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetUserShellFolderPath(hRootKey, hToken, userPrefix, szValueName, pszPath);
         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, hToken, NULL, szValueName, pszPath);
         if (FAILED(hr))
             hr = _SHGetDefaultValue(hToken, folder, pszPath);
 #endif
         if (userPrefix != NULL && userPrefix != DefaultW)
             LocalFree((HLOCAL) userPrefix);
     }
 error:
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

◆ _SHGetUserShellFolderPath()

static HRESULT _SHGetUserShellFolderPath	(	HKEY	rootKey,
		LPCWSTR	userPrefix,
		LPCWSTR	value,
		LPWSTR	path
	)

static

Definition at line 1426 of file shellpath.c.

 {
     HRESULT hr;
     WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
     LPCWSTR pShellFolderPath, pUserShellFolderPath;
     HKEY userShellFolderKey, shellFolderKey;
     DWORD dwType, dwPathLen;
 
     TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
      path);
 
     if (userPrefix)
     {
         strcpyW(shellFolderPath, userPrefix);
         PathAddBackslashW(shellFolderPath);
         strcatW(shellFolderPath, szSHFolders);
         pShellFolderPath = shellFolderPath;
         strcpyW(userShellFolderPath, userPrefix);
         PathAddBackslashW(userShellFolderPath);
         strcatW(userShellFolderPath, szSHUserFolders);
         pUserShellFolderPath = userShellFolderPath;
     }
     else
     {
         pUserShellFolderPath = szSHUserFolders;
         pShellFolderPath = szSHFolders;
     }
 
     if (RegCreateKeyW(rootKey, pShellFolderPath, &shellFolderKey))
     {
         TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
         return E_FAIL;
     }
     if (RegCreateKeyW(rootKey, pUserShellFolderPath, &userShellFolderKey))
     {
         TRACE("Failed to create %s\n",
          debugstr_w(pUserShellFolderPath));
         RegCloseKey(shellFolderKey);
         return E_FAIL;
     }
 
     dwPathLen = MAX_PATH * sizeof(WCHAR);
     if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
      (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
     {
         LONG ret;
 
         path[dwPathLen / sizeof(WCHAR)] = '\0';
         if (dwType == REG_EXPAND_SZ && path[0] == '%')
         {
             WCHAR szTemp[MAX_PATH];
 
 #ifndef __REACTOS__
             _SHExpandEnvironmentStrings(path, szTemp);
 #else
             hr = _SHExpandEnvironmentStrings(hToken, path, szTemp, _countof(szTemp));
             if (FAILED(hr))
                 goto end;
 #endif
             lstrcpynW(path, szTemp, MAX_PATH);
         }
         ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
          (strlenW(path) + 1) * sizeof(WCHAR));
         if (ret != ERROR_SUCCESS)
             hr = HRESULT_FROM_WIN32(ret);
         else
             hr = S_OK;
     }
     else
         hr = E_FAIL;
 #ifdef __REACTOS__
 end:
 #endif
     RegCloseKey(shellFolderKey);
     RegCloseKey(userShellFolderKey);
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHGetAllUsersProfilePath(), and _SHGetUserProfilePath().

◆ _SHOpenProfilesKey()

static HRESULT _SHOpenProfilesKey ( PHKEY pKey )

static

Definition at line 1869 of file shellpath.c.

 {
     LONG lRet;
     DWORD disp;
 
     lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, NULL, 0,
      KEY_ALL_ACCESS, NULL, pKey, &disp);
     return HRESULT_FROM_WIN32(lRet);
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHRegisterCommonShellFolders()

static HRESULT _SHRegisterCommonShellFolders ( void )

static

Definition at line 2518 of file shellpath.c.

 {
     static const UINT folders[] = {
      CSIDL_COMMON_STARTMENU,
      CSIDL_COMMON_PROGRAMS,
      CSIDL_COMMON_STARTUP,
      CSIDL_COMMON_DESKTOPDIRECTORY,
      CSIDL_COMMON_FAVORITES,
      CSIDL_COMMON_APPDATA,
      CSIDL_COMMON_TEMPLATES,
      CSIDL_COMMON_DOCUMENTS,
      CSIDL_COMMON_ADMINTOOLS,
      CSIDL_COMMON_MUSIC,
      CSIDL_COMMON_PICTURES,
      CSIDL_COMMON_VIDEO,
     };
     HRESULT hr;
 
     TRACE("\n");
     hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
      szSHFolders, folders, ARRAY_SIZE(folders));
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by SHELL_RegisterShellFolders().

◆ _SHRegisterFolders()

static HRESULT _SHRegisterFolders	(	HKEY	hRootKey,
		HANDLE	hToken,
		LPCWSTR	szUserShellFolderPath,
		LPCWSTR	szShellFolderPath,
		const UINT	folders[],
		UINT	foldersLen
	)

static

Definition at line 2359 of file shellpath.c.

 {
     const WCHAR *szValueName;
     WCHAR buffer[40];
     UINT i;
     WCHAR path[MAX_PATH];
     HRESULT hr = S_OK;
     HKEY hUserKey = NULL, hKey = NULL;
     DWORD dwType, dwPathLen;
     LONG ret;
 
     TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
      debugstr_w(szUserShellFolderPath), folders, foldersLen);
 
     ret = RegCreateKeyW(hRootKey, szUserShellFolderPath, &hUserKey);
     if (ret)
         hr = HRESULT_FROM_WIN32(ret);
     else
     {
         ret = RegCreateKeyW(hRootKey, szShellFolderPath, &hKey);
         if (ret)
             hr = HRESULT_FROM_WIN32(ret);
     }
     for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
     {
         dwPathLen = MAX_PATH * sizeof(WCHAR);
 
         /* For CSIDL_Type_User we also use the GUID if no szValueName is provided */
         szValueName = CSIDL_Data[folders[i]].szValueName;
         if (!szValueName && CSIDL_Data[folders[i]].type == CSIDL_Type_User)
         {
             StringFromGUID2( CSIDL_Data[folders[i]].id, buffer, 39 );
             szValueName = &buffer[0];
         }
 
         if (!RegQueryValueExW(hUserKey, szValueName, NULL,
                               &dwType, (LPBYTE)path, &dwPathLen) &&
             (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
         {
             hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
                                   hToken, SHGFP_TYPE_CURRENT, path);
         }
         else
         {
             *path = '\0';
             if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
                 _SHGetUserProfilePath(hToken, SHGFP_TYPE_CURRENT, folders[i],
                  path);
             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
                 _SHGetAllUsersProfilePath(SHGFP_TYPE_CURRENT, folders[i], path);
             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
             {
                 GetWindowsDirectoryW(path, MAX_PATH);
                 if (CSIDL_Data[folders[i]].szDefaultPath &&
                     !IS_INTRESOURCE(CSIDL_Data[folders[i]].szDefaultPath))
                 {
                     PathAddBackslashW(path);
                     strcatW(path, CSIDL_Data[folders[i]].szDefaultPath);
                 }
             }
             else
                 hr = E_FAIL;
             if (*path)
             {
                 ret = RegSetValueExW(hUserKey, szValueName, 0, REG_EXPAND_SZ,
                  (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
                 if (ret)
                     hr = HRESULT_FROM_WIN32(ret);
                 else
                 {
                     hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
                      hToken, SHGFP_TYPE_CURRENT, path);
                     ret = RegSetValueExW(hKey, szValueName, 0, REG_SZ,
                      (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
                     if (ret)
                         hr = HRESULT_FROM_WIN32(ret);
                 }
             }
         }
     }
     if (hUserKey)
         RegCloseKey(hUserKey);
     if (hKey)
         RegCloseKey(hKey);
 
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().

◆ _SHRegisterUserShellFolders()

static HRESULT _SHRegisterUserShellFolders ( BOOL bDefault )

static

Definition at line 2450 of file shellpath.c.

 {
     static const UINT folders[] = {
      CSIDL_PROGRAMS,
      CSIDL_PERSONAL,
      CSIDL_FAVORITES,
      CSIDL_APPDATA,
      CSIDL_STARTUP,
      CSIDL_RECENT,
      CSIDL_SENDTO,
      CSIDL_STARTMENU,
      CSIDL_MYMUSIC,
      CSIDL_MYVIDEO,
      CSIDL_DESKTOPDIRECTORY,
      CSIDL_NETHOOD,
      CSIDL_TEMPLATES,
      CSIDL_PRINTHOOD,
      CSIDL_LOCAL_APPDATA,
      CSIDL_INTERNET_CACHE,
      CSIDL_COOKIES,
      CSIDL_HISTORY,
      CSIDL_MYPICTURES,
      CSIDL_FONTS,
      CSIDL_ADMINTOOLS,
 /* Cannot use #if _WIN32_WINNT >= 0x0600 because _WIN32_WINNT == 0x0600 here. */
 #ifndef __REACTOS__
      CSIDL_CONTACTS,
      CSIDL_DOWNLOADS,
      CSIDL_LINKS,
      CSIDL_APPDATA_LOCALLOW,
      CSIDL_SAVED_GAMES,
      CSIDL_SEARCHES
 #endif
     };
     WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
     LPCWSTR pUserShellFolderPath, pShellFolderPath;
     HRESULT hr = S_OK;
     HKEY hRootKey;
     HANDLE hToken;
 
     TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
     if (bDefault)
     {
         hToken = (HANDLE)-1;
         hRootKey = HKEY_USERS;
         strcpyW(userShellFolderPath, DefaultW);
         PathAddBackslashW(userShellFolderPath);
         strcatW(userShellFolderPath, szSHUserFolders);
         pUserShellFolderPath = userShellFolderPath;
         strcpyW(shellFolderPath, DefaultW);
         PathAddBackslashW(shellFolderPath);
         strcatW(shellFolderPath, szSHFolders);
         pShellFolderPath = shellFolderPath;
     }
     else
     {
         hToken = NULL;
         hRootKey = HKEY_CURRENT_USER;
         pUserShellFolderPath = szSHUserFolders;
         pShellFolderPath = szSHFolders;
     }
 
     hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
      pShellFolderPath, folders, ARRAY_SIZE(folders));
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by SHELL_RegisterShellFolders().

◆ IsLFNDriveA()

BOOL WINAPI IsLFNDriveA ( LPCSTR lpszPath )

Definition at line 236 of file shellpath.c.

 {
     DWORD   fnlen;
 
     if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
     return FALSE;
     return fnlen > 12;
 }

Referenced by IsLFNDriveAW().

◆ IsLFNDriveAW()

BOOL WINAPI IsLFNDriveAW ( LPCVOID lpszPath )

Definition at line 260 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return IsLFNDriveW(lpszPath);
     return IsLFNDriveA(lpszPath);
 }

◆ IsLFNDriveW()

BOOL WINAPI IsLFNDriveW ( LPCWSTR lpszPath )

Definition at line 248 of file shellpath.c.

 {
     DWORD   fnlen;
 
     if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
     return FALSE;
     return fnlen > 12;
 }

Referenced by IsLFNDriveAW().

◆ PathAppendAW()

BOOL WINAPI PathAppendAW	(	LPVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

Definition at line 64 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathAppendW(lpszPath1, lpszPath2);
     return PathAppendA(lpszPath1, lpszPath2);
 }

◆ PathCleanupSpec()

int WINAPI PathCleanupSpec	(	LPCWSTR	lpszPathW,
		LPWSTR	lpszFileW
	)

Definition at line 359 of file shellpath.c.

 {
     int i = 0;
     DWORD rc = 0;
     int length = 0;
 
     if (SHELL_OsIsUnicode())
     {
         LPWSTR p = lpszFileW;
 
         TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
 
         if (lpszPathW)
             length = strlenW(lpszPathW);
 
         while (*p)
         {
             int gct = PathGetCharTypeW(*p);
             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
             {
                 lpszFileW[i]='-';
                 rc |= PCS_REPLACEDCHAR;
             }
             else
                 lpszFileW[i]=*p;
             i++;
             p++;
             if (length + i == MAX_PATH)
             {
                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
                 break;
             }
         }
         lpszFileW[i]=0;
     }
     else
     {
         LPSTR lpszFileA = (LPSTR)lpszFileW;
         LPCSTR lpszPathA = (LPCSTR)lpszPathW;
         LPSTR p = lpszFileA;
 
         TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
 
         if (lpszPathA)
             length = strlen(lpszPathA);
 
         while (*p)
         {
             int gct = PathGetCharTypeA(*p);
             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
             {
                 lpszFileA[i]='-';
                 rc |= PCS_REPLACEDCHAR;
             }
             else
                 lpszFileA[i]=*p;
             i++;
             p++;
             if (length + i == MAX_PATH)
             {
                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
                 break;
             }
         }
         lpszFileA[i]=0;
     }
     return rc;
 }

◆ PathFileExistsAW()

BOOL WINAPI PathFileExistsAW ( LPCVOID lpszPath )

Definition at line 226 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathFileExistsW (lpszPath);
     return PathFileExistsA (lpszPath);
 }

◆ PathGetExtensionA()

static LPSTR PathGetExtensionA ( LPCSTR lpszPath )

static

Definition at line 80 of file shellpath.c.

 {
     TRACE("(%s)\n",lpszPath);
 
     lpszPath = PathFindExtensionA(lpszPath);
     return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
 }

Referenced by PathIsExeA().

◆ PathGetExtensionW()

static LPWSTR PathGetExtensionW ( LPCWSTR lpszPath )

static

Definition at line 91 of file shellpath.c.

 {
     TRACE("(%s)\n",debugstr_w(lpszPath));
 
     lpszPath = PathFindExtensionW(lpszPath);
     return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
 }

Referenced by PathIsExeW(), and SHPathGetExtensionW().

◆ PathGetShortPathA()

static void PathGetShortPathA ( LPSTR pszPath )

static

Definition at line 124 of file shellpath.c.

 {
     CHAR path[MAX_PATH];
 
     TRACE("%s\n", pszPath);
 
     if (GetShortPathNameA(pszPath, path, MAX_PATH))
     {
       lstrcpyA(pszPath, path);
     }
 }

Referenced by PathGetShortPathAW().

◆ PathGetShortPathAW()

VOID WINAPI PathGetShortPathAW ( LPVOID pszPath )

Definition at line 154 of file shellpath.c.

 {
     if(SHELL_OsIsUnicode())
       PathGetShortPathW(pszPath);
     PathGetShortPathA(pszPath);
 }

◆ PathGetShortPathW()

static void PathGetShortPathW ( LPWSTR pszPath )

static

Definition at line 139 of file shellpath.c.

 {
     WCHAR path[MAX_PATH];
 
     TRACE("%s\n", debugstr_w(pszPath));
 
     if (GetShortPathNameW(pszPath, path, MAX_PATH))
     {
       lstrcpyW(pszPath, path);
     }
 }

Referenced by PathGetShortPathAW().

◆ PathIsExeA()

static BOOL PathIsExeA ( LPCSTR lpszPath )

static

Definition at line 178 of file shellpath.c.

 {
     LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
         int i;
         static const char * const lpszExtensions[] =
             {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
 
     TRACE("path=%s\n",lpszPath);
 
     for(i=0; lpszExtensions[i]; i++)
       if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
 
     return FALSE;
 }

Referenced by PathIsExeAW().

◆ PathIsExeAW()

BOOL WINAPI PathIsExeAW ( LPCVOID path )

Definition at line 216 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathIsExeW (path);
     return PathIsExeA(path);
 }

◆ PathIsExeW()

BOOL PathIsExeW ( LPCWSTR lpszPath )

Definition at line 196 of file shellpath.c.

 {
     LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
         int i;
         static const WCHAR lpszExtensions[][4] =
             {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
              {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
              {'s','c','r','\0'}, {'\0'} };
 
     TRACE("path=%s\n",debugstr_w(lpszPath));
 
     for(i=0; lpszExtensions[i][0]; i++)
       if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 
     return FALSE;
 }

Referenced by CFileDefExt::InitGeneralPage(), COpenWithMenu::Initialize(), and PathIsExeAW().

◆ PathIsRootAW()

BOOL WINAPI PathIsRootAW ( LPCVOID lpszPath )

Definition at line 168 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathIsRootW(lpszPath);
     return PathIsRootA(lpszPath);
 }

◆ PathMakeUniqueNameA()

static BOOL PathMakeUniqueNameA	(	LPSTR	lpszBuffer,
		DWORD	dwBuffSize,
		LPCSTR	lpszShortName,
		LPCSTR	lpszLongName,
		LPCSTR	lpszPathName
	)

static

Definition at line 273 of file shellpath.c.

 {
     FIXME("%p %u %s %s %s stub\n",
      lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
      debugstr_a(lpszLongName), debugstr_a(lpszPathName));
     return TRUE;
 }

Referenced by PathMakeUniqueNameAW().

◆ PathMakeUniqueNameAW()

BOOL WINAPI PathMakeUniqueNameAW	(	LPVOID	lpszBuffer,
		DWORD	dwBuffSize,
		LPCVOID	lpszShortName,
		LPCVOID	lpszLongName,
		LPCVOID	lpszPathName
	)

Definition at line 305 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
     return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 }

◆ PathMakeUniqueNameW()

static BOOL PathMakeUniqueNameW	(	LPWSTR	lpszBuffer,
		DWORD	dwBuffSize,
		LPCWSTR	lpszShortName,
		LPCWSTR	lpszLongName,
		LPCWSTR	lpszPathName
	)

static

Definition at line 289 of file shellpath.c.

 {
     FIXME("%p %u %s %s %s stub\n",
      lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
      debugstr_w(lpszLongName), debugstr_w(lpszPathName));
     return TRUE;
 }

Referenced by PathMakeUniqueNameAW().

◆ PathProcessCommandA()

static LONG PathProcessCommandA	(	LPCSTR	lpszPath,
		LPSTR	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

static

Definition at line 482 of file shellpath.c.

 {
     FIXME("%s %p 0x%04x 0x%04x stub\n",
     lpszPath, lpszBuff, dwBuffSize, dwFlags);
     if(!lpszPath) return -1;
     if(lpszBuff) strcpy(lpszBuff, lpszPath);
     return strlen(lpszPath);
 }

Referenced by PathProcessCommandAW().

◆ PathProcessCommandAW()

LONG WINAPI PathProcessCommandAW	(	LPCVOID	lpszPath,
		LPVOID	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

Definition at line 514 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
     return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 }

◆ PathProcessCommandW()

static LONG PathProcessCommandW	(	LPCWSTR	lpszPath,
		LPWSTR	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

static

Definition at line 498 of file shellpath.c.

 {
     FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
     debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
     if(!lpszPath) return -1;
     if(lpszBuff) strcpyW(lpszBuff, lpszPath);
     return strlenW(lpszPath);
 }

Referenced by PathProcessCommandAW().

◆ PathQualifyA()

static BOOL PathQualifyA ( LPCSTR pszPath )

static

Definition at line 431 of file shellpath.c.

 {
     FIXME("%s\n",pszPath);
     return FALSE;
 }

Referenced by PathQualifyAW().

◆ PathQualifyAW()

BOOL WINAPI PathQualifyAW ( LPCVOID pszPath )

Definition at line 449 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathQualifyW(pszPath);
     return PathQualifyA(pszPath);
 }

◆ PathQualifyW()

static BOOL PathQualifyW ( LPCWSTR pszPath )

static

Definition at line 440 of file shellpath.c.

 {
     FIXME("%s\n",debugstr_w(pszPath));
     return FALSE;
 }

Referenced by PathQualifyAW().

◆ PathRemoveFileSpecAW()

BOOL WINAPI PathRemoveFileSpecAW ( LPVOID lpszPath )

Definition at line 110 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathRemoveFileSpecW(lpszPath);
     return PathRemoveFileSpecA(lpszPath);
 }

◆ PathResolveA()

static BOOL PathResolveA	(	LPSTR	path,
		LPCSTR *	paths,
		DWORD	flags
	)

static

Definition at line 456 of file shellpath.c.

 {
     FIXME("(%s,%p,0x%08x),stub!\n", debugstr_a(path), paths, flags);
     return FALSE;
 }

Referenced by PathResolveAW().

◆ PathResolveAW()

BOOL WINAPI PathResolveAW	(	LPVOID	path,
		LPCVOID *	paths,
		DWORD	flags
	)

Definition at line 471 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
         return PathResolveW(path, (LPCWSTR*)paths, flags);
     else
         return PathResolveA(path, (LPCSTR*)paths, flags);
 }

◆ PathResolveW()

static BOOL PathResolveW	(	LPWSTR	path,
		LPCWSTR *	paths,
		DWORD	flags
	)

static

Definition at line 462 of file shellpath.c.

 {
     FIXME("(%s,%p,0x%08x),stub!\n", debugstr_w(path), paths, flags);
     return FALSE;
 }

Referenced by PathResolveAW().

◆ PathYetAnotherMakeUniqueName()

BOOL WINAPI PathYetAnotherMakeUniqueName	(	LPWSTR	buffer,
		LPCWSTR	path,
		LPCWSTR	shortname,
		LPCWSTR	longname
	)

Definition at line 320 of file shellpath.c.

 {
     WCHAR pathW[MAX_PATH], retW[MAX_PATH];
     const WCHAR *file, *ext;
     int i = 2;
 
     TRACE("(%p, %s, %s, %s)\n", buffer, debugstr_w(path), debugstr_w(shortname), debugstr_w(longname));
 
     file = longname ? longname : shortname;
     PathCombineW(pathW, path, file);
     strcpyW(retW, pathW);
     PathRemoveExtensionW(pathW);
 
     ext = PathFindExtensionW(file);
 
     /* now try to make it unique */
     while (PathFileExistsW(retW))
     {
         static const WCHAR fmtW[] = {'%','s',' ','(','%','d',')','%','s',0};
 
         sprintfW(retW, fmtW, pathW, i, ext);
         i++;
     }
 
     strcpyW(buffer, retW);
     TRACE("ret - %s\n", debugstr_w(buffer));
 
     return TRUE;
 }

Referenced by BrsFolder_NewFolder(), CNewMenu::CreateNewFolder(), CDefaultContextMenu::DoCreateNewFolder(), loadShell32(), and CNewMenu::NewItemByNonCommand().

◆ SHELL_RegisterShellFolders()

HRESULT SHELL_RegisterShellFolders ( void )

Definition at line 2546 of file shellpath.c.

 {
     HRESULT hr;
 
     hr = _SHRegisterUserShellFolders(TRUE);
     if (SUCCEEDED(hr))
         hr = _SHRegisterUserShellFolders(FALSE);
     if (SUCCEEDED(hr))
         hr = _SHRegisterCommonShellFolders();
     return hr;
 }

Referenced by DllRegisterServer().

◆ SHGetFolderLocation()

HRESULT WINAPI SHGetFolderLocation	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwReserved,
		LPITEMIDLIST *	ppidl
	)

Definition at line 2606 of file shellpath.c.

 {
     HRESULT hr = E_INVALIDARG;
 
     TRACE("%p 0x%08x %p 0x%08x %p\n",
      hwndOwner, nFolder, hToken, dwReserved, ppidl);
     
     if (!ppidl)
         return E_INVALIDARG;
     if (dwReserved)
         return E_INVALIDARG;
 
     /* The virtual folders' locations are not user-dependent */
     *ppidl = NULL;
     switch (nFolder & CSIDL_FOLDER_MASK)
     {
         case CSIDL_DESKTOP:
             *ppidl = _ILCreateDesktop();
             break;
 
         case CSIDL_PERSONAL:
             *ppidl = _ILCreateMyDocuments();
             break;
 
         case CSIDL_INTERNET:
             *ppidl = _ILCreateIExplore();
             break;
 
         case CSIDL_CONTROLS:
             *ppidl = _ILCreateControlPanel();
             break;
 
         case CSIDL_PRINTERS:
             *ppidl = _ILCreatePrinters();
             break;
 
         case CSIDL_BITBUCKET:
             *ppidl = _ILCreateBitBucket();
             break;
 
         case CSIDL_DRIVES:
             *ppidl = _ILCreateMyComputer();
             break;
 
         case CSIDL_NETWORK:
             *ppidl = _ILCreateNetwork();
             break;
 
         default:
         {
             WCHAR szPath[MAX_PATH];
 
             hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
              SHGFP_TYPE_CURRENT, szPath);
             if (SUCCEEDED(hr))
             {
                 DWORD attributes=0;
 
                 TRACE("Value=%s\n", debugstr_w(szPath));
                 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
             }
             else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
             {
                 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
                  * version 6.0 returns E_FAIL for nonexistent paths
                  */
                 hr = E_FAIL;
             }
         }
     }
     if(*ppidl)
         hr = S_OK;
 
     TRACE("-- (new pidl %p)\n",*ppidl);
     return hr;
 }

Referenced by CBandSiteMenu::_CreateBuiltInISFBand(), ILIsParentOrSpecialParent(), CExplorerBand::InitializeExplorerBand(), CExplorerBand::InsertSubitems(), LoadRdpSettingsFromFile(), loadShell32(), CShellMenuCallback::OnGetSubMenu(), SaveRdpSettingsToFile(), SHCreateFromDesktop(), SHEmptyRecycleBinW(), SHGetSpecialFolderLocation(), START_TEST(), TestCommandLine(), and TestCompareIDList().

◆ SHGetFolderPathA()

HRESULT WINAPI SHGetFolderPathA	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPSTR	pszPath
	)

Definition at line 2329 of file shellpath.c.

 {
     WCHAR szTemp[MAX_PATH];
     HRESULT hr;
 
     TRACE("%p,%d,%p,%#x,%p\n", hwndOwner, nFolder, hToken, dwFlags, pszPath);
 
     if (pszPath)
         *pszPath = '\0';
     hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
     if (SUCCEEDED(hr) && pszPath)
         WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
          NULL);
 
     return hr;
 }

Referenced by init_functionpointers(), loadShell32(), SHGetSpecialFolderPathA(), test_profile_items(), test_SHGetFolderPathA(), and test_SHGetFolderPathAndSubDirA().

◆ SHGetFolderPathAndSubDirA()

HRESULT WINAPI SHGetFolderPathAndSubDirA	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPCSTR	pszSubPath,
		LPSTR	pszPath
	)

Definition at line 2100 of file shellpath.c.

 {
     int length;
     HRESULT hr = S_OK;
     LPWSTR pszSubPathW = NULL;
     LPWSTR pszPathW = NULL;
 
     TRACE("%p,%#x,%p,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_a(pszSubPath), pszPath);
 
     if(pszPath) {
         pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
         if(!pszPathW) {
             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
     }
     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
 
     /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
      * set (null), or an empty string.therefore call it without the parameter set
      * if pszSubPath is an empty string
      */
     if (pszSubPath && pszSubPath[0]) {
         length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
         pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
         if(!pszSubPathW) {
             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
         MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
     }
 
     hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
 
     if (SUCCEEDED(hr) && pszPath)
         WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
 
 cleanup:
     HeapFree(GetProcessHeap(), 0, pszPathW);
     HeapFree(GetProcessHeap(), 0, pszSubPathW);
     return hr;
 }

Referenced by test_SHGetFolderPathAndSubDirA().

◆ SHGetFolderPathAndSubDirW()

HRESULT WINAPI SHGetFolderPathAndSubDirW	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPCWSTR	pszSubPath,
		LPWSTR	pszPath
	)

Definition at line 2152 of file shellpath.c.

 {
     HRESULT    hr;
     WCHAR      szBuildPath[MAX_PATH], szTemp[MAX_PATH];
     DWORD      folder = nFolder & CSIDL_FOLDER_MASK;
     CSIDL_Type type;
     int        ret;
     
     TRACE("%p,%#x,%p,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_w(pszSubPath), pszPath);
 
     /* Windows always NULL-terminates the resulting path regardless of success
      * or failure, so do so first
      */
     if (pszPath)
         *pszPath = '\0';
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
         return E_INVALIDARG;
     szTemp[0] = 0;
     type = CSIDL_Data[folder].type;
     switch (type)
     {
         case CSIDL_Type_Disallowed:
             hr = E_INVALIDARG;
             break;
         case CSIDL_Type_NonExistent:
             hr = S_FALSE;
             break;
         case CSIDL_Type_WindowsPath:
             GetWindowsDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_SystemPath:
             GetSystemDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_SystemX86Path:
             if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_CurrVer:
             hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
             break;
         case CSIDL_Type_User:
             hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
             break;
         case CSIDL_Type_AllUsers:
             hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
             break;
         default:
             FIXME("bogus type %d, please fix\n", type);
             hr = E_INVALIDARG;
             break;
     }
 
     /* Expand environment strings if necessary */
     if (*szTemp == '%')
 #ifndef __REACTOS__
         hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
 #else
         hr = _SHExpandEnvironmentStrings(hToken, szTemp, szBuildPath, _countof(szBuildPath));
 #endif
     else
         strcpyW(szBuildPath, szTemp);
 
     if (FAILED(hr)) goto end;
 
     if(pszSubPath) {
         /* make sure the new path does not exceed the buffer length
          * and remember to backslash and terminate it */
         if(MAX_PATH < (lstrlenW(szBuildPath) + lstrlenW(pszSubPath) + 2)) {
             hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
             goto end;
         }
         PathAppendW(szBuildPath, pszSubPath);
         PathRemoveBackslashW(szBuildPath);
     }
     /* Copy the path if it's available before we might return */
     if (SUCCEEDED(hr) && pszPath)
         strcpyW(pszPath, szBuildPath);
 
     /* if we don't care about existing directories we are ready */
     if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
 
     if (PathFileExistsW(szBuildPath)) goto end;
 
     /* not existing but we are not allowed to create it.  The return value
      * is verified against shell32 version 6.0.
      */
     if (!(nFolder & CSIDL_FLAG_CREATE))
     {
         hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
         goto end;
     }
 
     /* create directory/directories */
     ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
     if (ret && ret != ERROR_ALREADY_EXISTS)
     {
         ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
         hr = E_FAIL;
         goto end;
     }
 
     TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
 
 end:
     /* create desktop.ini for custom icon */
     if ((nFolder & CSIDL_FLAG_CREATE) &&
         CSIDL_Data[folder].nShell32IconIndex)
     {
         static const WCHAR s_szFormat[] = L"%%SystemRoot%%\\system32\\shell32.dll,%d";
         WCHAR szIconLocation[MAX_PATH];
         DWORD dwAttributes;
 
         /* make the directory a system folder */
         dwAttributes = GetFileAttributesW(szBuildPath);
         dwAttributes |= FILE_ATTRIBUTE_SYSTEM;
         SetFileAttributesW(szBuildPath, dwAttributes);
 
         /* build the desktop.ini file path */
         PathAppendW(szBuildPath, L"desktop.ini");
 
         /* build the icon location */
         StringCchPrintfW(szIconLocation, _countof(szIconLocation), s_szFormat,
                          CSIDL_Data[folder].nShell32IconIndex);
 
         /* write desktop.ini */
         WritePrivateProfileStringW(L".ShellClassInfo", L"IconResource", szIconLocation, szBuildPath);
 
         /* flush! */
         WritePrivateProfileStringW(NULL, NULL, NULL, szBuildPath);
 
         /* make the desktop.ini a system and hidden file */
         dwAttributes = GetFileAttributesW(szBuildPath);
         dwAttributes |= FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         SetFileAttributesW(szBuildPath, dwAttributes);
     }
 
     TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
     return hr;
 }

Referenced by CBandSiteMenu::_GetQLaunchPidl(), CreateShortcuts(), SHGetFolderPathAndSubDirA(), SHGetFolderPathW(), and ThemePageDlgProc().

◆ SHGetFolderPathW()

HRESULT WINAPI SHGetFolderPathW	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPWSTR	pszPath
	)

Definition at line 2087 of file shellpath.c.

 {
     HRESULT hr =  SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
     if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
     return hr;
 }

Referenced by _CDataObject_CreateInstance(), _SHRegisterFolders(), AutoStartupApplications(), BrsFolder_NewFolder(), CJournaledTestList::CJournaledTestList(), create_ie_menu(), create_profile_directory(), CreateObjectsFromPersistFolder(), DllRegisterServer(), CFontExt::Drop(), FILEDLG95_InitControls(), FillDefaultSettings(), format_filelist_filename(), CFontExt::Initialize(), LoadThemes(), OnAddStartMenuItems(), OnAdvancedStartMenuItems(), OnClearRecentItems(), RegisterTypeLibraries(), RunFontViewer(), set_installer_properties(), Settings_GetOutputPath(), SHGetFolderLocation(), SHGetFolderPathA(), SHGetSpecialFolderPathW(), test_namespace(), TestDefaultFormat(), and testRegStoreSavedCerts().

◆ SHGetSpecialFolderLocation()

HRESULT WINAPI SHGetSpecialFolderLocation	(	HWND	hwndOwner,
		INT	nFolder,
		LPITEMIDLIST *	ppidl
	)

Definition at line 2695 of file shellpath.c.

 {
     HRESULT hr = E_INVALIDARG;
 
     TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
 
     if (!ppidl)
         return E_INVALIDARG;
 
     hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
     return hr;
 }

Referenced by _GetDocumentsPidl(), DoTestEntry(), ebrowser_browse_to_desktop(), FILEDLG95_InitControls(), FILEDLG95_LOOKIN_Init(), FILEDLG95_OnWMCommand(), filedlg_collect_places_pidls(), GetFavoritesFolder(), GetMergedFolder(), CSendToMenu::GetSpecialFolder(), IShellBrowserImpl_Construct(), loadShell32(), CShellBrowser::OnOrganizeFavorites(), PidlBrowse(), CAddressEditBox::PopulateComboBox(), RSHELL_CStartMenu_CreateInstance(), SHAddToRecentDocs(), SHCloneSpecialIDList(), SHExplorerParseCmdLine(), SpecialFolderPath::SpecialFolderPath(), START_TEST(), test_ACListISF_FAVORITES(), test_ACListISF_MYCOMPUTER(), test_get_file_info_iconlist(), test_namespace(), test_parameters(), test_printers_folder(), test_SHCreateShellItem(), test_SHCreateShellItemArray(), test_ShellItemBindToHandler(), test_ShellItemGetAttributes(), test_SHGetIDListFromObject(), test_SHGetNameFromIDList(), test_SHGetPathFromIDList(), VariantToIdlist(), and WshCollection_Item().

◆ SHGetSpecialFolderPathA()

BOOL WINAPI SHGetSpecialFolderPathA	(	HWND	hwndOwner,
		LPSTR	szPath,
		int	nFolder,
		BOOL	bCreate
	)

Definition at line 2561 of file shellpath.c.

 {
     return SHGetFolderPathA(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
                             szPath) == S_OK;
 }

Referenced by init_strings(), loadShell32(), main(), test_BindToObject(), test_find_file(), and test_GetDisplayName().

◆ SHGetSpecialFolderPathW()

BOOL WINAPI SHGetSpecialFolderPathW	(	HWND	hwndOwner,
		LPWSTR	szPath,
		int	nFolder,
		BOOL	bCreate
	)

Definition at line 2574 of file shellpath.c.

 {
     return SHGetFolderPathW(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
                             szPath) == S_OK;
 }

Referenced by cache_containers_init(), CSendToMenu::CreateSendToFiles(), delhist_on_command(), CDeskLinkDropHandler::Drop(), CDesktopFolder::FinalConstruct(), CSendToMenu::FolderHasAnyItems(), get_csidl_dir(), GetStorageDirectory(), CFSFolder::InitializeEx(), InitPropertyBag_IPropertyBag_Read(), CSendToMenu::LoadAllItems(), profile_items_callback(), START_TEST(), test_FolderShortcut(), test_ITEMIDLIST_format(), test_ParseDisplayName(), test_SHCreateShellItemArray(), and test_SHGetPathFromIDList().

◆ SHPathGetExtensionW()

LPVOID WINAPI SHPathGetExtensionW	(	LPCWSTR	lpszPath,
		DWORD	void1,
		DWORD	void2
	)

Definition at line 102 of file shellpath.c.

 {
     return PathGetExtensionW(lpszPath);
 }

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( shell )

Variable Documentation

◆ Administrative_ToolsW

const WCHAR Administrative_ToolsW[] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static

Definition at line 530 of file shellpath.c.

◆ AllUsersProfileValueW

const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'}

static

Definition at line 638 of file shellpath.c.

Referenced by _SHExpandEnvironmentStrings().

◆ AllUsersProfileW

const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'}

static

Definition at line 629 of file shellpath.c.

Referenced by _SHExpandEnvironmentStrings(), and _SHGetDefaultValue().

◆ AllUsersW

const WCHAR AllUsersW[] = {'P','u','b','l','i','c',0}

static

Definition at line 647 of file shellpath.c.

Referenced by _SHExpandEnvironmentStrings().

◆ AppData_LocalLowW

const WCHAR AppData_LocalLowW[] = {'A','p','p','D','a','t','a','\\','L','o','c','a','l','L','o','w','\0'}

static

Definition at line 533 of file shellpath.c.

◆ AppDataW

const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'}

static

Definition at line 531 of file shellpath.c.

◆ Application_DataW

const WCHAR Application_DataW[] = {'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static

Definition at line 534 of file shellpath.c.

◆ CacheW

const WCHAR CacheW[] = {'C','a','c','h','e','\0'}

static

Definition at line 536 of file shellpath.c.

◆ CD_BurningW

const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'}

static

Definition at line 537 of file shellpath.c.

◆ Common_Administrative_ToolsW

const WCHAR Common_Administrative_ToolsW[] = {'C','o','m','m','o','n',' ','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static

Definition at line 538 of file shellpath.c.

◆ Common_AppDataW

const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'}

static

Definition at line 539 of file shellpath.c.

◆ Common_DesktopW

const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'}

static

Definition at line 540 of file shellpath.c.

◆ Common_DocumentsW

const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'}

static

Definition at line 541 of file shellpath.c.

◆ Common_FavoritesW

const WCHAR Common_FavoritesW[] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'}

static

Definition at line 542 of file shellpath.c.

◆ Common_ProgramsW

const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'}

static

Definition at line 547 of file shellpath.c.

◆ Common_Start_MenuW

const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'}

static

Definition at line 549 of file shellpath.c.

◆ Common_StartUpW

const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'}

static

Definition at line 548 of file shellpath.c.

◆ Common_TemplatesW

const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'}

static

Definition at line 550 of file shellpath.c.

◆ CommonFilesDirW

const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'}

static

Definition at line 543 of file shellpath.c.

◆ CommonFilesDirX86W

const WCHAR CommonFilesDirX86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'}

static

Definition at line 544 of file shellpath.c.

◆ CommonMusicW

const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'}

static

Definition at line 545 of file shellpath.c.

◆ CommonPicturesW

const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'}

static

Definition at line 546 of file shellpath.c.

◆ CommonVideoW

const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'}

static

Definition at line 551 of file shellpath.c.

◆ ContactsW

const WCHAR ContactsW[] = {'C','o','n','t','a','c','t','s','\0'}

static

Definition at line 553 of file shellpath.c.

◆ CookiesW

const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'}

static

Definition at line 555 of file shellpath.c.

◆ CSIDL_Data

const CSIDL_DATA CSIDL_Data[]

static

Definition at line 679 of file shellpath.c.

Referenced by _SHGetAllUsersProfilePath(), _SHGetCurrentVersionPath(), _SHGetDefaultValue(), _SHGetUserProfilePath(), _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

◆ DefaultW

const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'}

static

Definition at line 628 of file shellpath.c.

Referenced by _SHGetUserProfilePath(), and _SHRegisterUserShellFolders().

◆ DesktopW

const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'}

static

Definition at line 556 of file shellpath.c.

Referenced by test_getuserobjectinformation().

◆ DocumentsW

const WCHAR DocumentsW[] = {'D','o','c','u','m','e','n','t','s','\0'}

static

Definition at line 558 of file shellpath.c.

◆ DownloadsW

const WCHAR DownloadsW[] = {'D','o','w','n','l','o','a','d','s','\0'}

static

Definition at line 559 of file shellpath.c.

◆ FavoritesW

const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'}

static

Definition at line 561 of file shellpath.c.

◆ FontsW

const WCHAR FontsW[] = {'F','o','n','t','s','\0'}

static

Definition at line 562 of file shellpath.c.

◆ HistoryW

const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'}

static

Definition at line 563 of file shellpath.c.

◆ is_win64

const BOOL is_win64 = sizeof(void *) > sizeof(int)

static

Definition at line 55 of file shellpath.c.

Referenced by _SHGetCurrentVersionPath(), _SHGetDefaultValue(), get_classes_root_hkey(), get_wine_loader_name(), test_CoGetPSClsid(), and test_SHGetFolderPathA().

◆ LinksW

const WCHAR LinksW[] = {'L','i','n','k','s','\0'}

static

Definition at line 565 of file shellpath.c.

◆ Local_AppDataW

const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'}

static

Definition at line 567 of file shellpath.c.

◆ Local_Settings_Application_DataW

const WCHAR Local_Settings_Application_DataW[] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static

Definition at line 569 of file shellpath.c.

◆ Local_Settings_CD_BurningW

const WCHAR Local_Settings_CD_BurningW[] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\\','M','i','c','r','o','s','o','f','t','\\','C','D',' ','B','

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _INC_WINDOWS

◆ COBJMACROS

◆ CSIDL_APPDATA_LOCALLOW

◆ CSIDL_CONTACTS

◆ CSIDL_DOWNLOADS

◆ CSIDL_LINKS

◆ CSIDL_SAVED_GAMES

◆ CSIDL_SEARCHES

◆ WIN32_NO_STATUS

Typedef Documentation

◆ CSIDL_Type

Enumeration Type Documentation

◆ _CSIDL_Type

Function Documentation

◆ _GetUserSidStringFromToken()

◆ _SHExpandEnvironmentStrings()

◆ _SHGetAllUsersProfilePath()

◆ _SHGetCurrentVersionPath()

◆ _SHGetDefaultValue()

◆ _SHGetProfilesValue()

◆ _SHGetUserProfileDirectoryW()

◆ _SHGetUserProfilePath()

◆ _SHGetUserShellFolderPath()

◆ _SHOpenProfilesKey()

◆ _SHRegisterCommonShellFolders()

◆ _SHRegisterFolders()

◆ _SHRegisterUserShellFolders()

◆ IsLFNDriveA()

◆ IsLFNDriveAW()

◆ IsLFNDriveW()

◆ PathAppendAW()

◆ PathCleanupSpec()

◆ PathFileExistsAW()

◆ PathGetExtensionA()

◆ PathGetExtensionW()

◆ PathGetShortPathA()

◆ PathGetShortPathAW()

◆ PathGetShortPathW()

◆ PathIsExeA()

◆ PathIsExeAW()

◆ PathIsExeW()

◆ PathIsRootAW()

◆ PathMakeUniqueNameA()

◆ PathMakeUniqueNameAW()

◆ PathMakeUniqueNameW()

◆ PathProcessCommandA()

◆ PathProcessCommandAW()

◆ PathProcessCommandW()

◆ PathQualifyA()

◆ PathQualifyAW()

◆ PathQualifyW()

◆ PathRemoveFileSpecAW()

◆ PathResolveA()

◆ PathResolveAW()

◆ PathResolveW()

◆ PathYetAnotherMakeUniqueName()

◆ SHELL_RegisterShellFolders()

◆ SHGetFolderLocation()

◆ SHGetFolderPathA()

◆ SHGetFolderPathAndSubDirA()

◆ SHGetFolderPathAndSubDirW()

◆ SHGetFolderPathW()

◆ SHGetSpecialFolderLocation()

◆ SHGetSpecialFolderPathA()

◆ SHGetSpecialFolderPathW()

◆ SHPathGetExtensionW()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ Administrative_ToolsW

◆ AllUsersProfileValueW

◆ AllUsersProfileW

◆ AllUsersW

◆ AppData_LocalLowW