| /* | |
| * Path Functions | |
| * | |
| * Copyright 1998, 1999, 2000 Juergen Schmied | |
| * Copyright 2004 Juan Lang | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| * | |
| * NOTES: | |
| * | |
| * Many of these functions are in SHLWAPI.DLL also | |
| * | |
| */ | |
| #define COBJMACROS | |
| #include <stdio.h> | |
| #include <stdarg.h> | |
| #include <string.h> | |
| #include <ctype.h> | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "winternl.h" | |
| #include "winnls.h" | |
| #include "winreg.h" | |
| #include "wingdi.h" | |
| #include "winuser.h" | |
| #include "winioctl.h" | |
| #define WINE_MOUNTMGR_EXTENSIONS | |
| #include "ddk/mountmgr.h" | |
| #include "shlobj.h" | |
| #include "shtypes.h" | |
| #include "shresdef.h" | |
| #include "shell32_main.h" | |
| #include "pidl.h" | |
| #include "shlwapi.h" | |
| #include "sddl.h" | |
| #include "knownfolders.h" | |
| #include "initguid.h" | |
| #include "shobjidl.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(shell); | |
| static const BOOL is_win64 = sizeof(void *) > sizeof(int); | |
| /* | |
| ########## Combining and Constructing paths ########## | |
| */ | |
| /************************************************************************* | |
| * PathAppend [SHELL32.36] | |
| */ | |
| BOOL WINAPI PathAppendAW( | |
| LPVOID lpszPath1, | |
| LPCVOID lpszPath2) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathAppendW(lpszPath1, lpszPath2); | |
| return PathAppendA(lpszPath1, lpszPath2); | |
| } | |
| /************************************************************************* | |
| * PathCombine [SHELL32.37] | |
| */ | |
| LPVOID WINAPI PathCombineAW( | |
| LPVOID szDest, | |
| LPCVOID lpszDir, | |
| LPCVOID lpszFile) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathCombineW( szDest, lpszDir, lpszFile ); | |
| return PathCombineA( szDest, lpszDir, lpszFile ); | |
| } | |
| /************************************************************************* | |
| * PathAddBackslash [SHELL32.32] | |
| */ | |
| LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| return PathAddBackslashW(lpszPath); | |
| return PathAddBackslashA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathBuildRoot [SHELL32.30] | |
| */ | |
| LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| return PathBuildRootW(lpszPath, drive); | |
| return PathBuildRootA(lpszPath, drive); | |
| } | |
| /* | |
| Extracting Component Parts | |
| */ | |
| /************************************************************************* | |
| * PathFindFileName [SHELL32.34] | |
| */ | |
| LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| return PathFindFileNameW(lpszPath); | |
| return PathFindFileNameA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathFindExtension [SHELL32.31] | |
| */ | |
| LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathFindExtensionW(lpszPath); | |
| return PathFindExtensionA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathGetExtensionA [internal] | |
| * | |
| * NOTES | |
| * exported by ordinal | |
| * return value points to the first char after the dot | |
| */ | |
| static LPSTR PathGetExtensionA(LPCSTR lpszPath) | |
| { | |
| TRACE("(%s)\n",lpszPath); | |
| lpszPath = PathFindExtensionA(lpszPath); | |
| return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathGetExtensionW [internal] | |
| */ | |
| static LPWSTR PathGetExtensionW(LPCWSTR lpszPath) | |
| { | |
| TRACE("(%s)\n",debugstr_w(lpszPath)); | |
| lpszPath = PathFindExtensionW(lpszPath); | |
| return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathGetExtension [SHELL32.158] | |
| */ | |
| LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,DWORD void1, DWORD void2) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathGetExtensionW(lpszPath); | |
| return PathGetExtensionA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathGetArgs [SHELL32.52] | |
| */ | |
| LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathGetArgsW(lpszPath); | |
| return PathGetArgsA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathGetDriveNumber [SHELL32.57] | |
| */ | |
| int WINAPI PathGetDriveNumberAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathGetDriveNumberW(lpszPath); | |
| return PathGetDriveNumberA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathRemoveFileSpec [SHELL32.35] | |
| */ | |
| BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathRemoveFileSpecW(lpszPath); | |
| return PathRemoveFileSpecA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathStripPath [SHELL32.38] | |
| */ | |
| void WINAPI PathStripPathAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| PathStripPathW(lpszPath); | |
| else | |
| PathStripPathA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathStripToRoot [SHELL32.50] | |
| */ | |
| BOOL WINAPI PathStripToRootAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathStripToRootW(lpszPath); | |
| return PathStripToRootA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathRemoveArgs [SHELL32.251] | |
| */ | |
| void WINAPI PathRemoveArgsAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| PathRemoveArgsW(lpszPath); | |
| else | |
| PathRemoveArgsA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathRemoveExtension [SHELL32.250] | |
| */ | |
| void WINAPI PathRemoveExtensionAW(LPVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| PathRemoveExtensionW(lpszPath); | |
| else | |
| PathRemoveExtensionA(lpszPath); | |
| } | |
| /* | |
| Path Manipulations | |
| */ | |
| /************************************************************************* | |
| * PathGetShortPathA [internal] | |
| */ | |
| static void PathGetShortPathA(LPSTR pszPath) | |
| { | |
| CHAR path[MAX_PATH]; | |
| TRACE("%s\n", pszPath); | |
| if (GetShortPathNameA(pszPath, path, MAX_PATH)) | |
| { | |
| lstrcpyA(pszPath, path); | |
| } | |
| } | |
| /************************************************************************* | |
| * PathGetShortPathW [internal] | |
| */ | |
| static void PathGetShortPathW(LPWSTR pszPath) | |
| { | |
| WCHAR path[MAX_PATH]; | |
| TRACE("%s\n", debugstr_w(pszPath)); | |
| if (GetShortPathNameW(pszPath, path, MAX_PATH)) | |
| { | |
| lstrcpyW(pszPath, path); | |
| } | |
| } | |
| /************************************************************************* | |
| * PathGetShortPath [SHELL32.92] | |
| */ | |
| VOID WINAPI PathGetShortPathAW(LPVOID pszPath) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| PathGetShortPathW(pszPath); | |
| PathGetShortPathA(pszPath); | |
| } | |
| /************************************************************************* | |
| * PathRemoveBlanks [SHELL32.33] | |
| */ | |
| void WINAPI PathRemoveBlanksAW(LPVOID str) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| PathRemoveBlanksW(str); | |
| else | |
| PathRemoveBlanksA(str); | |
| } | |
| /************************************************************************* | |
| * PathQuoteSpaces [SHELL32.55] | |
| */ | |
| VOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| PathQuoteSpacesW(lpszPath); | |
| else | |
| PathQuoteSpacesA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathUnquoteSpaces [SHELL32.56] | |
| */ | |
| VOID WINAPI PathUnquoteSpacesAW(LPVOID str) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| PathUnquoteSpacesW(str); | |
| else | |
| PathUnquoteSpacesA(str); | |
| } | |
| /************************************************************************* | |
| * PathParseIconLocation [SHELL32.249] | |
| */ | |
| int WINAPI PathParseIconLocationAW (LPVOID lpszPath) | |
| { | |
| if(SHELL_OsIsUnicode()) | |
| return PathParseIconLocationW(lpszPath); | |
| return PathParseIconLocationA(lpszPath); | |
| } | |
| /* | |
| ########## Path Testing ########## | |
| */ | |
| /************************************************************************* | |
| * PathIsUNC [SHELL32.39] | |
| */ | |
| BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsUNCW( lpszPath ); | |
| return PathIsUNCA( lpszPath ); | |
| } | |
| /************************************************************************* | |
| * PathIsRelative [SHELL32.40] | |
| */ | |
| BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsRelativeW( lpszPath ); | |
| return PathIsRelativeA( lpszPath ); | |
| } | |
| /************************************************************************* | |
| * PathIsRoot [SHELL32.29] | |
| */ | |
| BOOL WINAPI PathIsRootAW(LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsRootW(lpszPath); | |
| return PathIsRootA(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathIsExeA [internal] | |
| */ | |
| static BOOL PathIsExeA (LPCSTR lpszPath) | |
| { | |
| 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; | |
| } | |
| /************************************************************************* | |
| * PathIsExeW [internal] | |
| */ | |
| static BOOL PathIsExeW (LPCWSTR lpszPath) | |
| { | |
| LPCWSTR lpszExtension = PathGetExtensionW(lpszPath); | |
| int i; | |
| static const WCHAR lpszExtensions[][4] = | |
| {L"exe", L"com", L"pif",L"cmd", L"bat", L"scf",L"scr",L"" }; | |
| TRACE("path=%s\n",debugstr_w(lpszPath)); | |
| for(i=0; lpszExtensions[i][0]; i++) | |
| if (!wcsicmp(lpszExtension,lpszExtensions[i])) return TRUE; | |
| return FALSE; | |
| } | |
| /************************************************************************* | |
| * PathIsExe [SHELL32.43] | |
| */ | |
| BOOL WINAPI PathIsExeAW (LPCVOID path) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsExeW (path); | |
| return PathIsExeA(path); | |
| } | |
| /************************************************************************* | |
| * PathIsDirectory [SHELL32.159] | |
| */ | |
| BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsDirectoryW (lpszPath); | |
| return PathIsDirectoryA (lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathFileExists [SHELL32.45] | |
| */ | |
| BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathFileExistsW (lpszPath); | |
| return PathFileExistsA (lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathMatchSpec [SHELL32.46] | |
| */ | |
| BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathMatchSpecW( name, mask ); | |
| return PathMatchSpecA( name, mask ); | |
| } | |
| /************************************************************************* | |
| * PathIsSameRoot [SHELL32.650] | |
| */ | |
| BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathIsSameRootW(lpszPath1, lpszPath2); | |
| return PathIsSameRootA(lpszPath1, lpszPath2); | |
| } | |
| /************************************************************************* | |
| * IsLFNDriveA [SHELL32.41] | |
| */ | |
| BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath) | |
| { | |
| DWORD fnlen; | |
| if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0)) | |
| return FALSE; | |
| return fnlen > 12; | |
| } | |
| /************************************************************************* | |
| * IsLFNDriveW [SHELL32.42] | |
| */ | |
| BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath) | |
| { | |
| DWORD fnlen; | |
| if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0)) | |
| return FALSE; | |
| return fnlen > 12; | |
| } | |
| /************************************************************************* | |
| * IsLFNDrive [SHELL32.119] | |
| */ | |
| BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return IsLFNDriveW(lpszPath); | |
| return IsLFNDriveA(lpszPath); | |
| } | |
| /* | |
| ########## Creating Something Unique ########## | |
| */ | |
| /************************************************************************* | |
| * PathMakeUniqueNameA [internal] | |
| */ | |
| static BOOL PathMakeUniqueNameA( | |
| LPSTR lpszBuffer, | |
| DWORD dwBuffSize, | |
| LPCSTR lpszShortName, | |
| LPCSTR lpszLongName, | |
| LPCSTR lpszPathName) | |
| { | |
| FIXME("%p %lu %s %s %s stub\n", | |
| lpszBuffer, dwBuffSize, debugstr_a(lpszShortName), | |
| debugstr_a(lpszLongName), debugstr_a(lpszPathName)); | |
| return TRUE; | |
| } | |
| /************************************************************************* | |
| * PathMakeUniqueNameW [internal] | |
| */ | |
| static BOOL PathMakeUniqueNameW( | |
| LPWSTR lpszBuffer, | |
| DWORD dwBuffSize, | |
| LPCWSTR lpszShortName, | |
| LPCWSTR lpszLongName, | |
| LPCWSTR lpszPathName) | |
| { | |
| FIXME("%p %lu %s %s %s stub\n", | |
| lpszBuffer, dwBuffSize, debugstr_w(lpszShortName), | |
| debugstr_w(lpszLongName), debugstr_w(lpszPathName)); | |
| return TRUE; | |
| } | |
| /************************************************************************* | |
| * PathMakeUniqueName [SHELL32.47] | |
| */ | |
| BOOL WINAPI PathMakeUniqueNameAW( | |
| LPVOID lpszBuffer, | |
| DWORD dwBuffSize, | |
| LPCVOID lpszShortName, | |
| LPCVOID lpszLongName, | |
| LPCVOID lpszPathName) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName); | |
| return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName); | |
| } | |
| /************************************************************************* | |
| * PathYetAnotherMakeUniqueName [SHELL32.75] | |
| */ | |
| BOOL WINAPI PathYetAnotherMakeUniqueName(LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname) | |
| { | |
| 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); | |
| lstrcpyW(retW, pathW); | |
| PathRemoveExtensionW(pathW); | |
| ext = PathFindExtensionW(file); | |
| /* now try to make it unique */ | |
| while (PathFileExistsW(retW)) | |
| { | |
| swprintf(retW, ARRAY_SIZE(retW), L"%s (%d)%s", pathW, i, ext); | |
| i++; | |
| } | |
| lstrcpyW(buffer, retW); | |
| TRACE("ret - %s\n", debugstr_w(buffer)); | |
| return TRUE; | |
| } | |
| /* | |
| ########## cleaning and resolving paths ########## | |
| */ | |
| /************************************************************************* | |
| * PathFindOnPath [SHELL32.145] | |
| */ | |
| BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID *sOtherDirs) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs); | |
| return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs); | |
| } | |
| /************************************************************************* | |
| * PathCleanupSpec [SHELL32.171] | |
| * | |
| * lpszFile is changed in place. | |
| */ | |
| int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW ) | |
| { | |
| 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 = lstrlenW(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; | |
| } | |
| /************************************************************************* | |
| * PathQualifyA [SHELL32] | |
| */ | |
| static BOOL PathQualifyA(LPCSTR pszPath) | |
| { | |
| FIXME("%s\n",pszPath); | |
| return FALSE; | |
| } | |
| /************************************************************************* | |
| * PathQualifyW [SHELL32] | |
| */ | |
| static BOOL PathQualifyW(LPCWSTR pszPath) | |
| { | |
| FIXME("%s\n",debugstr_w(pszPath)); | |
| return FALSE; | |
| } | |
| /************************************************************************* | |
| * PathQualify [SHELL32.49] | |
| */ | |
| BOOL WINAPI PathQualifyAW(LPCVOID pszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathQualifyW(pszPath); | |
| return PathQualifyA(pszPath); | |
| } | |
| static BOOL PathResolveA(char *path, const char **dirs, DWORD flags) | |
| { | |
| BOOL is_file_spec = PathIsFileSpecA(path); | |
| DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xbf; | |
| TRACE("(%s,%p,0x%08lx)\n", debugstr_a(path), dirs, flags); | |
| if (flags & PRF_VERIFYEXISTS) | |
| { | |
| if (PathFindOnPathExA(path, dirs, dwWhich)) | |
| { | |
| if (!PathIsFileSpecA(path)) GetFullPathNameA(path, MAX_PATH, path, NULL); | |
| return TRUE; | |
| } | |
| if (!is_file_spec) | |
| { | |
| GetFullPathNameA(path, MAX_PATH, path, NULL); | |
| if (PathFileExistsDefExtA(path, dwWhich)) | |
| return TRUE; | |
| } | |
| SetLastError(ERROR_FILE_NOT_FOUND); | |
| return FALSE; | |
| } | |
| if (is_file_spec) | |
| { | |
| SetLastError(ERROR_FILE_NOT_FOUND); | |
| return FALSE; | |
| } | |
| GetFullPathNameA(path, MAX_PATH, path, NULL); | |
| return TRUE; | |
| } | |
| BOOL WINAPI PathResolveW(WCHAR *path, const WCHAR **dirs, DWORD flags) | |
| { | |
| BOOL is_file_spec = PathIsFileSpecW(path); | |
| DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xbf; | |
| TRACE("(%s,%p,0x%08lx)\n", debugstr_w(path), dirs, flags); | |
| if (flags & PRF_VERIFYEXISTS) | |
| { | |
| if (PathFindOnPathExW(path, dirs, dwWhich)) | |
| { | |
| if (!PathIsFileSpecW(path)) GetFullPathNameW(path, MAX_PATH, path, NULL); | |
| return TRUE; | |
| } | |
| if (!is_file_spec) | |
| { | |
| GetFullPathNameW(path, MAX_PATH, path, NULL); | |
| if (PathFileExistsDefExtW(path, dwWhich)) | |
| return TRUE; | |
| } | |
| SetLastError(ERROR_FILE_NOT_FOUND); | |
| return FALSE; | |
| } | |
| if (is_file_spec) | |
| { | |
| SetLastError(ERROR_FILE_NOT_FOUND); | |
| return FALSE; | |
| } | |
| GetFullPathNameW(path, MAX_PATH, path, NULL); | |
| return TRUE; | |
| } | |
| /************************************************************************* | |
| * PathResolve [SHELL32.51] | |
| */ | |
| BOOL WINAPI PathResolveAW(void *path, const void **paths, DWORD flags) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathResolveW(path, (const WCHAR **)paths, flags); | |
| else | |
| return PathResolveA(path, (const char **)paths, flags); | |
| } | |
| /************************************************************************* | |
| * PathProcessCommandA | |
| */ | |
| static LONG PathProcessCommandA ( | |
| LPCSTR lpszPath, | |
| LPSTR lpszBuff, | |
| DWORD dwBuffSize, | |
| DWORD dwFlags) | |
| { | |
| FIXME("%s %p 0x%04lx 0x%04lx stub\n", | |
| lpszPath, lpszBuff, dwBuffSize, dwFlags); | |
| if(!lpszPath) return -1; | |
| if(lpszBuff) strcpy(lpszBuff, lpszPath); | |
| return strlen(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathProcessCommandW | |
| */ | |
| static LONG PathProcessCommandW ( | |
| LPCWSTR lpszPath, | |
| LPWSTR lpszBuff, | |
| DWORD dwBuffSize, | |
| DWORD dwFlags) | |
| { | |
| FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n", | |
| debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags); | |
| if(!lpszPath) return -1; | |
| if(lpszBuff) lstrcpyW(lpszBuff, lpszPath); | |
| return lstrlenW(lpszPath); | |
| } | |
| /************************************************************************* | |
| * PathProcessCommand (SHELL32.653) | |
| */ | |
| LONG WINAPI PathProcessCommandAW ( | |
| LPCVOID lpszPath, | |
| LPVOID lpszBuff, | |
| DWORD dwBuffSize, | |
| DWORD dwFlags) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags); | |
| return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags); | |
| } | |
| /* | |
| ########## special ########## | |
| */ | |
| /************************************************************************* | |
| * PathSetDlgItemPath (SHELL32.48) | |
| */ | |
| VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| PathSetDlgItemPathW(hDlg, id, pszPath); | |
| else | |
| PathSetDlgItemPathA(hDlg, id, pszPath); | |
| } | |
| typedef 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, | |
| CSIDL_Type_ProgramData, | |
| } CSIDL_Type; | |
| #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 | |
| typedef struct | |
| { | |
| IApplicationDestinations IApplicationDestinations_iface; | |
| LONG ref; | |
| } IApplicationDestinationsImpl; | |
| static inline IApplicationDestinationsImpl *impl_from_IApplicationDestinations( IApplicationDestinations *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, IApplicationDestinationsImpl, IApplicationDestinations_iface); | |
| } | |
| static HRESULT WINAPI ApplicationDestinations_QueryInterface(IApplicationDestinations *iface, REFIID riid, | |
| LPVOID *ppv) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv); | |
| if (ppv == NULL) | |
| return E_POINTER; | |
| if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IApplicationDestinations, riid)) | |
| { | |
| *ppv = &This->IApplicationDestinations_iface; | |
| IUnknown_AddRef((IUnknown*)*ppv); | |
| TRACE("Returning IApplicationDestinations: %p\n", *ppv); | |
| return S_OK; | |
| } | |
| *ppv = NULL; | |
| FIXME("(%p)->(%s, %p) interface not supported.\n", This, debugstr_guid(riid), ppv); | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI ApplicationDestinations_AddRef(IApplicationDestinations *iface) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| ULONG ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p), new refcount=%li\n", This, ref); | |
| return ref; | |
| } | |
| static ULONG WINAPI ApplicationDestinations_Release(IApplicationDestinations *iface) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| ULONG ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p), new refcount=%li\n", This, ref); | |
| if (ref == 0) | |
| free(This); | |
| return ref; | |
| } | |
| static HRESULT WINAPI ApplicationDestinations_SetAppID(IApplicationDestinations *iface, const WCHAR *appid) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| FIXME("(%p, %s) stub!\n", This, debugstr_w(appid)); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI ApplicationDestinations_RemoveDestination(IApplicationDestinations *iface, IUnknown *punk) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| FIXME("(%p, %p) stub!\n", This, punk); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI ApplicationDestinations_RemoveAllDestinations(IApplicationDestinations *iface) | |
| { | |
| IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface); | |
| FIXME("(%p) stub!\n", This); | |
| return E_NOTIMPL; | |
| } | |
| static const IApplicationDestinationsVtbl ApplicationDestinationsVtbl = | |
| { | |
| ApplicationDestinations_QueryInterface, | |
| ApplicationDestinations_AddRef, | |
| ApplicationDestinations_Release, | |
| ApplicationDestinations_SetAppID, | |
| ApplicationDestinations_RemoveDestination, | |
| ApplicationDestinations_RemoveAllDestinations | |
| }; | |
| HRESULT WINAPI ApplicationDestinations_Constructor(IUnknown *outer, REFIID riid, LPVOID *ppv) | |
| { | |
| IApplicationDestinationsImpl *This; | |
| HRESULT hr; | |
| TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv); | |
| if (outer) | |
| return CLASS_E_NOAGGREGATION; | |
| if (!(This = SHAlloc(sizeof(*This)))) | |
| return E_OUTOFMEMORY; | |
| This->IApplicationDestinations_iface.lpVtbl = &ApplicationDestinationsVtbl; | |
| This->ref = 0; | |
| hr = IUnknown_QueryInterface(&This->IApplicationDestinations_iface, riid, ppv); | |
| if (FAILED(hr)) | |
| SHFree(This); | |
| return hr; | |
| } | |
| typedef struct | |
| { | |
| IApplicationDocumentLists IApplicationDocumentLists_iface; | |
| LONG ref; | |
| } IApplicationDocumentListsImpl; | |
| static inline IApplicationDocumentListsImpl *impl_from_IApplicationDocumentLists( IApplicationDocumentLists *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, IApplicationDocumentListsImpl, IApplicationDocumentLists_iface); | |
| } | |
| static HRESULT WINAPI ApplicationDocumentLists_QueryInterface(IApplicationDocumentLists *iface, | |
| REFIID riid, LPVOID *ppv) | |
| { | |
| IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface); | |
| TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv); | |
| if (ppv == NULL) | |
| return E_POINTER; | |
| if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IApplicationDocumentLists, riid)) | |
| { | |
| *ppv = &This->IApplicationDocumentLists_iface; | |
| IUnknown_AddRef((IUnknown*)*ppv); | |
| TRACE("Returning IApplicationDocumentLists: %p\n", *ppv); | |
| return S_OK; | |
| } | |
| *ppv = NULL; | |
| FIXME("(%p)->(%s, %p) interface not supported.\n", This, debugstr_guid(riid), ppv); | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI ApplicationDocumentLists_AddRef(IApplicationDocumentLists *iface) | |
| { | |
| IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface); | |
| ULONG ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p), new refcount=%li\n", This, ref); | |
| return ref; | |
| } | |
| static ULONG WINAPI ApplicationDocumentLists_Release(IApplicationDocumentLists *iface) | |
| { | |
| IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface); | |
| ULONG ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p), new refcount=%li\n", This, ref); | |
| if (ref == 0) | |
| free(This); | |
| return ref; | |
| } | |
| static HRESULT WINAPI ApplicationDocumentLists_SetAppID(IApplicationDocumentLists *iface, | |
| const WCHAR *appid) | |
| { | |
| IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface); | |
| FIXME("(%p, %s) stub!\n", This, debugstr_w(appid)); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI ApplicationDocumentLists_GetList(IApplicationDocumentLists *iface, | |
| APPDOCLISTTYPE list_type, UINT item_count, | |
| REFIID riid, void **obj) | |
| { | |
| IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface); | |
| FIXME("(%p, %u, %u, %s, %p): stub\n", This, list_type, item_count, debugstr_guid(riid), obj); | |
| return E_NOTIMPL; | |
| } | |
| static const IApplicationDocumentListsVtbl ApplicationDocumentListsVtbl = | |
| { | |
| ApplicationDocumentLists_QueryInterface, | |
| ApplicationDocumentLists_AddRef, | |
| ApplicationDocumentLists_Release, | |
| ApplicationDocumentLists_SetAppID, | |
| ApplicationDocumentLists_GetList | |
| }; | |
| HRESULT WINAPI ApplicationDocumentLists_Constructor(IUnknown *outer, REFIID riid, LPVOID *ppv) | |
| { | |
| IApplicationDocumentListsImpl *This; | |
| HRESULT hr; | |
| TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv); | |
| if (outer) | |
| return CLASS_E_NOAGGREGATION; | |
| if (!(This = SHAlloc(sizeof(*This)))) | |
| return E_OUTOFMEMORY; | |
| This->IApplicationDocumentLists_iface.lpVtbl = &ApplicationDocumentListsVtbl; | |
| This->ref = 0; | |
| hr = IUnknown_QueryInterface(&This->IApplicationDocumentLists_iface, riid, ppv); | |
| if (FAILED(hr)) | |
| SHFree(This); | |
| return hr; | |
| } | |
| typedef struct | |
| { | |
| const KNOWNFOLDERID *id; | |
| CSIDL_Type type; | |
| const WCHAR *value; | |
| const WCHAR *def_path; /* fallback string or resource ID */ | |
| KF_CATEGORY category; | |
| const WCHAR *name; | |
| const KNOWNFOLDERID *parent; | |
| const WCHAR *path; | |
| const WCHAR *parsing; | |
| DWORD attributes; | |
| KF_DEFINITION_FLAGS flags; | |
| const FOLDERTYPEID *typeid; | |
| } CSIDL_DATA; | |
| static const CSIDL_DATA CSIDL_Data[] = | |
| { | |
| { /* 0x00 - CSIDL_DESKTOP */ | |
| .id = &FOLDERID_Desktop, | |
| .type = CSIDL_Type_User, | |
| .value = L"Desktop", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Desktop", | |
| .path = L"Desktop", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x01 - CSIDL_INTERNET */ | |
| .id = &FOLDERID_InternetFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"InternetFolder", | |
| .parsing = L"::{871C5380-42A0-1069-A2EA-08002B30309D}", | |
| }, | |
| { /* 0x02 - CSIDL_PROGRAMS */ | |
| .id = &FOLDERID_Programs, | |
| .type = CSIDL_Type_User, | |
| .value = L"Programs", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Programs", | |
| .parent = &FOLDERID_StartMenu, | |
| .path = L"Programs", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x03 - CSIDL_CONTROLS (.CPL files) */ | |
| .id = &FOLDERID_ControlPanelFolder, | |
| .type = CSIDL_Type_SystemPath, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"ControlPanelFolder", | |
| .path = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}", | |
| .parsing = L"::{26EE0668-A00A-44D7-9371-BEB064C98683}\\0", | |
| }, | |
| { /* 0x04 - CSIDL_PRINTERS */ | |
| .id = &FOLDERID_PrintersFolder, | |
| .type = CSIDL_Type_SystemPath, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"PrintersFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}", | |
| }, | |
| { /* 0x05 - CSIDL_PERSONAL */ | |
| .id = &FOLDERID_Documents, | |
| .type = CSIDL_Type_User, | |
| .value = L"Personal", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Personal", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Documents", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{FDD39AD0-238F-46AF-ADB4-6C85480369C7}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE, | |
| }, | |
| { /* 0x06 - CSIDL_FAVORITES */ | |
| .id = &FOLDERID_Favorites, | |
| .type = CSIDL_Type_User, | |
| .value = L"Favorites", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Favorites", | |
| .path = L"Favorites", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x07 - CSIDL_STARTUP */ | |
| .id = &FOLDERID_Startup, | |
| .type = CSIDL_Type_User, | |
| .value = L"StartUp", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Startup", | |
| .parent = &FOLDERID_Programs, | |
| .path = L"StartUp", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x08 - CSIDL_RECENT */ | |
| .id = &FOLDERID_Recent, | |
| .type = CSIDL_Type_User, | |
| .value = L"Recent", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Recent", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Recent", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x09 - CSIDL_SENDTO */ | |
| .id = &FOLDERID_SendTo, | |
| .type = CSIDL_Type_User, | |
| .value = L"SendTo", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"SendTo", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\SendTo", | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */ | |
| .id = &FOLDERID_RecycleBinFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"RecycleBinFolder", | |
| .parsing = L"::{645FF040-5081-101B-9F08-00AA002F954E}", | |
| }, | |
| { /* 0x0b - CSIDL_STARTMENU */ | |
| .id = &FOLDERID_StartMenu, | |
| .type = CSIDL_Type_User, | |
| .value = L"Start Menu", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Start Menu", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Start Menu", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x0c - CSIDL_MYDOCUMENTS */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */ | |
| }, | |
| { /* 0x0d - CSIDL_MYMUSIC */ | |
| .id = &FOLDERID_Music, | |
| .type = CSIDL_Type_User, | |
| .value = L"My Music", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"My Music", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Music", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{4BD8D571-6D19-48D3-BE97-422220080E43}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE, | |
| }, | |
| { /* 0x0e - CSIDL_MYVIDEO */ | |
| .id = &FOLDERID_Videos, | |
| .type = CSIDL_Type_User, | |
| .value = L"My Videos", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"My Video", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Videos", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{18989B1D-99B5-455B-841C-AB7C74E4DDFC}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE, | |
| }, | |
| { /* 0x0f - unassigned */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x10 - CSIDL_DESKTOPDIRECTORY */ | |
| .id = &FOLDERID_Desktop, | |
| .type = CSIDL_Type_User, | |
| .value = L"Desktop", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Desktop", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Desktop", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x11 - CSIDL_DRIVES */ | |
| .id = &FOLDERID_ComputerFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"MyComputerFolder", | |
| .parsing = L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}", | |
| }, | |
| { /* 0x12 - CSIDL_NETWORK */ | |
| .id = &FOLDERID_NetworkFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"NetworkPlacesFolder", | |
| .parsing = L"::{F02C1A0D-BE21-4350-88B0-7367FC96EF3C}", | |
| }, | |
| { /* 0x13 - CSIDL_NETHOOD */ | |
| .id = &FOLDERID_NetHood, | |
| .type = CSIDL_Type_User, | |
| .value = L"NetHood", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"NetHood", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Network Shortcuts", | |
| }, | |
| { /* 0x14 - CSIDL_FONTS */ | |
| .id = &FOLDERID_Fonts, | |
| .type = CSIDL_Type_WindowsPath, | |
| .value = L"Fonts", | |
| .def_path = L"Fonts", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"Fonts", | |
| .parent = &FOLDERID_Windows, | |
| .typeid = &FOLDERID_Windows | |
| }, | |
| { /* 0x15 - CSIDL_TEMPLATES */ | |
| .id = &FOLDERID_Templates, | |
| .type = CSIDL_Type_User, | |
| .value = L"Templates", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Templates", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Templates", | |
| }, | |
| { /* 0x16 - CSIDL_COMMON_STARTMENU */ | |
| .id = &FOLDERID_CommonStartMenu, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common Start Menu", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Start Menu", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"Microsoft\\Windows\\Start Menu", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x17 - CSIDL_COMMON_PROGRAMS */ | |
| .id = &FOLDERID_CommonPrograms, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common Programs", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Programs", | |
| .parent = &FOLDERID_CommonStartMenu, | |
| .path = L"Programs", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x18 - CSIDL_COMMON_STARTUP */ | |
| .id = &FOLDERID_CommonStartup, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common StartUp", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Startup", | |
| .parent = &FOLDERID_CommonPrograms, | |
| .path = L"StartUp", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */ | |
| .id = &FOLDERID_PublicDesktop, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"Common Desktop", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Desktop", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Desktop", | |
| .attributes = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x1a - CSIDL_APPDATA */ | |
| .id = &FOLDERID_RoamingAppData, | |
| .type = CSIDL_Type_User, | |
| .value = L"AppData", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"AppData", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"AppData\\Roaming", | |
| }, | |
| { /* 0x1b - CSIDL_PRINTHOOD */ | |
| .id = &FOLDERID_PrintHood, | |
| .type = CSIDL_Type_User, | |
| .value = L"PrintHood", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"PrintHood", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Printer Shortcuts", | |
| }, | |
| { /* 0x1c - CSIDL_LOCAL_APPDATA */ | |
| .id = &FOLDERID_LocalAppData, | |
| .type = CSIDL_Type_User, | |
| .value = L"Local AppData", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Local AppData", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"AppData\\Local", | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x1d - CSIDL_ALTSTARTUP */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_NonExistent, | |
| }, | |
| { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_NonExistent, | |
| }, | |
| { /* 0x1f - CSIDL_COMMON_FAVORITES */ | |
| .id = &FOLDERID_Favorites, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"Common Favorites", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Favorites", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Favorites", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x20 - CSIDL_INTERNET_CACHE */ | |
| .id = &FOLDERID_InternetCache, | |
| .type = CSIDL_Type_User, | |
| .value = L"Cache", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Cache", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\INetCache", | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY, | |
| }, | |
| { /* 0x21 - CSIDL_COOKIES */ | |
| .id = &FOLDERID_Cookies, | |
| .type = CSIDL_Type_User, | |
| .value = L"Cookies", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Cookies", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\INetCookies", | |
| }, | |
| { /* 0x22 - CSIDL_HISTORY */ | |
| .id = &FOLDERID_History, | |
| .type = CSIDL_Type_User, | |
| .value = L"History", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"History", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\History", | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY, | |
| }, | |
| { /* 0x23 - CSIDL_COMMON_APPDATA */ | |
| .id = &FOLDERID_ProgramData, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common AppData", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"Common AppData", | |
| }, | |
| { /* 0x24 - CSIDL_WINDOWS */ | |
| .id = &FOLDERID_Windows, | |
| .type = CSIDL_Type_WindowsPath, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"Windows", | |
| }, | |
| { /* 0x25 - CSIDL_SYSTEM */ | |
| .id = &FOLDERID_System, | |
| .type = CSIDL_Type_SystemPath, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"System", | |
| }, | |
| { /* 0x26 - CSIDL_PROGRAM_FILES */ | |
| .id = &FOLDERID_ProgramFiles, | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"ProgramFilesDir", | |
| .def_path = L"Program Files", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFiles", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x27 - CSIDL_MYPICTURES */ | |
| .id = &FOLDERID_Pictures, | |
| .type = CSIDL_Type_User, | |
| .value = L"My Pictures", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"My Pictures", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Pictures", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{33E28130-4E1E-4676-835A-98395C3BC3BB}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE, | |
| }, | |
| { /* 0x28 - CSIDL_PROFILE */ | |
| .id = &FOLDERID_Profile, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"Profile", | |
| }, | |
| { /* 0x29 - CSIDL_SYSTEMX86 */ | |
| .id = &FOLDERID_SystemX86, | |
| .type = CSIDL_Type_SystemX86Path, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"SystemX86", | |
| }, | |
| { /* 0x2a - CSIDL_PROGRAM_FILESX86 */ | |
| .id = &FOLDERID_ProgramFilesX86, | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"ProgramFilesDir (x86)", | |
| .def_path = L"Program Files (x86)", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFilesX86", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */ | |
| .id = &FOLDERID_ProgramFilesCommon, | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"CommonFilesDir", | |
| .def_path = L"Program Files\\Common Files", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFilesCommon", | |
| }, | |
| { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */ | |
| .id = &FOLDERID_ProgramFilesCommonX86, | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"CommonFilesDir (x86)", | |
| .def_path = L"Program Files (x86)\\Common Files", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFilesCommonX86", | |
| }, | |
| { /* 0x2d - CSIDL_COMMON_TEMPLATES */ | |
| .id = &FOLDERID_CommonTemplates, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common Templates", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Templates", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"Microsoft\\Windows\\Templates", | |
| }, | |
| { /* 0x2e - CSIDL_COMMON_DOCUMENTS */ | |
| .id = &FOLDERID_PublicDocuments, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"Common Documents", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Documents", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Documents", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */ | |
| .id = &FOLDERID_CommonAdminTools, | |
| .type = CSIDL_Type_ProgramData, | |
| .value = L"Common Administrative Tools", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Common Administrative Tools", | |
| .parent = &FOLDERID_CommonPrograms, | |
| .path = L"Administrative Tools", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x30 - CSIDL_ADMINTOOLS */ | |
| .id = &FOLDERID_AdminTools, | |
| .type = CSIDL_Type_User, | |
| .value = L"Administrative Tools", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Administrative Tools", | |
| .parent = &FOLDERID_Programs, | |
| .path = L"Administrative Tools", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x31 - CSIDL_CONNECTIONS */ | |
| .id = &FOLDERID_ConnectionsFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"ConnectionsFolder", | |
| .path = L"Administrative Tools", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{7007ACC7-3202-11D1-AAD2-00805FC1270E}", | |
| }, | |
| { /* 0x32 - unassigned */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x33 - unassigned */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x34 - unassigned */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x35 - CSIDL_COMMON_MUSIC */ | |
| .id = &FOLDERID_PublicMusic, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"CommonMusic", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"CommonMusic", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Music", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x36 - CSIDL_COMMON_PICTURES */ | |
| .id = &FOLDERID_PublicPictures, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"CommonPictures", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"CommonPictures", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Pictures", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x37 - CSIDL_COMMON_VIDEO */ | |
| .id = &FOLDERID_PublicVideos, | |
| .type = CSIDL_Type_AllUsers, | |
| .value = L"CommonVideo", | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"CommonVideo", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Videos", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x38 - CSIDL_RESOURCES */ | |
| .id = &FOLDERID_ResourceDir, | |
| .type = CSIDL_Type_WindowsPath, | |
| .def_path = L"Resources", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ResourceDir", | |
| }, | |
| { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */ | |
| .id = &FOLDERID_LocalizedResourcesDir, | |
| .type = CSIDL_Type_NonExistent, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"LocalizedResourcesDir", | |
| }, | |
| { /* 0x3a - CSIDL_COMMON_OEM_LINKS */ | |
| .id = &FOLDERID_CommonOEMLinks, | |
| .type = CSIDL_Type_ProgramData, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"OEM Links", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"OEM Links", | |
| }, | |
| { /* 0x3b - CSIDL_CDBURN_AREA */ | |
| .id = &FOLDERID_CDBurning, | |
| .type = CSIDL_Type_User, | |
| .value = L"CD Burning", | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"CD Burning", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\Burn\\Burn", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY, | |
| }, | |
| { /* 0x3c unassigned */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x3d - CSIDL_COMPUTERSNEARME */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| }, | |
| { /* 0x3e - CSIDL_PROFILES */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, /* oddly, this matches WinXP */ | |
| }, | |
| { /* 0x3f */ | |
| .id = &FOLDERID_AddNewPrograms, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"AddNewProgramsFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{15eae92e-f17a-4431-9f28-805e482dafd4}", | |
| }, | |
| { /* 0x40 */ | |
| .id = &FOLDERID_AppUpdates, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"AppUpdatesFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{7b81be6a-ce2b-4676-a29e-eb907a5126c5}\\::{d450a8a1-9568-45c7-9c0e-b4f9fb4537bd}", | |
| }, | |
| { /* 0x41 */ | |
| .id = &FOLDERID_ChangeRemovePrograms, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"ChangeRemoveProgramsFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{7b81be6a-ce2b-4676-a29e-eb907a5126c5}", | |
| }, | |
| { /* 0x42 */ | |
| .id = &FOLDERID_ConflictFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"ConflictFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{9C73F5E5-7AE7-4E32-A8E8-8D23B85255BF}\\::{E413D040-6788-4C22-957E-175D1C513A34},", | |
| }, | |
| { /* 0x43 - CSIDL_CONTACTS */ | |
| .id = &FOLDERID_Contacts, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Contacts", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Contacts", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{56784854-C6CB-462B-8169-88E350ACB882}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x44 */ | |
| .id = &FOLDERID_DeviceMetadataStore, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Device Metadata Store", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"Microsoft\\Windows\\DeviceMetadataStore", | |
| }, | |
| { /* 0x45 */ | |
| .id = &GUID_NULL, | |
| .type = CSIDL_Type_Disallowed, | |
| }, | |
| { /* 0x46 */ | |
| .id = &FOLDERID_DocumentsLibrary, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"DocumentsLibrary", | |
| .parent = &FOLDERID_Libraries, | |
| .path = L"Documents.library-ms", | |
| .parsing = L"::{031E4825-7B94-4dc3-B131-E946B44C8DD5}\\{7b0db17d-9cd2-4a93-9733-46cc89022e7c}", | |
| .flags = KFDF_PRECREATE | KFDF_STREAM, | |
| }, | |
| { /* 0x47 - CSIDL_DOWNLOADS */ | |
| .id = &FOLDERID_Downloads, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Downloads", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Downloads", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x48 */ | |
| .id = &FOLDERID_Games, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"Games", | |
| .parsing = L"::{ED228FDF-9EA8-4870-83b1-96b02CFE0D52}", | |
| }, | |
| { /* 0x49 */ | |
| .id = &FOLDERID_GameTasks, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"GameTasks", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\GameExplorer", | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY, | |
| }, | |
| { /* 0x4a */ | |
| .id = &FOLDERID_HomeGroup, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"HomeGroupFolder", | |
| .parsing = L"::{B4FB3F98-C1EA-428d-A78A-D1F5659CBA93}", | |
| }, | |
| { /* 0x4b */ | |
| .id = &FOLDERID_ImplicitAppShortcuts, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"ImplicitAppShortcuts", | |
| .parent = &FOLDERID_UserPinned, | |
| .path = L"ImplicitAppShortcuts", | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x4c */ | |
| .id = &FOLDERID_Libraries, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Libraries", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\Libraries", | |
| .flags = KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x4d - CSIDL_LINKS */ | |
| .id = &FOLDERID_Links, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Links", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Links", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{bfb9d5e0-c6a9-404c-b2b2-ae6db6af4968}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x4e - CSIDL_APPDATA_LOCALLOW */ | |
| .id = &FOLDERID_LocalAppDataLow, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"LocalAppDataLow", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"AppData\\LocalLow", | |
| .attributes = FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x4f */ | |
| .id = &FOLDERID_MusicLibrary, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"MusicLibrary", | |
| .parent = &FOLDERID_Libraries, | |
| .path = L"Music.library-ms", | |
| .parsing = L"::{031E4825-7B94-4dc3-B131-E946B44C8DD5}\\{2112AB0A-C86A-4ffe-A368-0DE96E47012E}", | |
| .flags = KFDF_PRECREATE | KFDF_STREAM, | |
| }, | |
| { /* 0x50 */ | |
| .id = &FOLDERID_OriginalImages, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Original Images", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows Photo Gallery\\Original Images", | |
| }, | |
| { /* 0x51 */ | |
| .id = &FOLDERID_PhotoAlbums, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"PhotoAlbums", | |
| .parent = &FOLDERID_Pictures, | |
| .path = L"Slide Shows", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x52 */ | |
| .id = &FOLDERID_PicturesLibrary, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"PicturesLibrary", | |
| .parent = &FOLDERID_Libraries, | |
| .path = L"Pictures.library-ms", | |
| .parsing = L"::{031E4825-7B94-4dc3-B131-E946B44C8DD5}\\{A990AE9F-A03B-4e80-94BC-9912D7504104}", | |
| .flags = KFDF_PRECREATE | KFDF_STREAM, | |
| }, | |
| { /* 0x53 */ | |
| .id = &FOLDERID_Playlists, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Playlists", | |
| .parent = &FOLDERID_Music, | |
| .path = L"Playlists", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| }, | |
| { /* 0x54 */ | |
| .id = &FOLDERID_ProgramFilesX64, | |
| #ifdef _WIN64 | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"ProgramFilesDir", | |
| .def_path = L"Program Files", | |
| #else | |
| .type = CSIDL_Type_NonExistent, | |
| #endif | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFilesX64", | |
| }, | |
| { /* 0x55 */ | |
| .id = &FOLDERID_ProgramFilesCommonX64, | |
| #ifdef _WIN64 | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"ProgramFilesCommonX64", | |
| .def_path = L"Program Files\\Common Files", | |
| #else | |
| .type = CSIDL_Type_NonExistent, | |
| #endif | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"ProgramFilesCommonX64", | |
| }, | |
| { /* 0x56 */ | |
| .id = &FOLDERID_Public, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"Public", | |
| .parsing = L"::{4336a54d-038b-4685-ab02-99bb52d3fb8b}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x57 */ | |
| .id = &FOLDERID_PublicDownloads, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"CommonDownloads", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Downloads", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x58 */ | |
| .id = &FOLDERID_PublicGameTasks, | |
| .type = CSIDL_Type_ProgramData, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"PublicGameTasks", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"Microsoft\\Windows\\GameExplorer", | |
| .flags = KFDF_LOCAL_REDIRECT_ONLY, | |
| }, | |
| { /* 0x59 */ | |
| .id = &FOLDERID_PublicLibraries, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"PublicLibraries", | |
| .parent = &FOLDERID_Public, | |
| .path = L"Libraries", | |
| .attributes = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x5a */ | |
| .id = &FOLDERID_PublicRingtones, | |
| .type = CSIDL_Type_ProgramData, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"CommonRingtones", | |
| .parent = &FOLDERID_ProgramData, | |
| .path = L"Microsoft\\Windows\\Ringtones", | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x5b */ | |
| .id = &FOLDERID_QuickLaunch, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Quick Launch", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Internet Explorer\\Quick Launch", | |
| }, | |
| { /* 0x5c */ | |
| .id = &FOLDERID_RecordedTVLibrary, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"RecordedTVLibrary", | |
| .parent = &FOLDERID_PublicLibraries, | |
| .path = L"RecordedTV.library-ms", | |
| .flags = KFDF_PRECREATE | KFDF_STREAM, | |
| }, | |
| { /* 0x5d */ | |
| .id = &FOLDERID_Ringtones, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Ringtones", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows\\Ringtones", | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x5e */ | |
| .id = &FOLDERID_SampleMusic, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"SampleMusic", | |
| .parent = &FOLDERID_PublicMusic, | |
| .path = L"Sample Music", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x5f */ | |
| .id = &FOLDERID_SamplePictures, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"SamplePictures", | |
| .parent = &FOLDERID_PublicPictures, | |
| .path = L"Sample Pictures", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x60 */ | |
| .id = &FOLDERID_SamplePlaylists, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"SamplePlaylists", | |
| .parent = &FOLDERID_PublicMusic, | |
| .path = L"Sample Playlists", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x61 */ | |
| .id = &FOLDERID_SampleVideos, | |
| .type = CSIDL_Type_AllUsers, | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"SampleVideos", | |
| .parent = &FOLDERID_PublicVideos, | |
| .path = L"Sample Videos", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x62 - CSIDL_SAVED_GAMES */ | |
| .id = &FOLDERID_SavedGames, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"SavedGames", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Saved Games", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{4C5C32FF-BB9D-43b0-B5B4-2D72E54EAAA4}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x63 - CSIDL_SEARCHES */ | |
| .id = &FOLDERID_SavedSearches, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Searches", | |
| .parent = &FOLDERID_Profile, | |
| .path = L"Searches", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}\\{7d1d3a04-debb-4115-95cf-2f29da2920da}", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, | |
| }, | |
| { /* 0x64 */ | |
| .id = &FOLDERID_SEARCH_CSC, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"CSCFolder", | |
| .parsing = L"shell:::{BD7A2E7B-21CB-41b2-A086-B309680C6B7E}\\*", | |
| }, | |
| { /* 0x65 */ | |
| .id = &FOLDERID_SEARCH_MAPI, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"MAPIFolder", | |
| .parsing = L"shell:::{89D83576-6BD1-4C86-9454-BEB04E94C819}\\*", | |
| }, | |
| { /* 0x66 */ | |
| .id = &FOLDERID_SearchHome, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"SearchHomeFolder", | |
| .parsing = L"::{9343812e-1c37-4a49-a12e-4b2d810d956b}", | |
| }, | |
| { /* 0x67 */ | |
| .id = &FOLDERID_SidebarDefaultParts, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_COMMON, | |
| .name = L"Default Gadgets", | |
| .parent = &FOLDERID_ProgramFiles, | |
| .path = L"Windows Sidebar\\Gadgets", | |
| }, | |
| { /* 0x68 */ | |
| .id = &FOLDERID_SidebarParts, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Gadgets", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Microsoft\\Windows Sidebar\\Gadgets", | |
| }, | |
| { /* 0x69 */ | |
| .id = &FOLDERID_SyncManagerFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"SyncCenterFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{9C73F5E5-7AE7-4E32-A8E8-8D23B85255BF}", | |
| }, | |
| { /* 0x6a */ | |
| .id = &FOLDERID_SyncResultsFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"SyncResultsFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{9C73F5E5-7AE7-4E32-A8E8-8D23B85255BF}\\::{BC48B32F-5910-47F5-8570-5074A8A5636A},", | |
| }, | |
| { /* 0x6b */ | |
| .id = &FOLDERID_SyncSetupFolder, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"SyncSetupFolder", | |
| .parsing = L"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{9C73F5E5-7AE7-4E32-A8E8-8D23B85255BF}\\::{F1390A9A-A3F4-4E5D-9C5F-98F3BD8D935C},", | |
| }, | |
| { /* 0x6c */ | |
| .id = &FOLDERID_UserPinned, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"User Pinned", | |
| .parent = &FOLDERID_QuickLaunch, | |
| .path = L"User Pinned", | |
| .attributes = FILE_ATTRIBUTE_HIDDEN, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x6d */ | |
| .id = &FOLDERID_UserProfiles, | |
| .type = CSIDL_Type_CurrVer, | |
| .value = L"Users", | |
| .def_path = L"Users", | |
| .category = KF_CATEGORY_FIXED, | |
| .name = L"UserProfiles", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE, | |
| }, | |
| { /* 0x6e */ | |
| .id = &FOLDERID_UserProgramFiles, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"UserProgramFiles", | |
| .parent = &FOLDERID_LocalAppData, | |
| .path = L"Programs", | |
| }, | |
| { /* 0x6f */ | |
| .id = &FOLDERID_UserProgramFilesCommon, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"UserProgramFilesCommon", | |
| .parent = &FOLDERID_UserProgramFiles, | |
| .path = L"Common", | |
| }, | |
| { /* 0x70 */ | |
| .id = &FOLDERID_UsersFiles, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"UsersFilesFolder", | |
| .parsing = L"::{59031a47-3f72-44a7-89c5-5595fe6b30ee}", | |
| }, | |
| { /* 0x71 */ | |
| .id = &FOLDERID_UsersLibraries, | |
| .type = CSIDL_Type_Disallowed, | |
| .category = KF_CATEGORY_VIRTUAL, | |
| .name = L"UsersLibrariesFolder", | |
| .parsing = L"::{031E4825-7B94-4dc3-B131-E946B44C8DD5}", | |
| }, | |
| { /* 0x72 */ | |
| .id = &FOLDERID_VideosLibrary, | |
| .type = CSIDL_Type_Disallowed, /* FIXME */ | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"VideosLibrary", | |
| .path = L"Videos.library-ms", | |
| .parsing = L"::{031E4825-7B94-4dc3-B131-E946B44C8DD5}\\{491E922F-5643-4af4-A7EB-4E7A138D8174}", | |
| }, | |
| { /* 0x73 */ | |
| .id = &FOLDERID_AccountPictures, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"AccountPictures", | |
| .parent = &FOLDERID_RoamingAppData, | |
| .path = L"Microsoft\\Windows\\AccountPictures", | |
| .attributes = FILE_ATTRIBUTE_READONLY, | |
| .flags = KFDF_PRECREATE | KFDF_ROAMABLE, | |
| }, | |
| { /* 0x74 */ | |
| .id = &FOLDERID_Screenshots, | |
| .type = CSIDL_Type_User, | |
| .category = KF_CATEGORY_PERUSER, | |
| .name = L"Screenshots", | |
| .parent = &FOLDERID_Pictures, | |
| .path = L"Screenshots", | |
| .flags = KFDF_PRECREATE | KFDF_ROAMABLE, | |
| }, | |
| }; | |
| static int csidl_from_id( const KNOWNFOLDERID *id ) | |
| { | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(CSIDL_Data); i++) | |
| if (IsEqualGUID( CSIDL_Data[i].id, id )) return i; | |
| return -1; | |
| } | |
| static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest); | |
| /* Gets the value named value from the registry key | |
| * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders | |
| * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which | |
| * is assumed to be MAX_PATH WCHARs in length. | |
| * If it exists, expands the value and writes the expanded value to | |
| * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders | |
| * Returns successful error code if the value was retrieved from the registry, | |
| * and a failure otherwise. | |
| */ | |
| static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix, | |
| LPCWSTR value, LPWSTR path) | |
| { | |
| 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) | |
| { | |
| lstrcpyW(shellFolderPath, userPrefix); | |
| PathAddBackslashW(shellFolderPath); | |
| lstrcatW(shellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"); | |
| pShellFolderPath = shellFolderPath; | |
| lstrcpyW(userShellFolderPath, userPrefix); | |
| PathAddBackslashW(userShellFolderPath); | |
| lstrcatW(userShellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"); | |
| pUserShellFolderPath = userShellFolderPath; | |
| } | |
| else | |
| { | |
| pUserShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"; | |
| pShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"; | |
| } | |
| 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]; | |
| _SHExpandEnvironmentStrings(path, szTemp); | |
| lstrcpynW(path, szTemp, MAX_PATH); | |
| } | |
| ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path, | |
| (lstrlenW(path) + 1) * sizeof(WCHAR)); | |
| if (ret != ERROR_SUCCESS) | |
| hr = HRESULT_FROM_WIN32(ret); | |
| else | |
| hr = S_OK; | |
| } | |
| else | |
| hr = E_FAIL; | |
| RegCloseKey(shellFolderKey); | |
| RegCloseKey(userShellFolderKey); | |
| TRACE("returning 0x%08lx\n", hr); | |
| return hr; | |
| } | |
| static void append_relative_path(BYTE folder, WCHAR *pszPath) | |
| { | |
| if (CSIDL_Data[folder].path) | |
| { | |
| PathAddBackslashW(pszPath); | |
| lstrcatW(pszPath, CSIDL_Data[folder].path); | |
| } | |
| else if (CSIDL_Data[folder].def_path) | |
| { | |
| PathAddBackslashW(pszPath); | |
| lstrcatW(pszPath, CSIDL_Data[folder].def_path); | |
| } | |
| } | |
| /* Gets a 'semi-expanded' default value of the CSIDL with index folder into | |
| * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean: | |
| * - Depending on the entry's type, the path may begin with an (unexpanded) | |
| * environment variable name. The caller is responsible for expanding | |
| * environment strings if so desired. | |
| * The types that are prepended with environment variables are: | |
| * CSIDL_Type_User: %USERPROFILE% | |
| * CSIDL_Type_AllUsers: %ALLUSERSPROFILE% | |
| * CSIDL_Type_CurrVer: %SystemDrive% | |
| * (Others might make sense too, but as yet are unneeded.) | |
| */ | |
| static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath) | |
| { | |
| HRESULT hr; | |
| TRACE("0x%02x,%p\n", folder, pszPath); | |
| if (folder >= ARRAY_SIZE(CSIDL_Data)) | |
| return E_INVALIDARG; | |
| if (!pszPath) | |
| return E_INVALIDARG; | |
| 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; | |
| } | |
| } | |
| if (!CSIDL_Data[folder].parent) | |
| { | |
| /* hit the root, sub in env var */ | |
| switch (CSIDL_Data[folder].type) | |
| { | |
| case CSIDL_Type_User: | |
| lstrcpyW(pszPath, L"%USERPROFILE%"); | |
| break; | |
| case CSIDL_Type_AllUsers: | |
| lstrcpyW(pszPath, L"%PUBLIC%"); | |
| break; | |
| case CSIDL_Type_ProgramData: | |
| lstrcpyW(pszPath, L"%ProgramData%"); | |
| break; | |
| case CSIDL_Type_CurrVer: | |
| lstrcpyW(pszPath, L"%SystemDrive%"); | |
| break; | |
| default: | |
| ; /* no corresponding env. var, do nothing */ | |
| } | |
| hr = S_OK; | |
| }else{ | |
| /* prepend with parent */ | |
| hr = _SHGetDefaultValue(csidl_from_id(CSIDL_Data[folder].parent), pszPath); | |
| } | |
| if (SUCCEEDED(hr)) | |
| append_relative_path(folder, pszPath); | |
| TRACE("returning 0x%08lx\n", hr); | |
| return hr; | |
| } | |
| /* Gets the (unexpanded) value of the folder with index folder into pszPath. | |
| * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value | |
| * can be overridden in the HKLM\\Software\\Microsoft\\Windows\\CurrentVersion key. | |
| * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in | |
| * the registry, uses _SHGetDefaultValue to get the value. | |
| */ | |
| static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder, | |
| LPWSTR pszPath) | |
| { | |
| HRESULT hr; | |
| TRACE("0x%08lx,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) | |
| hr = _SHGetDefaultValue(folder, pszPath); | |
| else | |
| { | |
| HKEY hKey; | |
| if (RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion", &hKey)) | |
| hr = E_FAIL; | |
| else | |
| { | |
| DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR); | |
| if (RegQueryValueExW(hKey, CSIDL_Data[folder].value, NULL, | |
| &dwType, (LPBYTE)pszPath, &dwPathLen) || | |
| (dwType != REG_SZ && dwType != REG_EXPAND_SZ)) | |
| { | |
| hr = _SHGetDefaultValue(folder, pszPath); | |
| 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].value, 0, dwType, | |
| (LPBYTE)pszPath, (lstrlenW(pszPath)+1)*sizeof(WCHAR)); | |
| } | |
| } | |
| else | |
| { | |
| pszPath[dwPathLen / sizeof(WCHAR)] = '\0'; | |
| hr = S_OK; | |
| } | |
| RegCloseKey(hKey); | |
| } | |
| } | |
| TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath)); | |
| return hr; | |
| } | |
| static LPWSTR _GetUserSidStringFromToken(HANDLE Token) | |
| { | |
| 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 = malloc(InfoSize); | |
| if (UserInfo == NULL) | |
| return NULL; | |
| if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize, | |
| &InfoSize)) | |
| { | |
| free(UserInfo); | |
| return NULL; | |
| } | |
| } | |
| if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr)) | |
| SidStr = NULL; | |
| if (UserInfo != (PTOKEN_USER) InfoBuffer) | |
| free(UserInfo); | |
| return SidStr; | |
| } | |
| /* Gets the user's path (unexpanded) for the CSIDL with index folder: | |
| * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise | |
| * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken: | |
| * - if hToken is -1, looks in HKEY_USERS\.Default | |
| * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE | |
| * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally | |
| * calls _SHGetDefaultValue for it. | |
| */ | |
| static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder, | |
| LPWSTR pszPath) | |
| { | |
| const WCHAR *szValueName; | |
| WCHAR buffer[40]; | |
| HRESULT hr; | |
| TRACE("%p,0x%08lx,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) | |
| { | |
| if (hToken != NULL && hToken != (HANDLE)-1) | |
| { | |
| FIXME("unsupported for user other than current or default\n"); | |
| return E_FAIL; | |
| } | |
| hr = _SHGetDefaultValue(folder, pszPath); | |
| } | |
| else | |
| { | |
| static const WCHAR DefaultW[] = L".Default"; | |
| 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].value; | |
| if (!szValueName) | |
| { | |
| StringFromGUID2( CSIDL_Data[folder].id, buffer, 39 ); | |
| szValueName = &buffer[0]; | |
| } | |
| 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); | |
| if (userPrefix != NULL && userPrefix != DefaultW) | |
| LocalFree((HLOCAL) userPrefix); | |
| } | |
| error: | |
| TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath)); | |
| return hr; | |
| } | |
| /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has | |
| * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls | |
| * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE. | |
| * If this fails, falls back to _SHGetDefaultValue. | |
| */ | |
| static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder, | |
| LPWSTR pszPath) | |
| { | |
| HRESULT hr; | |
| TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath); | |
| if (folder >= ARRAY_SIZE(CSIDL_Data)) | |
| return E_INVALIDARG; | |
| if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers && CSIDL_Data[folder].type != CSIDL_Type_ProgramData) | |
| return E_INVALIDARG; | |
| if (!pszPath) | |
| return E_INVALIDARG; | |
| if (dwFlags & SHGFP_TYPE_DEFAULT) | |
| hr = _SHGetDefaultValue(folder, pszPath); | |
| else | |
| { | |
| hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, | |
| CSIDL_Data[folder].value, pszPath); | |
| if (FAILED(hr)) | |
| hr = _SHGetDefaultValue(folder, pszPath); | |
| } | |
| TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath)); | |
| return hr; | |
| } | |
| static HRESULT _SHOpenProfilesKey(PHKEY pKey) | |
| { | |
| LONG lRet; | |
| DWORD disp; | |
| lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList", 0, NULL, 0, | |
| KEY_ALL_ACCESS, NULL, pKey, &disp); | |
| return HRESULT_FROM_WIN32(lRet); | |
| } | |
| /* Reads the value named szValueName from the key profilesKey (assumed to be | |
| * opened by _SHOpenProfilesKey) into szValue, which is assumed to be MAX_PATH | |
| * WCHARs in length. If it doesn't exist, returns szDefault (and saves | |
| * szDefault to the registry). | |
| */ | |
| static HRESULT _SHGetProfilesValue(HKEY profilesKey, LPCWSTR szValueName, | |
| LPWSTR szValue, LPCWSTR szDefault) | |
| { | |
| 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, | |
| (lstrlenW(szValue) + 1) * sizeof(WCHAR)); | |
| if (lRet) | |
| hr = HRESULT_FROM_WIN32(lRet); | |
| else | |
| hr = S_OK; | |
| } | |
| TRACE("returning 0x%08lx (output value is %s)\n", hr, debugstr_w(szValue)); | |
| return hr; | |
| } | |
| /* Attempts to expand environment variables from szSrc into szDest, which is | |
| * assumed to be MAX_PATH characters in length. Before referring to the | |
| * environment, handles a few variables directly, because the environment | |
| * variables may not be set when this is called (as during Wine's installation | |
| * when default values are being written to the registry). | |
| * The directly handled environment variables, and their source, are: | |
| * - ALLUSERSPROFILE, USERPROFILE: reads from the registry | |
| * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its | |
| * path | |
| * If one of the directly handled environment variables is expanded, only | |
| * expands a single variable, and only in the beginning of szSrc. | |
| */ | |
| static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest) | |
| { | |
| HRESULT hr; | |
| WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 }; | |
| HKEY key = NULL; | |
| 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] != '%') | |
| { | |
| lstrcpyW(szDest, szSrc); | |
| hr = S_OK; | |
| goto end; | |
| } | |
| /* 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); | |
| lstrcpyW( def_val + 3, L"users" ); | |
| hr = _SHGetProfilesValue(key, L"ProfilesDirectory", szProfilesPrefix, def_val ); | |
| } | |
| *szDest = 0; | |
| lstrcpyW(szTemp, szSrc); | |
| while (SUCCEEDED(hr) && szTemp[0] == '%') | |
| { | |
| if (!wcsnicmp(szTemp, L"%ALLUSERSPROFILE%", lstrlenW(L"%ALLUSERSPROFILE%"))) | |
| { | |
| WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH]; | |
| GetSystemDirectoryW(def_val, MAX_PATH); | |
| lstrcpyW( def_val + 3, L"users\\Public" ); | |
| hr = _SHGetProfilesValue(key, L"Public", szAllUsers, def_val); | |
| PathAppendW(szDest, szAllUsers); | |
| PathAppendW(szDest, szTemp + lstrlenW(L"%ALLUSERSPROFILE%")); | |
| } | |
| else if (!wcsnicmp(szTemp, L"%PUBLIC%", lstrlenW(L"%PUBLIC%"))) | |
| { | |
| WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH]; | |
| GetSystemDirectoryW(def_val, MAX_PATH); | |
| lstrcpyW( def_val + 3, L"users\\Public" ); | |
| hr = _SHGetProfilesValue(key, L"Public", szAllUsers, def_val); | |
| PathAppendW(szDest, szAllUsers); | |
| PathAppendW(szDest, szTemp + lstrlenW(L"%PUBLIC%")); | |
| } | |
| else if (!wcsnicmp(szTemp, L"%ProgramData%", lstrlenW(L"%ProgramData%"))) | |
| { | |
| WCHAR szProgramData[MAX_PATH], def_val[MAX_PATH]; | |
| HKEY shellFolderKey; | |
| DWORD dwType, dwPathLen = sizeof(def_val); | |
| BOOL in_registry = FALSE; | |
| if (!RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &shellFolderKey)) | |
| { | |
| if (!RegQueryValueExW(shellFolderKey, L"Common AppData", NULL, &dwType, | |
| (LPBYTE)def_val, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ)) | |
| in_registry = TRUE; | |
| RegCloseKey(shellFolderKey); | |
| } | |
| if (!in_registry) | |
| { | |
| GetSystemDirectoryW(def_val, MAX_PATH); | |
| lstrcpyW( def_val + 3, L"ProgramData" ); | |
| } | |
| hr = _SHGetProfilesValue(key, L"ProgramData", szProgramData, def_val); | |
| PathAppendW(szDest, szProgramData); | |
| PathAppendW(szDest, szTemp + lstrlenW(L"%ProgramData%")); | |
| } | |
| else if (!wcsnicmp(szTemp, L"%USERPROFILE%", lstrlenW(L"%USERPROFILE%"))) | |
| { | |
| WCHAR userName[MAX_PATH]; | |
| DWORD userLen = MAX_PATH; | |
| lstrcpyW(szDest, szProfilesPrefix); | |
| GetUserNameW(userName, &userLen); | |
| PathAppendW(szDest, userName); | |
| PathAppendW(szDest, szTemp + lstrlenW(L"%USERPROFILE%")); | |
| } | |
| else if (!wcsnicmp(szTemp, L"%SystemDrive%", lstrlenW(L"%SystemDrive%"))) | |
| { | |
| GetSystemDirectoryW(szDest, MAX_PATH); | |
| lstrcpyW(szDest + 3, szTemp + lstrlenW(L"%SystemDrive%") + 1); | |
| } | |
| else | |
| { | |
| DWORD ret = ExpandEnvironmentStringsW(szTemp, szDest, MAX_PATH); | |
| if (ret > MAX_PATH) | |
| hr = E_NOT_SUFFICIENT_BUFFER; | |
| else if (ret == 0) | |
| hr = HRESULT_FROM_WIN32(GetLastError()); | |
| else if (!wcscmp( szTemp, szDest )) break; /* nothing expanded */ | |
| } | |
| if (SUCCEEDED(hr)) lstrcpyW(szTemp, szDest); | |
| } | |
| end: | |
| if (key) | |
| RegCloseKey(key); | |
| TRACE("returning 0x%08lx (input was %s, output is %s)\n", hr, | |
| debugstr_w(szSrc), debugstr_w(szDest)); | |
| return hr; | |
| } | |
| static char *xdg_config; | |
| static DWORD xdg_config_len; | |
| static BOOL WINAPI init_xdg_dirs( INIT_ONCE *once, void *param, void **context ) | |
| { | |
| const WCHAR *var, *fmt = L"\\??\\unix%s/user-dirs.dirs"; | |
| char *p; | |
| WCHAR *name, *ptr; | |
| HANDLE file; | |
| DWORD len; | |
| if (!(var = _wgetenv( L"WINE_HOST_XDG_CONFIG_HOME" )) || var[0] != '/') | |
| { | |
| if (!(var = _wgetenv( L"WINEHOMEDIR" ))) return TRUE; | |
| fmt = L"%s/.config/user-dirs.dirs"; | |
| } | |
| len = lstrlenW(var) + lstrlenW(fmt); | |
| name = malloc( len * sizeof(WCHAR) ); | |
| swprintf( name, len, fmt, var ); | |
| name[1] = '\\'; /* change \??\ to \\?\ */ | |
| for (ptr = name; *ptr; ptr++) if (*ptr == '/') *ptr = '\\'; | |
| file = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 ); | |
| free( name ); | |
| if (file != INVALID_HANDLE_VALUE) | |
| { | |
| len = GetFileSize( file, NULL ); | |
| if (!(xdg_config = malloc( len + 1 ))) return TRUE; | |
| if (!ReadFile( file, xdg_config, len, &xdg_config_len, NULL )) | |
| { | |
| free( xdg_config ); | |
| xdg_config = NULL; | |
| } | |
| else | |
| { | |
| for (p = xdg_config; p < xdg_config + xdg_config_len; p++) if (*p == '\n') *p = 0; | |
| *p = 0; /* append null to simplify string parsing */ | |
| } | |
| CloseHandle( file ); | |
| } | |
| return TRUE; | |
| } | |
| static char *get_xdg_path( const char *var ) | |
| { | |
| static INIT_ONCE once; | |
| char *p, *ret = NULL; | |
| int i; | |
| InitOnceExecuteOnce( &once, init_xdg_dirs, NULL, NULL ); | |
| if (!xdg_config) return NULL; | |
| for (p = xdg_config; p < xdg_config + xdg_config_len; p += strlen(p) + 1) | |
| { | |
| while (*p == ' ' || *p == '\t') p++; | |
| if (strncmp( p, var, strlen(var) )) continue; | |
| p += strlen(var); | |
| while (*p == ' ' || *p == '\t') p++; | |
| if (*p != '=') continue; | |
| p++; | |
| while (*p == ' ' || *p == '\t') p++; | |
| if (*p != '"') continue; | |
| p++; | |
| if (*p != '/' && strncmp( p, "$HOME/", 6 )) continue; | |
| if (!(ret = malloc( strlen(p) + 1 ))) break; | |
| for (i = 0; *p && *p != '"'; i++, p++) | |
| { | |
| if (*p == '\\' && p[1]) p++; | |
| ret[i] = *p; | |
| } | |
| ret[i] = 0; | |
| if (*p != '"') | |
| { | |
| free( ret ); | |
| ret = NULL; | |
| } | |
| break; | |
| } | |
| return ret; | |
| } | |
| static BOOL link_folder( HANDLE mgr, const UNICODE_STRING *path, const char *link ) | |
| { | |
| struct mountmgr_shell_folder *ioctl; | |
| DWORD len = sizeof(*ioctl) + path->Length + strlen(link) + 1; | |
| BOOL ret; | |
| if (!(ioctl = malloc( len ))) return FALSE; | |
| ioctl->create_backup = FALSE; | |
| ioctl->folder_offset = sizeof(*ioctl); | |
| ioctl->folder_size = path->Length; | |
| memcpy( (char *)ioctl + ioctl->folder_offset, path->Buffer, ioctl->folder_size ); | |
| ioctl->symlink_offset = ioctl->folder_offset + ioctl->folder_size; | |
| strcpy( (char *)ioctl + ioctl->symlink_offset, link ); | |
| ret = DeviceIoControl( mgr, IOCTL_MOUNTMGR_DEFINE_SHELL_FOLDER, ioctl, len, NULL, 0, NULL, NULL ); | |
| free( ioctl ); | |
| return ret; | |
| } | |
| /****************************************************************************** | |
| * create_link | |
| * | |
| * Sets up a symbolic link for one of the 'My Whatever' shell folders to point | |
| * into the corresponding XDG directory. | |
| */ | |
| static void create_link( const WCHAR *path, const char *xdg_name, const char *default_name ) | |
| { | |
| UNICODE_STRING nt_name; | |
| char *target = NULL; | |
| HANDLE mgr; | |
| if ((mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ | GENERIC_WRITE, | |
| FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, | |
| 0, 0 )) == INVALID_HANDLE_VALUE) | |
| { | |
| FIXME( "failed to connect to mount manager\n" ); | |
| return; | |
| } | |
| nt_name.Buffer = NULL; | |
| if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL )) goto done; | |
| if ((target = get_xdg_path( xdg_name ))) | |
| { | |
| if (link_folder( mgr, &nt_name, target )) goto done; | |
| } | |
| link_folder( mgr, &nt_name, default_name ); | |
| done: | |
| RtlFreeUnicodeString( &nt_name ); | |
| free( target ); | |
| CloseHandle( mgr ); | |
| } | |
| /****************************************************************************** | |
| * _SHCreateSymbolicLink [Internal] | |
| * | |
| * Sets up a symbolic link for one of the special shell folders to point into | |
| * the users home directory. | |
| * | |
| * PARAMS | |
| * nFolder [I] CSIDL identifying the folder. | |
| */ | |
| static void _SHCreateSymbolicLink(int nFolder, const WCHAR *path) | |
| { | |
| DWORD folder = nFolder & CSIDL_FOLDER_MASK; | |
| switch (folder) { | |
| case CSIDL_PERSONAL: | |
| create_link( path, "XDG_DOCUMENTS_DIR", "$HOME/Documents" ); | |
| break; | |
| case CSIDL_DESKTOPDIRECTORY: | |
| create_link( path, "XDG_DESKTOP_DIR", "$HOME/Desktop" ); | |
| break; | |
| case CSIDL_MYPICTURES: | |
| create_link( path, "XDG_PICTURES_DIR", "$HOME/Pictures" ); | |
| break; | |
| case CSIDL_MYVIDEO: | |
| create_link( path, "XDG_VIDEOS_DIR", "$HOME/Movies" ); | |
| break; | |
| case CSIDL_MYMUSIC: | |
| create_link( path, "XDG_MUSIC_DIR", "$HOME/Music" ); | |
| break; | |
| case CSIDL_DOWNLOADS: | |
| create_link( path, "XDG_DOWNLOAD_DIR", "$HOME/Downloads" ); | |
| break; | |
| case CSIDL_TEMPLATES: | |
| create_link( path, "XDG_TEMPLATES_DIR", "$HOME/Templates" ); | |
| break; | |
| } | |
| } | |
| /****************************************************************************** | |
| * SHGetFolderPathW [SHELL32.@] | |
| * | |
| * Convert nFolder to path. | |
| * | |
| * RETURNS | |
| * Success: S_OK | |
| * Failure: standard HRESULT error codes. | |
| * | |
| * NOTES | |
| * Most values can be overridden in either | |
| * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders | |
| * or in the same location in HKLM. | |
| * The "Shell Folders" registry key was used in NT4 and earlier systems. | |
| * Beginning with Windows 2000, the "User Shell Folders" key is used, so | |
| * changes made to it are made to the former key too. This synchronization is | |
| * done on-demand: not until someone requests the value of one of these paths | |
| * (by calling one of the SHGet functions) is the value synchronized. | |
| * Furthermore, the HKCU paths take precedence over the HKLM paths. | |
| */ | |
| HRESULT WINAPI SHGetFolderPathW( | |
| HWND hwndOwner, /* [I] owner window */ | |
| int nFolder, /* [I] CSIDL identifying the folder */ | |
| HANDLE hToken, /* [I] access token */ | |
| DWORD dwFlags, /* [I] which path to return */ | |
| LPWSTR pszPath) /* [O] converted path */ | |
| { | |
| 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; | |
| } | |
| HRESULT WINAPI SHGetFolderPathAndSubDirA( | |
| HWND hwndOwner, /* [I] owner window */ | |
| int nFolder, /* [I] CSIDL identifying the folder */ | |
| HANDLE hToken, /* [I] access token */ | |
| DWORD dwFlags, /* [I] which path to return */ | |
| LPCSTR pszSubPath, /* [I] sub directory of the specified folder */ | |
| LPSTR pszPath) /* [O] converted path */ | |
| { | |
| int length; | |
| HRESULT hr = S_OK; | |
| LPWSTR pszSubPathW = NULL; | |
| LPWSTR pszPathW = NULL; | |
| TRACE("%p,%#x,%p,%#lx,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_a(pszSubPath), pszPath); | |
| if(pszPath) { | |
| pszPathW = malloc(MAX_PATH * sizeof(WCHAR)); | |
| if(!pszPathW) { | |
| hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY); | |
| goto cleanup; | |
| } | |
| } | |
| TRACE("%08x,%08lx,%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 = malloc(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: | |
| free(pszPathW); | |
| free(pszSubPathW); | |
| return hr; | |
| } | |
| /************************************************************************* | |
| * SHGetFolderPathAndSubDirW [SHELL32.@] | |
| */ | |
| HRESULT WINAPI SHGetFolderPathAndSubDirW( | |
| HWND hwndOwner, /* [I] owner window */ | |
| int nFolder, /* [I] CSIDL identifying the folder */ | |
| HANDLE hToken, /* [I] access token */ | |
| DWORD dwFlags, /* [I] which path to return */ | |
| LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */ | |
| LPWSTR pszPath) /* [O] converted path */ | |
| { | |
| HRESULT hr; | |
| WCHAR szBuildPath[MAX_PATH], szTemp[MAX_PATH]; | |
| DWORD folder = nFolder & CSIDL_FOLDER_MASK; | |
| CSIDL_Type type; | |
| int ret; | |
| TRACE("%p,%#x,%p,%#lx,%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); | |
| append_relative_path(folder, szTemp); | |
| hr = S_OK; | |
| break; | |
| case CSIDL_Type_SystemPath: | |
| GetSystemDirectoryW(szTemp, MAX_PATH); | |
| append_relative_path(folder, szTemp); | |
| hr = S_OK; | |
| break; | |
| case CSIDL_Type_SystemX86Path: | |
| if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH); | |
| append_relative_path(folder, szTemp); | |
| 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: | |
| case CSIDL_Type_ProgramData: | |
| 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 == '%') | |
| hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath); | |
| else | |
| lstrcpyW(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) | |
| lstrcpyW(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 symbolic links rather than directories for specific | |
| * user shell folders */ | |
| if (!pszSubPath) | |
| _SHCreateSymbolicLink(folder, szBuildPath); | |
| /* 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: | |
| TRACE("returning 0x%08lx (final path is %s)\n", hr, debugstr_w(szBuildPath)); | |
| return hr; | |
| } | |
| /************************************************************************* | |
| * SHGetFolderPathA [SHELL32.@] | |
| * | |
| * See SHGetFolderPathW. | |
| */ | |
| HRESULT WINAPI SHGetFolderPathA( | |
| HWND hwndOwner, | |
| int nFolder, | |
| HANDLE hToken, | |
| DWORD dwFlags, | |
| LPSTR pszPath) | |
| { | |
| WCHAR szTemp[MAX_PATH]; | |
| HRESULT hr; | |
| TRACE("%p,%d,%p,%#lx,%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; | |
| } | |
| /* For each folder in folders, if its value has not been set in the registry, | |
| * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the | |
| * folder's type) to get the unexpanded value first. | |
| * Writes the unexpanded value to User Shell Folders, and queries it with | |
| * SHGetFolderPathW to force the creation of the directory if it doesn't | |
| * already exist. SHGetFolderPathW also returns the expanded value, which | |
| * this then writes to Shell Folders. | |
| */ | |
| static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken, | |
| LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[], | |
| UINT foldersLen) | |
| { | |
| 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]].value; | |
| 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)) | |
| { | |
| *path = '\0'; | |
| if (CSIDL_Data[folders[i]].type == CSIDL_Type_User) | |
| _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i], | |
| path); | |
| else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers || | |
| CSIDL_Data[folders[i]].type == CSIDL_Type_ProgramData) | |
| _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path); | |
| else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath) | |
| { | |
| GetWindowsDirectoryW(path, MAX_PATH); | |
| append_relative_path(folders[i], path); | |
| } | |
| else | |
| hr = E_FAIL; | |
| if (*path) | |
| { | |
| ret = RegSetValueExW(hUserKey, szValueName, 0, REG_EXPAND_SZ, | |
| (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR)); | |
| if (ret) | |
| hr = HRESULT_FROM_WIN32(ret); | |
| else | |
| { | |
| hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE, | |
| hToken, SHGFP_TYPE_DEFAULT, path); | |
| ret = RegSetValueExW(hKey, szValueName, 0, REG_SZ, | |
| (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR)); | |
| if (ret) | |
| hr = HRESULT_FROM_WIN32(ret); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| /* create the default dir, which may be different from the path | |
| * stored in the registry. */ | |
| SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE, | |
| hToken, SHGFP_TYPE_DEFAULT, path); | |
| } | |
| } | |
| if (hUserKey) | |
| RegCloseKey(hUserKey); | |
| if (hKey) | |
| RegCloseKey(hKey); | |
| TRACE("returning 0x%08lx\n", hr); | |
| return hr; | |
| } | |
| static HRESULT _SHRegisterUserShellFolders(BOOL bDefault) | |
| { | |
| 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, | |
| CSIDL_CONTACTS, | |
| CSIDL_DOWNLOADS, | |
| CSIDL_LINKS, | |
| CSIDL_APPDATA_LOCALLOW, | |
| CSIDL_SAVED_GAMES, | |
| CSIDL_SEARCHES | |
| }; | |
| 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; | |
| lstrcpyW(userShellFolderPath, L".Default"); | |
| PathAddBackslashW(userShellFolderPath); | |
| lstrcatW(userShellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"); | |
| pUserShellFolderPath = userShellFolderPath; | |
| lstrcpyW(shellFolderPath, L".Default"); | |
| PathAddBackslashW(shellFolderPath); | |
| lstrcatW(shellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"); | |
| pShellFolderPath = shellFolderPath; | |
| } | |
| else | |
| { | |
| hToken = NULL; | |
| hRootKey = HKEY_CURRENT_USER; | |
| pUserShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"; | |
| pShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"; | |
| } | |
| hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath, | |
| pShellFolderPath, folders, ARRAY_SIZE(folders)); | |
| TRACE("returning 0x%08lx\n", hr); | |
| return hr; | |
| } | |
| static HRESULT _SHRegisterCommonShellFolders(void) | |
| { | |
| 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, | |
| L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", | |
| L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", | |
| folders, ARRAY_SIZE(folders)); | |
| TRACE("returning 0x%08lx\n", hr); | |
| return hr; | |
| } | |
| /****************************************************************************** | |
| * create_extra_folders [Internal] | |
| * | |
| * Create some extra folders that don't have a standard CSIDL definition. | |
| */ | |
| static HRESULT create_extra_folders(void) | |
| { | |
| WCHAR path[MAX_PATH+5]; | |
| HRESULT hr; | |
| HKEY hkey; | |
| DWORD type, size, ret; | |
| ret = RegCreateKeyW( HKEY_CURRENT_USER, L"Environment", &hkey ); | |
| if (ret) return HRESULT_FROM_WIN32( ret ); | |
| hr = SHGetFolderPathAndSubDirW( 0, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, | |
| SHGFP_TYPE_DEFAULT, L"Temp", path ); | |
| if (SUCCEEDED(hr)) | |
| { | |
| size = sizeof(path); | |
| if (RegQueryValueExW( hkey, L"TEMP", NULL, &type, (LPBYTE)path, &size )) | |
| RegSetValueExW( hkey, L"TEMP", 0, REG_SZ, (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR) ); | |
| size = sizeof(path); | |
| if (RegQueryValueExW( hkey, L"TMP", NULL, &type, (LPBYTE)path, &size )) | |
| RegSetValueExW( hkey, L"TMP", 0, REG_SZ, (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR) ); | |
| } | |
| RegCloseKey( hkey ); | |
| if (SUCCEEDED(hr)) | |
| { | |
| hr = SHGetFolderPathAndSubDirW( 0, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL, | |
| SHGFP_TYPE_DEFAULT, L"Microsoft", path ); | |
| } | |
| if (SUCCEEDED(hr)) | |
| { | |
| hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, | |
| SHGFP_TYPE_DEFAULT, L"Microsoft\\Windows\\Themes", path); | |
| } | |
| if (SUCCEEDED(hr)) | |
| { | |
| hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, | |
| SHGFP_TYPE_DEFAULT, L"Microsoft\\Windows\\AccountPictures", path); | |
| } | |
| if (SUCCEEDED(hr)) | |
| { | |
| hr = SHGetFolderPathAndSubDirW(0, CSIDL_MYPICTURES | CSIDL_FLAG_CREATE, NULL, | |
| SHGFP_TYPE_DEFAULT, L"Screenshots", path); | |
| } | |
| return hr; | |
| } | |
| /****************************************************************************** | |
| * set_folder_attributes | |
| * | |
| * Set the various folder attributes registry keys. | |
| */ | |
| static HRESULT set_folder_attributes(void) | |
| { | |
| static const struct | |
| { | |
| const CLSID *clsid; | |
| unsigned int wfparsing : 1; | |
| unsigned int wfdisplay : 1; | |
| unsigned int hideasdel : 1; | |
| DWORD attr; | |
| DWORD call_for_attr; | |
| } folders[] = | |
| { | |
| { &CLSID_UnixFolder, TRUE, FALSE, FALSE }, | |
| { &CLSID_UnixDosFolder, TRUE, FALSE, FALSE, | |
| SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM }, | |
| { &CLSID_FolderShortcut, FALSE, FALSE, FALSE, | |
| SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_LINK, | |
| SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR }, | |
| { &CLSID_MyDocuments, TRUE, FALSE, FALSE, | |
| SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM }, | |
| { &CLSID_RecycleBin, FALSE, FALSE, FALSE, | |
| SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET }, | |
| { &CLSID_ControlPanel, FALSE, TRUE, TRUE, | |
| SFGAO_FOLDER|SFGAO_HASSUBFOLDER }, | |
| { &CLSID_Printers, FALSE, FALSE, FALSE, | |
| SFGAO_FOLDER|SFGAO_CANLINK } | |
| }; | |
| unsigned int i; | |
| WCHAR buffer[39 + ARRAY_SIZE(L"CLSID\\") + ARRAY_SIZE(L"\\ShellFolder")]; | |
| LONG res; | |
| HKEY hkey; | |
| for (i = 0; i < ARRAY_SIZE(folders); i++) | |
| { | |
| lstrcpyW( buffer, L"CLSID\\" ); | |
| StringFromGUID2( folders[i].clsid, buffer + lstrlenW(buffer), 39 ); | |
| lstrcatW( buffer, L"\\ShellFolder" ); | |
| res = RegCreateKeyExW( HKEY_CLASSES_ROOT, buffer, 0, NULL, 0, | |
| KEY_READ | KEY_WRITE, NULL, &hkey, NULL); | |
| if (res) return HRESULT_FROM_WIN32( res ); | |
| if (folders[i].wfparsing) | |
| res = RegSetValueExW( hkey, L"WantsFORPARSING", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) ); | |
| if (folders[i].wfdisplay) | |
| res = RegSetValueExW( hkey, L"WantsFORDISPLAY", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) ); | |
| if (folders[i].hideasdel) | |
| res = RegSetValueExW( hkey, L"HideAsDeletePerUser", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) ); | |
| if (folders[i].attr) | |
| res = RegSetValueExW( hkey, L"Attributes", 0, REG_DWORD, | |
| (const BYTE *)&folders[i].attr, sizeof(DWORD)); | |
| if (folders[i].call_for_attr) | |
| res = RegSetValueExW( hkey, L"CallForAttributes", 0, REG_DWORD, | |
| (const BYTE *)&folders[i].call_for_attr, sizeof(DWORD)); | |
| RegCloseKey( hkey ); | |
| } | |
| return S_OK; | |
| } | |
| /************************************************************************* | |
| * SHGetSpecialFolderPathA [SHELL32.@] | |
| */ | |
| BOOL WINAPI SHGetSpecialFolderPathA ( | |
| HWND hwndOwner, | |
| LPSTR szPath, | |
| int nFolder, | |
| BOOL bCreate) | |
| { | |
| return SHGetFolderPathA(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0, | |
| szPath) == S_OK; | |
| } | |
| /************************************************************************* | |
| * SHGetSpecialFolderPathW | |
| */ | |
| BOOL WINAPI SHGetSpecialFolderPathW ( | |
| HWND hwndOwner, | |
| LPWSTR szPath, | |
| int nFolder, | |
| BOOL bCreate) | |
| { | |
| return SHGetFolderPathW(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0, | |
| szPath) == S_OK; | |
| } | |
| /************************************************************************* | |
| * SHGetSpecialFolderPath (SHELL32.175) | |
| */ | |
| BOOL WINAPI SHGetSpecialFolderPathAW ( | |
| HWND hwndOwner, | |
| LPVOID szPath, | |
| int nFolder, | |
| BOOL bCreate) | |
| { | |
| if (SHELL_OsIsUnicode()) | |
| return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate); | |
| return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate); | |
| } | |
| /************************************************************************* | |
| * SHGetFolderLocation [SHELL32.@] | |
| * | |
| * Gets the folder locations from the registry and creates a pidl. | |
| * | |
| * PARAMS | |
| * hwndOwner [I] | |
| * nFolder [I] CSIDL_xxxxx | |
| * hToken [I] token representing user, or NULL for current user, or -1 for | |
| * default user | |
| * dwReserved [I] must be zero | |
| * ppidl [O] PIDL of a special folder | |
| * | |
| * RETURNS | |
| * Success: S_OK | |
| * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG | |
| * | |
| * NOTES | |
| * Creates missing reg keys and directories. | |
| * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return | |
| * virtual folders that are handled here. | |
| */ | |
| HRESULT WINAPI SHGetFolderLocation( | |
| HWND hwndOwner, | |
| int nFolder, | |
| HANDLE hToken, | |
| DWORD dwReserved, | |
| LPITEMIDLIST *ppidl) | |
| { | |
| HRESULT hr = E_INVALIDARG; | |
| TRACE("%p 0x%08x %p 0x%08lx %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; | |
| } | |
| /************************************************************************* | |
| * SHGetSpecialFolderLocation [SHELL32.@] | |
| * | |
| * NOTES | |
| * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent | |
| * directory. | |
| */ | |
| HRESULT WINAPI SHGetSpecialFolderLocation( | |
| HWND hwndOwner, | |
| INT nFolder, | |
| LPITEMIDLIST * ppidl) | |
| { | |
| 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; | |
| } | |
| /************************************************************************* | |
| * SHGetKnownFolderPath [SHELL32.@] | |
| */ | |
| HRESULT WINAPI SHGetKnownFolderPath(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, WCHAR **ret_path) | |
| { | |
| WCHAR pathW[MAX_PATH]; | |
| HRESULT hr; | |
| int folder = csidl_from_id(rfid), shgfp_flags; | |
| TRACE("%s, 0x%08lx, %p, %p\n", debugstr_guid(rfid), flags, token, ret_path); | |
| *ret_path = NULL; | |
| if (folder < 0) | |
| return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ); | |
| if (flags & ~(KF_FLAG_CREATE|KF_FLAG_SIMPLE_IDLIST|KF_FLAG_DONT_UNEXPAND| | |
| KF_FLAG_DONT_VERIFY|KF_FLAG_NO_ALIAS|KF_FLAG_INIT|KF_FLAG_DEFAULT_PATH|KF_FLAG_NOT_PARENT_RELATIVE)) | |
| { | |
| FIXME("flags 0x%08lx not supported\n", flags); | |
| return E_INVALIDARG; | |
| } | |
| if ((flags & (KF_FLAG_DEFAULT_PATH | KF_FLAG_NOT_PARENT_RELATIVE)) == KF_FLAG_NOT_PARENT_RELATIVE) | |
| { | |
| WARN("Invalid flags mask %#lx.\n", flags); | |
| return E_INVALIDARG; | |
| } | |
| if (flags & KF_FLAG_NOT_PARENT_RELATIVE) | |
| { | |
| FIXME("Ignoring KF_FLAG_NOT_PARENT_RELATIVE.\n"); | |
| flags &= ~KF_FLAG_NOT_PARENT_RELATIVE; | |
| } | |
| folder |= flags & CSIDL_FLAG_MASK; | |
| shgfp_flags = flags & KF_FLAG_DEFAULT_PATH ? SHGFP_TYPE_DEFAULT : SHGFP_TYPE_CURRENT; | |
| hr = SHGetFolderPathAndSubDirW( 0, folder, token, shgfp_flags, NULL, pathW ); | |
| if (FAILED( hr )) | |
| { | |
| TRACE("Failed to get folder path, %#lx.\n", hr); | |
| return hr; | |
| } | |
| TRACE("Final path is %s, %#lx\n", debugstr_w(pathW), hr); | |
| *ret_path = CoTaskMemAlloc((lstrlenW(pathW) + 1) * sizeof(WCHAR)); | |
| if (!*ret_path) | |
| return E_OUTOFMEMORY; | |
| lstrcpyW(*ret_path, pathW); | |
| return hr; | |
| } | |
| /************************************************************************* | |
| * SHGetFolderPathEx [SHELL32.@] | |
| */ | |
| HRESULT WINAPI SHGetFolderPathEx(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, LPWSTR path, DWORD len) | |
| { | |
| HRESULT hr; | |
| WCHAR *buffer; | |
| TRACE("%s, 0x%08lx, %p, %p, %lu\n", debugstr_guid(rfid), flags, token, path, len); | |
| if (!path || !len) return E_INVALIDARG; | |
| hr = SHGetKnownFolderPath( rfid, flags, token, &buffer ); | |
| if (SUCCEEDED( hr )) | |
| { | |
| if (lstrlenW( buffer ) + 1 > len) | |
| { | |
| CoTaskMemFree( buffer ); | |
| return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER ); | |
| } | |
| lstrcpyW( path, buffer ); | |
| CoTaskMemFree( buffer ); | |
| } | |
| return hr; | |
| } | |
| /* | |
| * Internal function to convert known folder identifier to path of registry key | |
| * associated with known folder. | |
| * | |
| * Parameters: | |
| * rfid [I] pointer to known folder identifier (may be NULL) | |
| * lpStringGuid [I] string with known folder identifier (used when rfid is NULL) | |
| * lpPath [O] place to store string address. String should be | |
| * later freed using HeapFree(GetProcessHeap(),0, ... ) | |
| */ | |
| static HRESULT get_known_folder_registry_path( | |
| REFKNOWNFOLDERID rfid, | |
| LPWSTR lpStringGuid, | |
| LPWSTR *lpPath) | |
| { | |
| HRESULT hr = S_OK; | |
| int length; | |
| WCHAR sGuid[50]; | |
| TRACE("(%s, %s, %p)\n", debugstr_guid(rfid), debugstr_w(lpStringGuid), lpPath); | |
| if(rfid) | |
| StringFromGUID2(rfid, sGuid, ARRAY_SIZE(sGuid)); | |
| else | |
| lstrcpyW(sGuid, lpStringGuid); | |
| length = lstrlenW(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions")+51; | |
| *lpPath = malloc(length * sizeof(WCHAR)); | |
| if(!(*lpPath)) | |
| hr = E_OUTOFMEMORY; | |
| if(SUCCEEDED(hr)) | |
| { | |
| lstrcpyW(*lpPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions\\"); | |
| lstrcatW(*lpPath, sGuid); | |
| } | |
| return hr; | |
| } | |
| static HRESULT get_known_folder_wstr(const WCHAR *regpath, const WCHAR *value, WCHAR **out) | |
| { | |
| DWORD size = 0; | |
| HRESULT hr; | |
| size = 0; | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, regpath, value, RRF_RT_REG_SZ, NULL, NULL, &size)); | |
| if(FAILED(hr)) | |
| return hr; | |
| *out = CoTaskMemAlloc(size); | |
| if(!*out) | |
| return E_OUTOFMEMORY; | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, regpath, value, RRF_RT_REG_SZ, NULL, *out, &size)); | |
| if(FAILED(hr)){ | |
| CoTaskMemFree(*out); | |
| *out = NULL; | |
| } | |
| return hr; | |
| } | |
| static HRESULT get_known_folder_dword(const WCHAR *registryPath, const WCHAR *value, DWORD *out) | |
| { | |
| DWORD dwSize = sizeof(DWORD); | |
| DWORD dwType; | |
| return HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, value, RRF_RT_DWORD, &dwType, out, &dwSize)); | |
| } | |
| /* | |
| * Internal function to get place where folder redirection information are stored. | |
| * | |
| * Parameters: | |
| * rfid [I] pointer to known folder identifier (may be NULL) | |
| * rootKey [O] root key where the redirection information are stored | |
| * It can be HKLM for COMMON folders, and HKCU for PERUSER folders. | |
| */ | |
| static HRESULT get_known_folder_redirection_place( | |
| REFKNOWNFOLDERID rfid, | |
| HKEY *rootKey) | |
| { | |
| HRESULT hr; | |
| LPWSTR lpRegistryPath = NULL; | |
| DWORD category; | |
| /* first, get known folder's category */ | |
| hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath); | |
| if(SUCCEEDED(hr)) | |
| hr = get_known_folder_dword(lpRegistryPath, L"Category", &category); | |
| if(SUCCEEDED(hr)) | |
| { | |
| if(category == KF_CATEGORY_COMMON) | |
| { | |
| *rootKey = HKEY_LOCAL_MACHINE; | |
| hr = S_OK; | |
| } | |
| else if(category == KF_CATEGORY_PERUSER) | |
| { | |
| *rootKey = HKEY_CURRENT_USER; | |
| hr = S_OK; | |
| } | |
| else | |
| hr = E_FAIL; | |
| } | |
| free(lpRegistryPath); | |
| return hr; | |
| } | |
| static HRESULT get_known_folder_path_by_id(REFKNOWNFOLDERID folderId, LPWSTR lpRegistryPath, DWORD dwFlags, LPWSTR *ppszPath); | |
| static HRESULT redirect_known_folder( | |
| REFKNOWNFOLDERID rfid, | |
| HWND hwnd, | |
| KF_REDIRECT_FLAGS flags, | |
| LPCWSTR pszTargetPath, | |
| UINT cFolders, | |
| KNOWNFOLDERID const *pExclusion, | |
| LPWSTR *ppszError) | |
| { | |
| HRESULT hr; | |
| HKEY rootKey = HKEY_LOCAL_MACHINE, hKey; | |
| WCHAR sGuid[39]; | |
| LPWSTR lpRegistryPath = NULL, lpSrcPath = NULL; | |
| TRACE("(%s, %p, 0x%08x, %s, %d, %p, %p)\n", debugstr_guid(rfid), hwnd, flags, debugstr_w(pszTargetPath), cFolders, pExclusion, ppszError); | |
| if (ppszError) *ppszError = NULL; | |
| hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath); | |
| if(SUCCEEDED(hr)) | |
| hr = get_known_folder_path_by_id(rfid, lpRegistryPath, 0, &lpSrcPath); | |
| free(lpRegistryPath); | |
| /* get path to redirection storage */ | |
| if(SUCCEEDED(hr)) | |
| hr = get_known_folder_redirection_place(rfid, &rootKey); | |
| /* write redirection information */ | |
| if(SUCCEEDED(hr)) | |
| hr = HRESULT_FROM_WIN32(RegCreateKeyExW(rootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| StringFromGUID2(rfid, sGuid, ARRAY_SIZE(sGuid)); | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, sGuid, 0, REG_SZ, (LPBYTE)pszTargetPath, (lstrlenW(pszTargetPath)+1)*sizeof(WCHAR))); | |
| RegCloseKey(hKey); | |
| } | |
| /* make sure destination path exists */ | |
| SHCreateDirectory(NULL, pszTargetPath); | |
| /* copy content if required */ | |
| if(SUCCEEDED(hr) && (flags & KF_REDIRECT_COPY_CONTENTS) ) | |
| { | |
| WCHAR srcPath[MAX_PATH+1], dstPath[MAX_PATH+1]; | |
| SHFILEOPSTRUCTW fileOp; | |
| ZeroMemory(srcPath, sizeof(srcPath)); | |
| lstrcpyW(srcPath, lpSrcPath); | |
| lstrcatW(srcPath, L"\\*"); | |
| ZeroMemory(dstPath, sizeof(dstPath)); | |
| lstrcpyW(dstPath, pszTargetPath); | |
| ZeroMemory(&fileOp, sizeof(fileOp)); | |
| if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS) | |
| fileOp.wFunc = FO_MOVE; | |
| else | |
| fileOp.wFunc = FO_COPY; | |
| fileOp.pFrom = srcPath; | |
| fileOp.pTo = dstPath; | |
| fileOp.fFlags = FOF_NO_UI; | |
| hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL); | |
| if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS) | |
| { | |
| ZeroMemory(srcPath, sizeof(srcPath)); | |
| lstrcpyW(srcPath, lpSrcPath); | |
| ZeroMemory(&fileOp, sizeof(fileOp)); | |
| fileOp.wFunc = FO_DELETE; | |
| fileOp.pFrom = srcPath; | |
| fileOp.fFlags = FOF_NO_UI; | |
| hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL); | |
| } | |
| } | |
| CoTaskMemFree(lpSrcPath); | |
| return hr; | |
| } | |
| struct knownfolder | |
| { | |
| IKnownFolder IKnownFolder_iface; | |
| LONG refs; | |
| KNOWNFOLDERID id; | |
| LPWSTR registryPath; | |
| }; | |
| static inline struct knownfolder *impl_from_IKnownFolder( IKnownFolder *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct knownfolder, IKnownFolder_iface ); | |
| } | |
| static ULONG WINAPI knownfolder_AddRef( | |
| IKnownFolder *iface ) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| return InterlockedIncrement( &knownfolder->refs ); | |
| } | |
| static ULONG WINAPI knownfolder_Release( | |
| IKnownFolder *iface ) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| LONG refs = InterlockedDecrement( &knownfolder->refs ); | |
| if (!refs) | |
| { | |
| TRACE("destroying %p\n", knownfolder); | |
| free( knownfolder->registryPath ); | |
| free( knownfolder ); | |
| } | |
| return refs; | |
| } | |
| static HRESULT WINAPI knownfolder_QueryInterface( | |
| IKnownFolder *iface, | |
| REFIID riid, | |
| void **ppv ) | |
| { | |
| struct knownfolder *This = impl_from_IKnownFolder( iface ); | |
| TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv ); | |
| *ppv = NULL; | |
| if ( IsEqualGUID( riid, &IID_IKnownFolder ) || | |
| IsEqualGUID( riid, &IID_IUnknown ) ) | |
| { | |
| *ppv = iface; | |
| } | |
| else if ( IsEqualGUID( riid, &IID_IMarshal ) ) | |
| { | |
| TRACE("IID_IMarshal returning NULL.\n"); | |
| return E_NOINTERFACE; | |
| } | |
| else | |
| { | |
| FIXME("interface %s not implemented\n", debugstr_guid(riid)); | |
| return E_NOINTERFACE; | |
| } | |
| IKnownFolder_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static HRESULT knownfolder_set_id( | |
| struct knownfolder *knownfolder, | |
| const KNOWNFOLDERID *kfid) | |
| { | |
| HKEY hKey; | |
| HRESULT hr; | |
| TRACE("%s\n", debugstr_guid(kfid)); | |
| knownfolder->id = *kfid; | |
| /* check is it registry-registered folder */ | |
| hr = get_known_folder_registry_path(kfid, NULL, &knownfolder->registryPath); | |
| if(SUCCEEDED(hr)) | |
| hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, 0, KEY_ENUMERATE_SUB_KEYS, &hKey)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = S_OK; | |
| RegCloseKey(hKey); | |
| } | |
| else | |
| { | |
| /* This known folder is not registered. To mark it, we set registryPath to NULL */ | |
| free(knownfolder->registryPath); | |
| knownfolder->registryPath = NULL; | |
| hr = S_OK; | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI knownfolder_GetId( | |
| IKnownFolder *iface, | |
| KNOWNFOLDERID *pkfid) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| TRACE("%p\n", pkfid); | |
| *pkfid = knownfolder->id; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI knownfolder_GetCategory( | |
| IKnownFolder *iface, | |
| KF_CATEGORY *pCategory) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder(iface); | |
| HRESULT hr = S_OK; | |
| TRACE("%p, %p\n", knownfolder, pCategory); | |
| /* we cannot get a category for a folder which is not registered */ | |
| if(!knownfolder->registryPath) | |
| hr = E_FAIL; | |
| if(SUCCEEDED(hr)) | |
| hr = get_known_folder_dword(knownfolder->registryPath, L"Category", (DWORD *)pCategory); | |
| return hr; | |
| } | |
| static HRESULT WINAPI knownfolder_GetShellItem( | |
| IKnownFolder *iface, | |
| DWORD flags, | |
| REFIID riid, | |
| void **ppv) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder(iface); | |
| TRACE("(%p, 0x%08lx, %s, %p)\n", knownfolder, flags, debugstr_guid(riid), ppv); | |
| return SHGetKnownFolderItem(&knownfolder->id, flags, NULL, riid, ppv); | |
| } | |
| static HRESULT get_known_folder_path( | |
| LPWSTR sFolderId, | |
| LPWSTR registryPath, | |
| LPWSTR *ppszPath) | |
| { | |
| HRESULT hr; | |
| DWORD dwSize, dwType; | |
| WCHAR path[MAX_PATH] = {0}; | |
| WCHAR parentGuid[39]; | |
| DWORD category; | |
| LPWSTR parentRegistryPath, parentPath; | |
| HKEY hRedirectionRootKey = NULL; | |
| TRACE("(%s, %p)\n", debugstr_w(registryPath), ppszPath); | |
| *ppszPath = NULL; | |
| /* check if folder has parent */ | |
| dwSize = sizeof(parentGuid); | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"ParentFolder", RRF_RT_REG_SZ, &dwType, parentGuid, &dwSize)); | |
| if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_FALSE; | |
| if(hr == S_OK) | |
| { | |
| /* get parent's known folder path (recursive) */ | |
| hr = get_known_folder_registry_path(NULL, parentGuid, &parentRegistryPath); | |
| if(FAILED(hr)) return hr; | |
| hr = get_known_folder_path(parentGuid, parentRegistryPath, &parentPath); | |
| if(FAILED(hr)) { | |
| free(parentRegistryPath); | |
| return hr; | |
| } | |
| lstrcatW(path, parentPath); | |
| lstrcatW(path, L"\\"); | |
| free(parentRegistryPath); | |
| free(parentPath); | |
| } | |
| /* check, if folder was redirected */ | |
| if(SUCCEEDED(hr)) | |
| hr = get_known_folder_dword(registryPath, L"Category", &category); | |
| if(SUCCEEDED(hr)) | |
| { | |
| if(category == KF_CATEGORY_COMMON) | |
| hRedirectionRootKey = HKEY_LOCAL_MACHINE; | |
| else if(category == KF_CATEGORY_PERUSER) | |
| hRedirectionRootKey = HKEY_CURRENT_USER; | |
| if(hRedirectionRootKey) | |
| { | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", sFolderId, RRF_RT_REG_SZ, NULL, NULL, &dwSize)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR)); | |
| if(!*ppszPath) hr = E_OUTOFMEMORY; | |
| } | |
| if(SUCCEEDED(hr)) | |
| { | |
| lstrcpyW(*ppszPath, path); | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", sFolderId, RRF_RT_REG_SZ, NULL, *ppszPath + lstrlenW(path), &dwSize)); | |
| } | |
| } | |
| if(!*ppszPath) | |
| { | |
| /* no redirection, use previous way - read the relative path from folder definition */ | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"RelativePath", RRF_RT_REG_SZ, &dwType, NULL, &dwSize)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR)); | |
| if(!*ppszPath) hr = E_OUTOFMEMORY; | |
| } | |
| if(SUCCEEDED(hr)) | |
| { | |
| lstrcpyW(*ppszPath, path); | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"RelativePath", RRF_RT_REG_SZ, &dwType, *ppszPath + lstrlenW(path), &dwSize)); | |
| } | |
| } | |
| } | |
| TRACE("returning path: %s\n", debugstr_w(*ppszPath)); | |
| return hr; | |
| } | |
| static HRESULT get_known_folder_path_by_id( | |
| REFKNOWNFOLDERID folderId, | |
| LPWSTR lpRegistryPath, | |
| DWORD dwFlags, | |
| LPWSTR *ppszPath) | |
| { | |
| HRESULT hr = E_FAIL; | |
| WCHAR sGuid[39]; | |
| DWORD dwAttributes; | |
| TRACE("(%s, %s, 0x%08lx, %p)\n", debugstr_guid(folderId), debugstr_w(lpRegistryPath), dwFlags, ppszPath); | |
| /* if this is registry-registered known folder, get path from registry */ | |
| if(lpRegistryPath) | |
| { | |
| StringFromGUID2(folderId, sGuid, ARRAY_SIZE(sGuid)); | |
| hr = get_known_folder_path(sGuid, lpRegistryPath, ppszPath); | |
| } | |
| /* in other case, use older way */ | |
| if(FAILED(hr)) | |
| hr = SHGetKnownFolderPath( folderId, dwFlags, NULL, ppszPath ); | |
| if (FAILED(hr)) return hr; | |
| /* check if known folder really exists */ | |
| dwAttributes = GetFileAttributesW(*ppszPath); | |
| if(dwAttributes == INVALID_FILE_ATTRIBUTES || !(dwAttributes & FILE_ATTRIBUTE_DIRECTORY) ) | |
| { | |
| TRACE("directory %s not found\n", debugstr_w(*ppszPath)); | |
| CoTaskMemFree(*ppszPath); | |
| *ppszPath = NULL; | |
| hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI knownfolder_GetPath( | |
| IKnownFolder *iface, | |
| DWORD dwFlags, | |
| LPWSTR *ppszPath) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| TRACE("(%p, 0x%08lx, %p)\n", knownfolder, dwFlags, ppszPath); | |
| return get_known_folder_path_by_id(&knownfolder->id, knownfolder->registryPath, dwFlags, ppszPath); | |
| } | |
| static HRESULT WINAPI knownfolder_SetPath( | |
| IKnownFolder *iface, | |
| DWORD dwFlags, | |
| LPCWSTR pszPath) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| HRESULT hr = S_OK; | |
| TRACE("(%p, 0x%08lx, %s)\n", knownfolder, dwFlags, debugstr_w(pszPath)); | |
| /* check if the known folder is registered */ | |
| if(!knownfolder->registryPath) | |
| hr = E_FAIL; | |
| if(SUCCEEDED(hr)) | |
| hr = redirect_known_folder(&knownfolder->id, NULL, 0, pszPath, 0, NULL, NULL); | |
| return hr; | |
| } | |
| static HRESULT WINAPI knownfolder_GetIDList( | |
| IKnownFolder *iface, | |
| DWORD flags, | |
| PIDLIST_ABSOLUTE *ppidl) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| TRACE("(%p, 0x%08lx, %p)\n", knownfolder, flags, ppidl); | |
| return SHGetKnownFolderIDList(&knownfolder->id, flags, NULL, ppidl); | |
| } | |
| static HRESULT WINAPI knownfolder_GetFolderType( | |
| IKnownFolder *iface, | |
| FOLDERTYPEID *pftid) | |
| { | |
| FIXME("%p\n", pftid); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI knownfolder_GetRedirectionCapabilities( | |
| IKnownFolder *iface, | |
| KF_REDIRECTION_CAPABILITIES *pCapabilities) | |
| { | |
| FIXME("%p stub\n", pCapabilities); | |
| if(!pCapabilities) return E_INVALIDARG; | |
| *pCapabilities = KF_REDIRECTION_CAPABILITIES_DENY_ALL; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI knownfolder_GetFolderDefinition( | |
| IKnownFolder *iface, | |
| KNOWNFOLDER_DEFINITION *pKFD) | |
| { | |
| struct knownfolder *knownfolder = impl_from_IKnownFolder( iface ); | |
| HRESULT hr; | |
| DWORD dwSize; | |
| WCHAR parentGuid[39]; | |
| TRACE("(%p, %p)\n", knownfolder, pKFD); | |
| if(!pKFD) return E_INVALIDARG; | |
| ZeroMemory(pKFD, sizeof(*pKFD)); | |
| /* required fields */ | |
| hr = get_known_folder_dword(knownfolder->registryPath, L"Category", (DWORD *)&pKFD->category); | |
| if(FAILED(hr)) | |
| return hr; | |
| hr = get_known_folder_wstr(knownfolder->registryPath, L"Name", &pKFD->pszName); | |
| if(FAILED(hr)) | |
| return hr; | |
| /* optional fields */ | |
| dwSize = sizeof(parentGuid); | |
| hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, L"ParentFolder", | |
| RRF_RT_REG_SZ, NULL, parentGuid, &dwSize)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = IIDFromString(parentGuid, &pKFD->fidParent); | |
| if(FAILED(hr)) | |
| return hr; | |
| } | |
| get_known_folder_dword(knownfolder->registryPath, L"Attributes", &pKFD->dwAttributes); | |
| get_known_folder_wstr(knownfolder->registryPath, L"RelativePath", &pKFD->pszRelativePath); | |
| get_known_folder_wstr(knownfolder->registryPath, L"ParsingName", &pKFD->pszParsingName); | |
| return S_OK; | |
| } | |
| static const struct IKnownFolderVtbl knownfolder_vtbl = | |
| { | |
| knownfolder_QueryInterface, | |
| knownfolder_AddRef, | |
| knownfolder_Release, | |
| knownfolder_GetId, | |
| knownfolder_GetCategory, | |
| knownfolder_GetShellItem, | |
| knownfolder_GetPath, | |
| knownfolder_SetPath, | |
| knownfolder_GetIDList, | |
| knownfolder_GetFolderType, | |
| knownfolder_GetRedirectionCapabilities, | |
| knownfolder_GetFolderDefinition | |
| }; | |
| static HRESULT knownfolder_create( struct knownfolder **knownfolder ) | |
| { | |
| struct knownfolder *kf; | |
| kf = malloc( sizeof(*kf) ); | |
| if (!kf) return E_OUTOFMEMORY; | |
| kf->IKnownFolder_iface.lpVtbl = &knownfolder_vtbl; | |
| kf->refs = 1; | |
| memset( &kf->id, 0, sizeof(kf->id) ); | |
| kf->registryPath = NULL; | |
| *knownfolder = kf; | |
| TRACE("returning iface %p\n", &kf->IKnownFolder_iface); | |
| return S_OK; | |
| } | |
| struct foldermanager | |
| { | |
| IKnownFolderManager IKnownFolderManager_iface; | |
| LONG refs; | |
| UINT num_ids; | |
| KNOWNFOLDERID *ids; | |
| }; | |
| static inline struct foldermanager *impl_from_IKnownFolderManager( IKnownFolderManager *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct foldermanager, IKnownFolderManager_iface ); | |
| } | |
| static ULONG WINAPI foldermanager_AddRef( | |
| IKnownFolderManager *iface ) | |
| { | |
| struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface ); | |
| return InterlockedIncrement( &foldermanager->refs ); | |
| } | |
| static ULONG WINAPI foldermanager_Release( | |
| IKnownFolderManager *iface ) | |
| { | |
| struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface ); | |
| LONG refs = InterlockedDecrement( &foldermanager->refs ); | |
| if (!refs) | |
| { | |
| TRACE("destroying %p\n", foldermanager); | |
| free( foldermanager->ids ); | |
| free( foldermanager ); | |
| } | |
| return refs; | |
| } | |
| static HRESULT WINAPI foldermanager_QueryInterface( | |
| IKnownFolderManager *iface, | |
| REFIID riid, | |
| void **ppv ) | |
| { | |
| struct foldermanager *This = impl_from_IKnownFolderManager( iface ); | |
| TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv ); | |
| *ppv = NULL; | |
| if ( IsEqualGUID( riid, &IID_IKnownFolderManager ) || | |
| IsEqualGUID( riid, &IID_IUnknown ) ) | |
| { | |
| *ppv = iface; | |
| } | |
| else if ( IsEqualGUID( riid, &IID_IMarshal ) ) | |
| { | |
| TRACE("IID_IMarshal returning NULL.\n"); | |
| return E_NOINTERFACE; | |
| } | |
| else | |
| { | |
| FIXME("interface %s not implemented\n", debugstr_guid(riid)); | |
| return E_NOINTERFACE; | |
| } | |
| IKnownFolderManager_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI foldermanager_FolderIdFromCsidl( | |
| IKnownFolderManager *iface, | |
| int nCsidl, | |
| KNOWNFOLDERID *pfid) | |
| { | |
| TRACE("%d, %p\n", nCsidl, pfid); | |
| if (nCsidl >= ARRAY_SIZE(CSIDL_Data)) | |
| return E_INVALIDARG; | |
| *pfid = *CSIDL_Data[nCsidl].id; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI foldermanager_FolderIdToCsidl( | |
| IKnownFolderManager *iface, | |
| REFKNOWNFOLDERID rfid, | |
| int *pnCsidl) | |
| { | |
| int csidl; | |
| TRACE("%s, %p\n", debugstr_guid(rfid), pnCsidl); | |
| csidl = csidl_from_id( rfid ); | |
| if (csidl == -1) return E_INVALIDARG; | |
| *pnCsidl = csidl; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI foldermanager_GetFolderIds( | |
| IKnownFolderManager *iface, | |
| KNOWNFOLDERID **ppKFId, | |
| UINT *pCount) | |
| { | |
| struct foldermanager *fm = impl_from_IKnownFolderManager( iface ); | |
| TRACE("%p, %p\n", ppKFId, pCount); | |
| *ppKFId = CoTaskMemAlloc(fm->num_ids * sizeof(KNOWNFOLDERID)); | |
| memcpy(*ppKFId, fm->ids, fm->num_ids * sizeof(KNOWNFOLDERID)); | |
| *pCount = fm->num_ids; | |
| return S_OK; | |
| } | |
| static BOOL is_knownfolder( struct foldermanager *fm, const KNOWNFOLDERID *id ) | |
| { | |
| UINT i; | |
| HRESULT hr; | |
| LPWSTR registryPath = NULL; | |
| HKEY hKey; | |
| /* TODO: move all entries from "CSIDL_Data" static array to registry known folder descriptions */ | |
| for (i = 0; i < fm->num_ids; i++) | |
| if (IsEqualGUID( &fm->ids[i], id )) return TRUE; | |
| hr = get_known_folder_registry_path(id, NULL, ®istryPath); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, KEY_ENUMERATE_SUB_KEYS, &hKey)); | |
| free(registryPath); | |
| } | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = S_OK; | |
| RegCloseKey(hKey); | |
| } | |
| return hr == S_OK; | |
| } | |
| static HRESULT WINAPI foldermanager_GetFolder( | |
| IKnownFolderManager *iface, | |
| REFKNOWNFOLDERID rfid, | |
| IKnownFolder **ppkf) | |
| { | |
| struct foldermanager *fm = impl_from_IKnownFolderManager( iface ); | |
| struct knownfolder *kf; | |
| HRESULT hr; | |
| TRACE("%s, %p\n", debugstr_guid(rfid), ppkf); | |
| if (!is_knownfolder( fm, rfid )) | |
| { | |
| WARN("unknown folder\n"); | |
| return E_INVALIDARG; | |
| } | |
| hr = knownfolder_create( &kf ); | |
| if (SUCCEEDED( hr )) | |
| { | |
| hr = knownfolder_set_id( kf, rfid ); | |
| *ppkf = &kf->IKnownFolder_iface; | |
| } | |
| else | |
| *ppkf = NULL; | |
| return hr; | |
| } | |
| static HRESULT WINAPI foldermanager_GetFolderByName( | |
| IKnownFolderManager *iface, | |
| LPCWSTR pszCanonicalName, | |
| IKnownFolder **ppkf) | |
| { | |
| struct foldermanager *fm = impl_from_IKnownFolderManager( iface ); | |
| struct knownfolder *kf; | |
| BOOL found = FALSE; | |
| HRESULT hr; | |
| UINT i; | |
| TRACE( "%s, %p\n", debugstr_w(pszCanonicalName), ppkf ); | |
| for (i = 0; i < fm->num_ids; i++) | |
| { | |
| WCHAR *path, *name; | |
| hr = get_known_folder_registry_path( &fm->ids[i], NULL, &path ); | |
| if (FAILED( hr )) return hr; | |
| hr = get_known_folder_wstr( path, L"Name", &name ); | |
| free( path ); | |
| if (FAILED( hr )) return hr; | |
| found = !wcsicmp( pszCanonicalName, name ); | |
| CoTaskMemFree( name ); | |
| if (found) break; | |
| } | |
| if (found) | |
| { | |
| hr = knownfolder_create( &kf ); | |
| if (FAILED( hr )) return hr; | |
| hr = knownfolder_set_id( kf, &fm->ids[i] ); | |
| if (FAILED( hr )) | |
| { | |
| IKnownFolder_Release( &kf->IKnownFolder_iface ); | |
| return hr; | |
| } | |
| *ppkf = &kf->IKnownFolder_iface; | |
| } | |
| else | |
| { | |
| hr = HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ); | |
| *ppkf = NULL; | |
| } | |
| return hr; | |
| } | |
| static HRESULT register_folder(const KNOWNFOLDERID *rfid, const KNOWNFOLDER_DEFINITION *pKFD) | |
| { | |
| HRESULT hr; | |
| HKEY hKey = NULL; | |
| DWORD dwDisp; | |
| LPWSTR registryPath = NULL; | |
| hr = get_known_folder_registry_path(rfid, NULL, ®istryPath); | |
| TRACE("registry path: %s\n", debugstr_w(registryPath)); | |
| if(SUCCEEDED(hr)) | |
| hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, NULL, 0, KEY_WRITE, 0, &hKey, &dwDisp)); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Category", 0, REG_DWORD, (LPBYTE)&pKFD->category, sizeof(pKFD->category))); | |
| if(SUCCEEDED(hr) && pKFD->dwAttributes != 0) | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Attributes", 0, REG_DWORD, (LPBYTE)&pKFD->dwAttributes, sizeof(pKFD->dwAttributes))); | |
| if(SUCCEEDED(hr)) | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Name", 0, REG_SZ, (LPBYTE)pKFD->pszName, (lstrlenW(pKFD->pszName)+1)*sizeof(WCHAR) )); | |
| if(SUCCEEDED(hr) && pKFD->pszParsingName) | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"ParsingName", 0, REG_SZ, (LPBYTE)pKFD->pszParsingName, (lstrlenW(pKFD->pszParsingName)+1)*sizeof(WCHAR) )); | |
| if(SUCCEEDED(hr) && !IsEqualGUID(&pKFD->fidParent, &GUID_NULL)) | |
| { | |
| WCHAR sParentGuid[39]; | |
| StringFromGUID2(&pKFD->fidParent, sParentGuid, ARRAY_SIZE(sParentGuid)); | |
| /* this known folder has parent folder */ | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"ParentFolder", 0, REG_SZ, (LPBYTE)sParentGuid, sizeof(sParentGuid))); | |
| } | |
| if(SUCCEEDED(hr) && pKFD->category != KF_CATEGORY_VIRTUAL && pKFD->pszRelativePath) | |
| hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"RelativePath", 0, REG_SZ, (LPBYTE)pKFD->pszRelativePath, (lstrlenW(pKFD->pszRelativePath)+1)*sizeof(WCHAR) )); | |
| RegCloseKey(hKey); | |
| if(FAILED(hr)) | |
| SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath); | |
| } | |
| free(registryPath); | |
| return hr; | |
| } | |
| static HRESULT WINAPI foldermanager_RegisterFolder( | |
| IKnownFolderManager *iface, | |
| REFKNOWNFOLDERID rfid, | |
| KNOWNFOLDER_DEFINITION const *pKFD) | |
| { | |
| TRACE("(%p, %s, %p)\n", iface, debugstr_guid(rfid), pKFD); | |
| return register_folder(rfid, pKFD); | |
| } | |
| static HRESULT WINAPI foldermanager_UnregisterFolder( | |
| IKnownFolderManager *iface, | |
| REFKNOWNFOLDERID rfid) | |
| { | |
| HRESULT hr; | |
| LPWSTR registryPath = NULL; | |
| TRACE("(%p, %s)\n", iface, debugstr_guid(rfid)); | |
| hr = get_known_folder_registry_path(rfid, NULL, ®istryPath); | |
| if(SUCCEEDED(hr)) | |
| hr = HRESULT_FROM_WIN32(SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath)); | |
| free(registryPath); | |
| return hr; | |
| } | |
| static HRESULT WINAPI foldermanager_FindFolderFromPath( | |
| IKnownFolderManager *iface, | |
| LPCWSTR pszPath, | |
| FFFP_MODE mode, | |
| IKnownFolder **ppkf) | |
| { | |
| FIXME("%s, 0x%08x, %p\n", debugstr_w(pszPath), mode, ppkf); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI foldermanager_FindFolderFromIDList( | |
| IKnownFolderManager *iface, | |
| PCIDLIST_ABSOLUTE pidl, | |
| IKnownFolder **ppkf) | |
| { | |
| FIXME("%p, %p\n", pidl, ppkf); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI foldermanager_Redirect( | |
| IKnownFolderManager *iface, | |
| REFKNOWNFOLDERID rfid, | |
| HWND hwnd, | |
| KF_REDIRECT_FLAGS flags, | |
| LPCWSTR pszTargetPath, | |
| UINT cFolders, | |
| KNOWNFOLDERID const *pExclusion, | |
| LPWSTR *ppszError) | |
| { | |
| return redirect_known_folder(rfid, hwnd, flags, pszTargetPath, cFolders, pExclusion, ppszError); | |
| } | |
| static const struct IKnownFolderManagerVtbl foldermanager_vtbl = | |
| { | |
| foldermanager_QueryInterface, | |
| foldermanager_AddRef, | |
| foldermanager_Release, | |
| foldermanager_FolderIdFromCsidl, | |
| foldermanager_FolderIdToCsidl, | |
| foldermanager_GetFolderIds, | |
| foldermanager_GetFolder, | |
| foldermanager_GetFolderByName, | |
| foldermanager_RegisterFolder, | |
| foldermanager_UnregisterFolder, | |
| foldermanager_FindFolderFromPath, | |
| foldermanager_FindFolderFromIDList, | |
| foldermanager_Redirect | |
| }; | |
| static HRESULT foldermanager_create( void **ppv ) | |
| { | |
| UINT i, j; | |
| struct foldermanager *fm; | |
| fm = malloc( sizeof(*fm) ); | |
| if (!fm) return E_OUTOFMEMORY; | |
| fm->IKnownFolderManager_iface.lpVtbl = &foldermanager_vtbl; | |
| fm->refs = 1; | |
| fm->num_ids = 0; | |
| for (i = 0; i < ARRAY_SIZE(CSIDL_Data); i++) | |
| { | |
| if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL )) fm->num_ids++; | |
| } | |
| fm->ids = malloc( fm->num_ids * sizeof(KNOWNFOLDERID) ); | |
| if (!fm->ids) | |
| { | |
| free( fm ); | |
| return E_OUTOFMEMORY; | |
| } | |
| for (i = j = 0; i < ARRAY_SIZE(CSIDL_Data); i++) | |
| { | |
| if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL )) | |
| { | |
| fm->ids[j] = *CSIDL_Data[i].id; | |
| j++; | |
| } | |
| } | |
| TRACE("found %u known folders\n", fm->num_ids); | |
| *ppv = &fm->IKnownFolderManager_iface; | |
| TRACE("returning iface %p\n", *ppv); | |
| return S_OK; | |
| } | |
| HRESULT WINAPI KnownFolderManager_Constructor( IUnknown *punk, REFIID riid, void **ppv ) | |
| { | |
| TRACE("%p, %s, %p\n", punk, debugstr_guid(riid), ppv); | |
| if (!ppv) | |
| return E_POINTER; | |
| if (punk) | |
| return CLASS_E_NOAGGREGATION; | |
| return foldermanager_create( ppv ); | |
| } | |
| HRESULT WINAPI SHGetKnownFolderIDList(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, PIDLIST_ABSOLUTE *pidl) | |
| { | |
| TRACE("%s, 0x%08lx, %p, %p\n", debugstr_guid(rfid), flags, token, pidl); | |
| if (!pidl) | |
| return E_INVALIDARG; | |
| if (flags) | |
| FIXME("unsupported flags: 0x%08lx\n", flags); | |
| if (token) | |
| FIXME("user token is not used.\n"); | |
| *pidl = NULL; | |
| if (IsEqualIID(rfid, &FOLDERID_Desktop)) | |
| *pidl = _ILCreateDesktop(); | |
| else if (IsEqualIID(rfid, &FOLDERID_RecycleBinFolder)) | |
| *pidl = _ILCreateBitBucket(); | |
| else if (IsEqualIID(rfid, &FOLDERID_ComputerFolder)) | |
| *pidl = _ILCreateMyComputer(); | |
| else if (IsEqualIID(rfid, &FOLDERID_PrintersFolder)) | |
| *pidl = _ILCreatePrinters(); | |
| else if (IsEqualIID(rfid, &FOLDERID_ControlPanelFolder)) | |
| *pidl = _ILCreateControlPanel(); | |
| else if (IsEqualIID(rfid, &FOLDERID_NetworkFolder)) | |
| *pidl = _ILCreateNetwork(); | |
| else if (IsEqualIID(rfid, &FOLDERID_Documents)) | |
| *pidl = _ILCreateMyDocuments(); | |
| else | |
| { | |
| DWORD attributes = 0; | |
| WCHAR *pathW; | |
| HRESULT hr; | |
| hr = SHGetKnownFolderPath(rfid, flags, token, &pathW); | |
| if (FAILED(hr)) | |
| return hr; | |
| hr = SHILCreateFromPathW(pathW, pidl, &attributes); | |
| CoTaskMemFree(pathW); | |
| return hr; | |
| } | |
| return *pidl ? S_OK : E_FAIL; | |
| } | |
| HRESULT WINAPI SHGetKnownFolderItem(REFKNOWNFOLDERID rfid, KNOWN_FOLDER_FLAG flags, HANDLE hToken, | |
| REFIID riid, void **ppv) | |
| { | |
| PIDLIST_ABSOLUTE pidl; | |
| HRESULT hr; | |
| TRACE("%s, 0x%08x, %p, %s, %p\n", debugstr_guid(rfid), flags, hToken, debugstr_guid(riid), ppv); | |
| hr = SHGetKnownFolderIDList(rfid, flags, hToken, &pidl); | |
| if (FAILED(hr)) | |
| { | |
| *ppv = NULL; | |
| return hr; | |
| } | |
| hr = SHCreateItemFromIDList(pidl, riid, ppv); | |
| CoTaskMemFree(pidl); | |
| return hr; | |
| } | |
| static void register_system_knownfolders(void) | |
| { | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(CSIDL_Data); ++i) | |
| { | |
| const CSIDL_DATA *folder = &CSIDL_Data[i]; | |
| if(folder->name){ | |
| KNOWNFOLDER_DEFINITION kfd; | |
| /* register_folder won't modify kfd, so cast away const instead of | |
| * reallocating */ | |
| kfd.category = folder->category; | |
| kfd.pszName = (WCHAR *)folder->name; | |
| kfd.pszDescription = NULL; | |
| kfd.fidParent = folder->parent ? *folder->parent : GUID_NULL; | |
| kfd.pszRelativePath = (WCHAR *)folder->path; | |
| kfd.pszParsingName = (WCHAR *)folder->parsing; | |
| kfd.pszTooltip = NULL; | |
| kfd.pszLocalizedName = NULL; | |
| kfd.pszIcon = NULL; | |
| kfd.pszSecurity = NULL; | |
| kfd.dwAttributes = folder->attributes; | |
| kfd.kfdFlags = folder->flags; | |
| kfd.ftidType = folder->typeid ? *folder->typeid : GUID_NULL; | |
| register_folder(folder->id, &kfd); | |
| } | |
| } | |
| } | |
| HRESULT SHELL_RegisterShellFolders(void) | |
| { | |
| HRESULT hr; | |
| hr = _SHRegisterUserShellFolders(TRUE); | |
| if (SUCCEEDED(hr)) | |
| hr = _SHRegisterUserShellFolders(FALSE); | |
| if (SUCCEEDED(hr)) | |
| hr = _SHRegisterCommonShellFolders(); | |
| if (SUCCEEDED(hr)) | |
| hr = create_extra_folders(); | |
| if (SUCCEEDED(hr)) | |
| hr = set_folder_attributes(); | |
| if (SUCCEEDED(hr)) | |
| register_system_knownfolders(); | |
| return hr; | |
| } |