| /* |
| * Path Functions |
| * |
| * Copyright 1998, 1999, 2000 Juergen Schmied |
| * |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * NOTES: |
| * |
| * Many of these functions are in SHLWAPI.DLL also |
| * |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <stdarg.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include "wine/debug.h" |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winnls.h" |
| #include "winreg.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| |
| #include "shlobj.h" |
| #include "shell32_main.h" |
| #include "undocshell.h" |
| #include "pidl.h" |
| #include "wine/unicode.h" |
| #include "shlwapi.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(shell); |
| |
| /* |
| ########## 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 (!strcasecmp(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] = |
| {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'}, |
| {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'}, |
| {'s','c','r','\0'}, {'\0'} }; |
| |
| TRACE("path=%s\n",debugstr_w(lpszPath)); |
| |
| for(i=0; lpszExtensions[i][0]; i++) |
| if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE; |
| |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * 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] |
| */ |
| BOOL WINAPI 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] |
| */ |
| BOOL WINAPI 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] |
| * |
| * NOTES |
| * exported by ordinal |
| */ |
| BOOL WINAPI PathYetAnotherMakeUniqueName( |
| LPWSTR lpszBuffer, |
| LPCWSTR lpszPathName, |
| LPCWSTR lpszShortName, |
| LPCWSTR lpszLongName) |
| { |
| FIXME("(%p, %s, %s ,%s):stub.\n", |
| lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName)); |
| 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] |
| */ |
| DWORD WINAPI PathCleanupSpecAW (LPCVOID x, LPVOID y) |
| { |
| FIXME("(%p, %p) stub\n",x,y); |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * PathQualifyA [SHELL32] |
| */ |
| BOOL WINAPI PathQualifyA(LPCSTR pszPath) |
| { |
| FIXME("%s\n",pszPath); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathQualifyW [SHELL32] |
| */ |
| BOOL WINAPI PathQualifyW(LPCWSTR pszPath) |
| { |
| FIXME("%s\n",debugstr_w(pszPath)); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathQualify [SHELL32.49] |
| */ |
| BOOL WINAPI PathQualifyAW(LPCVOID pszPath) |
| { |
| if (SHELL_OsIsUnicode()) |
| return PathQualifyW(pszPath); |
| return PathQualifyA(pszPath); |
| } |
| |
| /************************************************************************* |
| * PathResolveA [SHELL32.51] |
| */ |
| BOOL WINAPI PathResolveA( |
| LPSTR lpszPath, |
| LPCSTR *alpszPaths, |
| DWORD dwFlags) |
| { |
| FIXME("(%s,%p,0x%08lx),stub!\n", |
| lpszPath, *alpszPaths, dwFlags); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathResolveW [SHELL32] |
| */ |
| BOOL WINAPI PathResolveW( |
| LPWSTR lpszPath, |
| LPCWSTR *alpszPaths, |
| DWORD dwFlags) |
| { |
| FIXME("(%s,%p,0x%08lx),stub!\n", |
| debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathResolve [SHELL32.51] |
| */ |
| BOOL WINAPI PathResolveAW( |
| LPVOID lpszPath, |
| LPCVOID *alpszPaths, |
| DWORD dwFlags) |
| { |
| if (SHELL_OsIsUnicode()) |
| return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags); |
| return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags); |
| } |
| |
| /************************************************************************* |
| * PathProcessCommandA [SHELL32.653] |
| */ |
| HRESULT WINAPI PathProcessCommandA ( |
| LPCSTR lpszPath, |
| LPSTR lpszBuff, |
| DWORD dwBuffSize, |
| DWORD dwFlags) |
| { |
| FIXME("%s %p 0x%04lx 0x%04lx stub\n", |
| lpszPath, lpszBuff, dwBuffSize, dwFlags); |
| strcpy(lpszBuff, lpszPath); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathProcessCommandW |
| */ |
| HRESULT WINAPI PathProcessCommandW ( |
| LPCWSTR lpszPath, |
| LPWSTR lpszBuff, |
| DWORD dwBuffSize, |
| DWORD dwFlags) |
| { |
| FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n", |
| debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags); |
| strcpyW(lpszBuff, lpszPath); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * PathProcessCommand (SHELL32.653) |
| */ |
| HRESULT 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); |
| } |
| |
| /************************************************************************* |
| * SHGetFolderPathW [SHELL32.@] |
| * |
| * converts csidl to path |
| */ |
| |
| static const WCHAR szSHFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'}; |
| static const WCHAR szSHUserFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'}; |
| static const WCHAR szSetup[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','e','t','u','p','\0'}; |
| static const WCHAR szCurrentVersion[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0'}; |
| |
| |
| |
| static const WCHAR Administrative_ToolsW[] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}; |
| static const WCHAR All_Users__Application_DataW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}; |
| static const WCHAR All_Users__DocumentsW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'D','o','c','u','m','e','n','t','s','\0'}; |
| static const WCHAR All_Users__Documents__My_MusicW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','M','u','s','i','c','\0'}; |
| static const WCHAR All_Users__Documents__My_PicturesW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','P','i','c','t','u','r','e','s','\0'}; |
| static const WCHAR All_Users__Documents__My_VideoW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','V','i','d','e','o','\0'}; |
| static const WCHAR All_Users__Start_Menu__Programs__Administrative_ToolsW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\', |
| 'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}; |
| static const WCHAR All_Users__Start_Menu__Programs__StartUpW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'S','t','a','r','t',' ','M','e','n','u','\\', |
| 'P','r','o','g','r','a','m','s','\\', |
| 'S','t','a','r','t','U','p','\0'}; |
| static const WCHAR All_Users__TemplatesW[] = {'A','l','l',' ','U','s','e','r','s','\\', |
| 'T','e','m','p','l','a','t','e','s','\0'}; |
| static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'}; |
| static const WCHAR Application_DataW[] = {'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}; |
| static const WCHAR CacheW[] = {'C','a','c','h','e','\0'}; |
| static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'}; |
| static const WCHAR Common_Administrative_ToolsW[] = {'C','o','m','m','o','n',' ','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}; |
| static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'}; |
| static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'}; |
| static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'}; |
| static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'}; |
| static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'}; |
| static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'}; |
| static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'}; |
| static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'}; |
| static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'}; |
| static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'}; |
| static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'}; |
| static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'}; |
| static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'}; |
| static const WCHAR Empty_StringW[] = {'\0'}; |
| static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'}; |
| static const WCHAR FontsW[] = {'F','o','n','t','s','\0'}; |
| static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'}; |
| static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'}; |
| static const WCHAR Local_Settings__Application_DataW[] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\', |
| 'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}; |
| static const WCHAR Local_Settings__Application_Data__Microsoft__CD_BurningW[] = { |
| 'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\', |
| 'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\\', |
| 'M','i','c','r','o','s','o','f','t','\\','C','D',' ','B','u','r','n','i','n','g','\0'}; |
| static const WCHAR My_DocumentsW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\0'}; |
| static const WCHAR My_Documents__My_MusicW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','M','u','s','i','c','\0'}; |
| static const WCHAR My_Documents__My_PicturesW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','P','i','c','t','u','r','e','s','\0'}; |
| static const WCHAR My_Documents__My_VideoW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\', |
| 'M','y',' ','V','i','d','e','o','\0'}; |
| static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'}; |
| static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'}; |
| static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'}; |
| static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'}; |
| static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'}; |
| static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'}; |
| static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'}; |
| static const WCHAR Program_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\0'}; |
| static const WCHAR Program_Files__Common_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\\', |
| 'C','o','m','m','o','n',' ','F','i','l','e','s','\0'}; |
| static const WCHAR ProgramsW[] = {'P','r','o','g','r','m','s','\0'}; |
| static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'}; |
| static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'}; |
| static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'}; |
| static const WCHAR ShellNewW[] = {'S','h','e','l','l','N','e','w','\0'}; |
| static const WCHAR Start_Menu__ProgramsW[] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\0'}; |
| static const WCHAR SysDirW[] = {'S','y','s','D','i','r','\0'}; |
| static const WCHAR SYSTEMW[] = {'S','Y','S','T','E','M','\0'}; |
| static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'}; |
| static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'}; |
| static const WCHAR Start_Menu__Programs__Administrative_ToolsW[] = { |
| 'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\', |
| 'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}; |
| static const WCHAR Start_Menu__Programs__StartUpW[] = {'S','t','a','r','t',' ','M','e','n','u','\\', |
| 'P','r','o','g','r','a','m','s','\\', |
| 'S','t','a','r','t','U','p','\0'}; |
| static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'}; |
| static const WCHAR Temporary_Internet_FilesW[] = {'T','e','m','p','o','r','a','r','y',' ','I','n','t','e','r','n','e','t',' ','F','i','l','e','s','\0'}; |
| static const WCHAR WinDirW[] = {'W','i','n','D','i','r','\0'}; |
| static const WCHAR WindowsW[] = {'W','i','n','d','o','w','s','\0'}; |
| |
| |
| |
| |
| typedef struct |
| { |
| DWORD dwFlags; |
| HKEY hRootKey; |
| LPCWSTR szValueName; |
| LPCWSTR szDefaultPath; /* fallback string; sub dir of windows directory */ |
| } CSIDL_DATA; |
| |
| #define CSIDL_MYFLAG_SHFOLDER 1 |
| #define CSIDL_MYFLAG_SETUP 2 |
| #define CSIDL_MYFLAG_CURRVER 4 |
| #define CSIDL_MYFLAG_RELATIVE 8 |
| |
| #define HKLM HKEY_LOCAL_MACHINE |
| #define HKCU HKEY_CURRENT_USER |
| #define HKEY_DISALLOWED (HKEY)0 |
| #define HKEY_UNIMPLEMENTED (HKEY)1 |
| #define HKEY_WINDOWSPATH (HKEY)2 |
| #define HKEY_NONEXISTENT (HKEY)3 |
| static const CSIDL_DATA CSIDL_Data[] = |
| { |
| { /* CSIDL_DESKTOP */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| DesktopW, |
| DesktopW |
| }, |
| { /* CSIDL_INTERNET */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_PROGRAMS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| ProgramsW, |
| Start_Menu__ProgramsW |
| }, |
| { /* CSIDL_CONTROLS (.CPL files) */ |
| CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| SysDirW, |
| SYSTEMW |
| }, |
| { /* CSIDL_PRINTERS */ |
| CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| SysDirW, |
| SYSTEMW |
| }, |
| { /* CSIDL_PERSONAL */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| PersonalW, |
| My_DocumentsW |
| }, |
| { /* CSIDL_FAVORITES */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| FavoritesW, |
| FavoritesW |
| }, |
| { /* CSIDL_STARTUP */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| StartUpW, |
| Start_Menu__Programs__StartUpW |
| }, |
| { /* CSIDL_RECENT */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| RecentW, |
| RecentW |
| }, |
| { /* CSIDL_SENDTO */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| SendToW, |
| SendToW |
| }, |
| { /* CSIDL_BITBUCKET - Recycle Bin */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL, |
| }, |
| { /* CSIDL_STARTMENU */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| Start_MenuW, |
| Start_MenuW |
| }, |
| { /* CSIDL_MYDOCUMENTS */ |
| 0, |
| HKEY_UNIMPLEMENTED, /* FIXME */ |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_MYMUSIC */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| My_MusicW, |
| My_Documents__My_MusicW |
| }, |
| { /* CSIDL_MYVIDEO */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| My_VideoW, |
| My_Documents__My_VideoW |
| }, |
| { /* unassigned */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL, |
| }, |
| { /* CSIDL_DESKTOPDIRECTORY */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| DesktopW, |
| DesktopW |
| }, |
| { /* CSIDL_DRIVES */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL, |
| }, |
| { /* CSIDL_NETWORK */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL, |
| }, |
| { /* CSIDL_NETHOOD */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| NetHoodW, |
| NetHoodW |
| }, |
| { /* CSIDL_FONTS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| FontsW, |
| FontsW |
| }, |
| { /* CSIDL_TEMPLATES */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| TemplatesW, |
| ShellNewW |
| }, |
| { /* CSIDL_COMMON_STARTMENU */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_Start_MenuW, |
| Start_MenuW |
| }, |
| { /* CSIDL_COMMON_PROGRAMS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_ProgramsW, |
| Empty_StringW |
| }, |
| { /* CSIDL_COMMON_STARTUP */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_StartUpW, |
| All_Users__Start_Menu__Programs__StartUpW |
| }, |
| { /* CSIDL_COMMON_DESKTOPDIRECTORY */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_DesktopW, |
| DesktopW |
| }, |
| { /* CSIDL_APPDATA */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| AppDataW, |
| Application_DataW |
| }, |
| { /* CSIDL_PRINTHOOD */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| PrintHoodW, |
| PrintHoodW |
| }, |
| { /* CSIDL_LOCAL_APPDATA (win2k only/undocumented) */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| Local_AppDataW, |
| Local_Settings__Application_DataW, |
| }, |
| { /* CSIDL_ALTSTARTUP */ |
| 0, |
| HKEY_NONEXISTENT, |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_COMMON_ALTSTARTUP */ |
| 0, |
| HKEY_NONEXISTENT, |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_COMMON_FAVORITES */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| FavoritesW, |
| FavoritesW |
| }, |
| { /* CSIDL_INTERNET_CACHE (32) */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| CacheW, |
| Temporary_Internet_FilesW |
| }, |
| { /* CSIDL_COOKIES (33) */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| CookiesW, |
| CookiesW |
| }, |
| { /* CSIDL_HISTORY (34) */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| HistoryW, |
| HistoryW |
| }, |
| { /* CSIDL_COMMON_APPDATA */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_AppDataW, |
| All_Users__Application_DataW |
| }, |
| { /* CSIDL_WINDOWS */ |
| CSIDL_MYFLAG_SETUP, |
| HKLM, |
| WinDirW, |
| WindowsW |
| }, |
| { /* CSIDL_SYSTEM */ |
| CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| SysDirW, |
| SYSTEMW |
| }, |
| { /* CSIDL_PROGRAM_FILES */ |
| CSIDL_MYFLAG_CURRVER, |
| HKLM, |
| ProgramFilesDirW, |
| Program_FilesW |
| }, |
| { /* CSIDL_MYPICTURES */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| My_PicturesW, |
| My_Documents__My_PicturesW |
| }, |
| { /* CSIDL_PROFILE */ |
| CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| WinDirW, /* correct ? */ |
| Empty_StringW |
| }, |
| { /* CSIDL_SYSTEMX86 */ |
| CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| SysDirW, |
| SYSTEMW |
| }, |
| { /* CSIDL_PROGRAM_FILESX86 */ |
| CSIDL_MYFLAG_CURRVER, |
| HKLM, |
| ProgramFilesDirW, |
| Program_FilesW |
| }, |
| { /* CSIDL_PROGRAM_FILES_COMMON */ |
| CSIDL_MYFLAG_CURRVER, |
| HKLM, |
| CommonFilesDirW, |
| Program_Files__Common_FilesW /* ? */ |
| }, |
| { /* CSIDL_PROGRAM_FILES_COMMONX86 */ |
| CSIDL_MYFLAG_CURRVER, |
| HKLM, |
| CommonFilesDirW, |
| Program_Files__Common_FilesW /* ? */ |
| }, |
| { /* CSIDL_COMMON_TEMPLATES */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_TemplatesW, |
| /*"Documents and Settings\\"*/ All_Users__TemplatesW |
| }, |
| { /* CSIDL_COMMON_DOCUMENTS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_DocumentsW, |
| /*"Documents and Settings\\"*/ All_Users__DocumentsW |
| }, |
| { /* CSIDL_COMMON_ADMINTOOLS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| Common_Administrative_ToolsW, |
| /*"Documents and Settings\\"*/ All_Users__Start_Menu__Programs__Administrative_ToolsW |
| }, |
| { /* CSIDL_ADMINTOOLS */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKCU, |
| Administrative_ToolsW, |
| Start_Menu__Programs__Administrative_ToolsW |
| }, |
| { /* CSIDL_CONNECTIONS */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* unassigned 32 */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* unassigned 33 */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* unassigned 34 */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_COMMON_MUSIC */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| CommonMusicW, |
| /*"Documents and Settings\\"*/ All_Users__Documents__My_MusicW |
| }, |
| { /* CSIDL_COMMON_PICTURES */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| CommonPicturesW, |
| /*"Documents and Settings\\"*/ All_Users__Documents__My_PicturesW |
| }, |
| { /* CSIDL_COMMON_VIDEO */ |
| CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE, |
| HKLM, |
| CommonVideoW, |
| /*"Documents and Settings\\"*/ All_Users__Documents__My_VideoW |
| }, |
| { /* CSIDL_RESOURCES */ |
| 0, |
| HKEY_WINDOWSPATH, |
| NULL, |
| ResourcesW |
| }, |
| { /* CSIDL_RESOURCES_LOCALIZED */ |
| 0, |
| HKEY_DISALLOWED, /* FIXME */ |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_COMMON_OEM_LINKS */ |
| 0, |
| HKEY_DISALLOWED, /* FIXME */ |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_CDBURN_AREA */ |
| CSIDL_MYFLAG_SHFOLDER, |
| HKCU, |
| CD_BurningW, |
| Local_Settings__Application_Data__Microsoft__CD_BurningW |
| }, |
| { /* unassigned 3C */ |
| 0, |
| HKEY_DISALLOWED, |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_COMPUTERSNEARME */ |
| 0, |
| HKEY_DISALLOWED, /* FIXME */ |
| NULL, |
| NULL |
| }, |
| { /* CSIDL_PROFILES */ |
| 0, |
| HKEY_DISALLOWED, /* FIXME */ |
| NULL, |
| NULL |
| } |
| }; |
| #undef HKCU |
| #undef HKLM |
| |
| /**********************************************************************/ |
| |
| HRESULT WINAPI SHGetFolderPathW( |
| HWND hwndOwner, |
| int csidl, |
| HANDLE hToken, /* [in] FIXME: get paths for specific user */ |
| DWORD dwFlags, /* [in] FIXME: SHGFP_TYPE_CURRENT|SHGFP_TYPE_DEFAULT */ |
| LPWSTR pszPath) |
| { |
| WCHAR szBuildPath[MAX_PATH]; |
| HKEY hRootKey, hKey; |
| DWORD dwCsidlFlags; |
| DWORD dwType, dwDisp, dwPathLen = MAX_PATH; |
| DWORD folder = csidl & CSIDL_FOLDER_MASK; |
| WCHAR *p; |
| |
| TRACE("%p,%p,csidl=0x%04x\n", hwndOwner,pszPath,csidl); |
| |
| if (!pszPath) |
| return E_INVALIDARG; |
| |
| *pszPath = '\0'; |
| if ((folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0])) || |
| (CSIDL_Data[folder].hRootKey == HKEY_DISALLOWED)) |
| return E_INVALIDARG; |
| if (CSIDL_Data[folder].hRootKey == HKEY_UNIMPLEMENTED) |
| { |
| FIXME("folder 0x%04lx unknown, please add.\n", folder); |
| return E_FAIL; |
| } |
| if (CSIDL_Data[folder].hRootKey == HKEY_NONEXISTENT) |
| return S_FALSE; |
| |
| /* Special case for some values that don't exist in registry */ |
| if (CSIDL_Data[folder].hRootKey == HKEY_WINDOWSPATH) |
| { |
| GetWindowsDirectoryW(pszPath, MAX_PATH); |
| PathAddBackslashW(pszPath); |
| strcatW(pszPath, CSIDL_Data[folder].szDefaultPath); |
| return S_OK; |
| } |
| |
| dwCsidlFlags = CSIDL_Data[folder].dwFlags; |
| hRootKey = CSIDL_Data[folder].hRootKey; |
| |
| if (dwCsidlFlags & CSIDL_MYFLAG_SHFOLDER) |
| { |
| /* user shell folders */ |
| if (RegCreateKeyExW(hRootKey,szSHUserFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL; |
| |
| if (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen)) |
| { |
| RegCloseKey(hKey); |
| |
| /* shell folders */ |
| if (RegCreateKeyExW(hRootKey,szSHFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL; |
| |
| if (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen)) |
| { |
| |
| /* value not existing */ |
| if (dwCsidlFlags & CSIDL_MYFLAG_RELATIVE) |
| { |
| GetWindowsDirectoryW(pszPath, MAX_PATH); |
| PathAddBackslashW(pszPath); |
| strcatW(pszPath, CSIDL_Data[folder].szDefaultPath); |
| } |
| else |
| { |
| GetSystemDirectoryW(pszPath, MAX_PATH); |
| strcpyW(pszPath + 3, CSIDL_Data[folder].szDefaultPath); |
| } |
| dwType=REG_SZ; |
| RegSetValueExW(hKey,CSIDL_Data[folder].szValueName,0,REG_SZ,(LPBYTE)pszPath, |
| (strlenW(pszPath)+1)*sizeof(WCHAR)); |
| } |
| } |
| RegCloseKey(hKey); |
| } |
| else |
| { |
| LPCWSTR pRegPath; |
| |
| if (dwCsidlFlags & CSIDL_MYFLAG_SETUP) |
| pRegPath = szSetup; |
| else if (dwCsidlFlags & CSIDL_MYFLAG_CURRVER) |
| pRegPath = szCurrentVersion; |
| else |
| { |
| ERR("folder settings broken, please correct !\n"); |
| return E_FAIL; |
| } |
| |
| if (RegCreateKeyExW(hRootKey,pRegPath,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL; |
| |
| if (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen)) |
| { |
| /* value not existing */ |
| if (dwCsidlFlags & CSIDL_MYFLAG_RELATIVE) |
| { |
| GetWindowsDirectoryW(pszPath, MAX_PATH); |
| PathAddBackslashW(pszPath); |
| strcatW(pszPath, CSIDL_Data[folder].szDefaultPath); |
| } |
| else |
| { |
| GetSystemDirectoryW(pszPath, MAX_PATH); |
| strcpyW(pszPath + 3, CSIDL_Data[folder].szDefaultPath); |
| } |
| dwType=REG_SZ; |
| RegSetValueExW(hKey,CSIDL_Data[folder].szValueName,0,REG_SZ,(LPBYTE)pszPath, |
| (strlenW(pszPath)+1)*sizeof(WCHAR)); |
| } |
| RegCloseKey(hKey); |
| } |
| |
| /* expand paths like %USERPROFILE% */ |
| if (dwType == REG_EXPAND_SZ) |
| { |
| ExpandEnvironmentStringsW(pszPath, szBuildPath, MAX_PATH); |
| strcpyW(pszPath, szBuildPath); |
| } |
| |
| /* if we don't care about existing directories we are ready */ |
| if(csidl & CSIDL_FLAG_DONT_VERIFY) return S_OK; |
| |
| if (PathFileExistsW(pszPath)) return S_OK; |
| |
| /* not existing but we are not allowed to create it */ |
| if (!(csidl & CSIDL_FLAG_CREATE)) return E_FAIL; |
| |
| /* create directory/directories */ |
| strcpyW(szBuildPath, pszPath); |
| p = strchrW(szBuildPath, '\\'); |
| while (p) |
| { |
| *p = 0; |
| if (!PathFileExistsW(szBuildPath)) |
| { |
| if (!CreateDirectoryW(szBuildPath,NULL)) |
| { |
| ERR("Failed to create directory '%s'.\n", debugstr_w(pszPath)); |
| return E_FAIL; |
| } |
| } |
| *p = '\\'; |
| p = strchrW(p+1, '\\'); |
| } |
| /* last component must be created too. */ |
| if (!PathFileExistsW(szBuildPath)) |
| { |
| if (!CreateDirectoryW(szBuildPath,NULL)) |
| { |
| ERR("Failed to create directory '%s'.\n", debugstr_w(pszPath)); |
| return E_FAIL; |
| } |
| } |
| |
| TRACE("Created missing system directory '%s'\n", debugstr_w(pszPath)); |
| return S_OK; |
| } |
| |
| /************************************************************************* |
| * SHGetFolderPathA [SHELL32.@] |
| */ |
| HRESULT WINAPI SHGetFolderPathA( |
| HWND hwndOwner, |
| int csidl, |
| HANDLE hToken, |
| DWORD dwFlags, |
| LPSTR pszPath) |
| { |
| WCHAR szTemp[MAX_PATH]; |
| HRESULT hr; |
| |
| if (!pszPath) |
| return E_INVALIDARG; |
| |
| *pszPath = '\0'; |
| hr = SHGetFolderPathW(hwndOwner, csidl, hToken, dwFlags, szTemp); |
| if (SUCCEEDED(hr)) |
| WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL, |
| NULL); |
| |
| TRACE("%p,%p,csidl=0x%04x\n",hwndOwner,pszPath,csidl); |
| |
| return hr; |
| } |
| |
| /************************************************************************* |
| * SHGetSpecialFolderPathA [SHELL32.@] |
| */ |
| BOOL WINAPI SHGetSpecialFolderPathA ( |
| HWND hwndOwner, |
| LPSTR szPath, |
| int csidl, |
| BOOL bCreate) |
| { |
| return (SHGetFolderPathA( |
| hwndOwner, |
| csidl + (bCreate ? CSIDL_FLAG_CREATE : 0), |
| NULL, |
| 0, |
| szPath)) == S_OK ? TRUE : FALSE; |
| } |
| |
| /************************************************************************* |
| * SHGetSpecialFolderPathW |
| */ |
| BOOL WINAPI SHGetSpecialFolderPathW ( |
| HWND hwndOwner, |
| LPWSTR szPath, |
| int csidl, |
| BOOL bCreate) |
| { |
| return (SHGetFolderPathW( |
| hwndOwner, |
| csidl + (bCreate ? CSIDL_FLAG_CREATE : 0), |
| NULL, |
| 0, |
| szPath)) == S_OK ? TRUE : FALSE; |
| } |
| |
| /************************************************************************* |
| * SHGetSpecialFolderPath (SHELL32.175) |
| */ |
| BOOL WINAPI SHGetSpecialFolderPathAW ( |
| HWND hwndOwner, |
| LPVOID szPath, |
| int csidl, |
| BOOL bCreate) |
| |
| { |
| if (SHELL_OsIsUnicode()) |
| return SHGetSpecialFolderPathW (hwndOwner, szPath, csidl, bCreate); |
| return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate); |
| } |
| |
| /************************************************************************* |
| * SHGetSpecialFolderLocation [SHELL32.@] |
| * |
| * gets the folder locations from the registry and creates a pidl |
| * creates missing reg keys and directories |
| * |
| * PARAMS |
| * hwndOwner [I] |
| * nFolder [I] CSIDL_xxxxx |
| * ppidl [O] PIDL of a special folder |
| * |
| * NOTES |
| * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent |
| * directory. If the directory is missing it returns a x80070002. |
| * In most cases, this forwards to SHGetSpecialFolderPath, but |
| * CSIDLs with virtual folders (not real paths) must be handled |
| * here. |
| */ |
| 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; |
| |
| *ppidl = NULL; |
| switch (nFolder) |
| { |
| case CSIDL_DESKTOP: |
| *ppidl = _ILCreateDesktop(); |
| 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; |
| |
| case CSIDL_ALTSTARTUP: |
| case CSIDL_COMMON_ALTSTARTUP: |
| hr = E_FAIL; |
| break; |
| |
| case CSIDL_COMPUTERSNEARME: |
| hr = E_FAIL; |
| break; |
| |
| default: |
| { |
| WCHAR szPath[MAX_PATH]; |
| |
| if (SHGetSpecialFolderPathW(hwndOwner, szPath, nFolder, TRUE)) |
| { |
| DWORD attributes=0; |
| |
| TRACE("Value=%s\n", debugstr_w(szPath)); |
| hr = SHILCreateFromPathW(szPath, ppidl, &attributes); |
| } |
| } |
| } |
| if(*ppidl) |
| hr = NOERROR; |
| |
| TRACE("-- (new pidl %p)\n",*ppidl); |
| return hr; |
| } |
| |
| /************************************************************************* |
| * SHGetFolderLocation [SHELL32.@] |
| * |
| * NOTES |
| * the pidl can be a simple one. since we can't get the path out of the pidl |
| * we have to take all data from the pidl |
| * Mostly we forward to SHGetSpecialFolderLocation, but a few special cases |
| * we handle here. |
| */ |
| HRESULT WINAPI SHGetFolderLocation( |
| HWND hwnd, |
| int csidl, |
| HANDLE hToken, |
| DWORD dwFlags, |
| LPITEMIDLIST *ppidl) |
| { |
| HRESULT hr; |
| |
| TRACE_(shell)("%p 0x%08x %p 0x%08lx %p\n", |
| hwnd, csidl, hToken, dwFlags, ppidl); |
| |
| if (!ppidl) |
| return E_INVALIDARG; |
| |
| switch (csidl) |
| { |
| case CSIDL_ALTSTARTUP: |
| case CSIDL_COMMON_ALTSTARTUP: |
| *ppidl = NULL; |
| hr = S_FALSE; |
| break; |
| default: |
| hr = SHGetSpecialFolderLocation(hwnd, csidl, ppidl); |
| } |
| return hr; |
| } |
