6344 lines
206 KiB
C
6344 lines
206 KiB
C
/*
|
|
* 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 "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdio.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 "shtypes.h"
|
|
#include "shresdef.h"
|
|
#include "shell32_main.h"
|
|
#include "undocshell.h"
|
|
#include "pidl.h"
|
|
#include "wine/unicode.h"
|
|
#include "shlwapi.h"
|
|
#include "xdg.h"
|
|
#include "sddl.h"
|
|
#include "knownfolders.h"
|
|
#include "initguid.h"
|
|
#include "shobjidl.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] =
|
|
{{'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]
|
|
*/
|
|
static BOOL PathMakeUniqueNameA(
|
|
LPSTR lpszBuffer,
|
|
DWORD dwBuffSize,
|
|
LPCSTR lpszShortName,
|
|
LPCSTR lpszLongName,
|
|
LPCSTR lpszPathName)
|
|
{
|
|
FIXME("%p %u %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 %u %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);
|
|
strcpyW(retW, pathW);
|
|
PathRemoveExtensionW(pathW);
|
|
|
|
ext = PathFindExtensionW(file);
|
|
|
|
/* now try to make it unique */
|
|
while (PathFileExistsW(retW))
|
|
{
|
|
static const WCHAR fmtW[] = {'%','s',' ','(','%','d',')','%','s',0};
|
|
|
|
sprintfW(retW, fmtW, pathW, i, ext);
|
|
i++;
|
|
}
|
|
|
|
strcpyW(buffer, retW);
|
|
TRACE("ret - %s\n", debugstr_w(buffer));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
########## 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 = strlenW(lpszPathW);
|
|
|
|
while (*p)
|
|
{
|
|
int gct = PathGetCharTypeW(*p);
|
|
if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
|
|
{
|
|
lpszFileW[i]='-';
|
|
rc |= PCS_REPLACEDCHAR;
|
|
}
|
|
else
|
|
lpszFileW[i]=*p;
|
|
i++;
|
|
p++;
|
|
if (length + i == MAX_PATH)
|
|
{
|
|
rc |= PCS_FATAL | PCS_PATHTOOLONG;
|
|
break;
|
|
}
|
|
}
|
|
lpszFileW[i]=0;
|
|
}
|
|
else
|
|
{
|
|
LPSTR lpszFileA = (LPSTR)lpszFileW;
|
|
LPCSTR lpszPathA = (LPCSTR)lpszPathW;
|
|
LPSTR p = lpszFileA;
|
|
|
|
TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
|
|
|
|
if (lpszPathA)
|
|
length = strlen(lpszPathA);
|
|
|
|
while (*p)
|
|
{
|
|
int gct = PathGetCharTypeA(*p);
|
|
if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
|
|
{
|
|
lpszFileA[i]='-';
|
|
rc |= PCS_REPLACEDCHAR;
|
|
}
|
|
else
|
|
lpszFileA[i]=*p;
|
|
i++;
|
|
p++;
|
|
if (length + i == MAX_PATH)
|
|
{
|
|
rc |= PCS_FATAL | PCS_PATHTOOLONG;
|
|
break;
|
|
}
|
|
}
|
|
lpszFileA[i]=0;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* 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);
|
|
}
|
|
|
|
BOOL WINAPI PathFindOnPathExA(LPSTR,LPCSTR *,DWORD);
|
|
BOOL WINAPI PathFindOnPathExW(LPWSTR,LPCWSTR *,DWORD);
|
|
BOOL WINAPI PathFileExistsDefExtA(LPSTR,DWORD);
|
|
BOOL WINAPI PathFileExistsDefExtW(LPWSTR,DWORD);
|
|
|
|
static BOOL PathResolveA(char *path, const char **dirs, DWORD flags)
|
|
{
|
|
BOOL is_file_spec = PathIsFileSpecA(path);
|
|
DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xff;
|
|
|
|
TRACE("(%s,%p,0x%08x)\n", debugstr_a(path), dirs, flags);
|
|
|
|
if (flags & PRF_VERIFYEXISTS && !PathFileExistsA(path))
|
|
{
|
|
if (PathFindOnPathExA(path, dirs, dwWhich))
|
|
return TRUE;
|
|
if (PathFileExistsDefExtA(path, dwWhich))
|
|
return TRUE;
|
|
if (!is_file_spec) GetFullPathNameA(path, MAX_PATH, path, NULL);
|
|
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;
|
|
}
|
|
|
|
static BOOL PathResolveW(WCHAR *path, const WCHAR **dirs, DWORD flags)
|
|
{
|
|
BOOL is_file_spec = PathIsFileSpecW(path);
|
|
DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xff;
|
|
|
|
TRACE("(%s,%p,0x%08x)\n", debugstr_w(path), dirs, flags);
|
|
|
|
if (flags & PRF_VERIFYEXISTS && !PathFileExistsW(path))
|
|
{
|
|
if (PathFindOnPathExW(path, dirs, dwWhich))
|
|
return TRUE;
|
|
if (PathFileExistsDefExtW(path, dwWhich))
|
|
return TRUE;
|
|
if (!is_file_spec) GetFullPathNameW(path, MAX_PATH, path, NULL);
|
|
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%04x 0x%04x 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%04x, 0x%04x) stub\n",
|
|
debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
|
|
if(!lpszPath) return -1;
|
|
if(lpszBuff) strcpyW(lpszBuff, lpszPath);
|
|
return strlenW(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);
|
|
}
|
|
|
|
static const WCHAR szCategory[] = {'C','a','t','e','g','o','r','y',0};
|
|
static const WCHAR szAttributes[] = {'A','t','t','r','i','b','u','t','e','s',0};
|
|
static const WCHAR szName[] = {'N','a','m','e',0};
|
|
static const WCHAR szParsingName[] = {'P','a','r','s','i','n','g','N','a','m','e',0};
|
|
static const WCHAR szRelativePath[] = {'R','e','l','a','t','i','v','e','P','a','t','h',0};
|
|
static const WCHAR szParentFolder[] = {'P','a','r','e','n','t','F','o','l','d','e','r',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 AddNewProgramsFolderW[] = {'A','d','d','N','e','w','P','r','o','g','r','a','m','s','F','o','l','d','e','r',0};
|
|
static const WCHAR AppUpdatesFolderW[] = {'A','p','p','U','p','d','a','t','e','s','F','o','l','d','e','r',0};
|
|
static const WCHAR Administrative_ToolsW[] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
|
|
static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
|
|
static const WCHAR AppData_RoamingW[] = {'A','p','p','D','a','t','a','\\','R','o','a','m','i','n','g','\0'};
|
|
static const WCHAR AppData_LocalLowW[] = {'A','p','p','D','a','t','a','\\','L','o','c','a','l','L','o','w','\0'};
|
|
static const WCHAR AppData_LocalW[] = {'A','p','p','D','a','t','a','\\','L','o','c','a','l','\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 ChangeRemoveProgramsFolderW[] = {'C','h','a','n','g','e','R','e','m','o','v','e','P','r','o','g','r','a','m','s','F','o','l','d','e','r',0};
|
|
static const WCHAR CommonW[] = {'C','o','m','m','o','n',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 CommonDownloadsW[] = {'C','o','m','m','o','n','D','o','w','n','l','o','a','d','s',0};
|
|
static const WCHAR Common_FavoritesW[] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'};
|
|
static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
|
|
static const WCHAR CommonFilesDirX86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
|
|
static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
|
|
static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
|
|
static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
|
|
static const WCHAR CommonRingtonesW[] = {'C','o','m','m','o','n','R','i','n','g','t','o','n','e','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_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 ConflictFolderW[] = {'C','o','n','f','l','i','c','t','F','o','l','d','e','r',0};
|
|
static const WCHAR ConnectionsFolderW[] = {'C','o','n','n','e','c','t','i','o','n','s','F','o','l','d','e','r',0};
|
|
static const WCHAR ContactsW[] = {'C','o','n','t','a','c','t','s','\0'};
|
|
static const WCHAR ControlPanelFolderW[] = {'C','o','n','t','r','o','l','P','a','n','e','l','F','o','l','d','e','r',0};
|
|
static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
|
|
static const WCHAR CSCFolderW[] = {'C','S','C','F','o','l','d','e','r',0};
|
|
static const WCHAR Default_GadgetsW[] = {'D','e','f','a','u','l','t',' ','G','a','d','g','e','t','s',0};
|
|
static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
|
|
static const WCHAR Device_Metadata_StoreW[] = {'D','e','v','i','c','e',' ','M','e','t','a','d','a','t','a',' ','S','t','o','r','e',0};
|
|
static const WCHAR DocumentsW[] = {'D','o','c','u','m','e','n','t','s','\0'};
|
|
static const WCHAR DocumentsLibraryW[] = {'D','o','c','u','m','e','n','t','s','L','i','b','r','a','r','y','\0'};
|
|
static const WCHAR Documents_librarymsW[] = {'D','o','c','u','m','e','n','t','s','.','l','i','b','r','a','r','y','-','m','s',0};
|
|
static const WCHAR DownloadsW[] = {'D','o','w','n','l','o','a','d','s','\0'};
|
|
static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
|
|
static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
|
|
static const WCHAR GadgetsW[] = {'G','a','d','g','e','t','s',0};
|
|
static const WCHAR GamesW[] = {'G','a','m','e','s',0};
|
|
static const WCHAR GameTasksW[] = {'G','a','m','e','T','a','s','k','s',0};
|
|
static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
|
|
static const WCHAR HomeGroupFolderW[] = {'H','o','m','e','G','r','o','u','p','F','o','l','d','e','r',0};
|
|
static const WCHAR ImplicitAppShortcutsW[] = {'I','m','p','l','i','c','i','t','A','p','p','S','h','o','r','t','c','u','t','s',0};
|
|
static const WCHAR InternetFolderW[] = {'I','n','t','e','r','n','e','t','F','o','l','d','e','r',0};
|
|
static const WCHAR LibrariesW[] = {'L','i','b','r','a','r','i','e','s',0};
|
|
static const WCHAR LinksW[] = {'L','i','n','k','s','\0'};
|
|
static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
|
|
static const WCHAR LocalAppDataLowW[] = {'L','o','c','a','l','A','p','p','D','a','t','a','L','o','w',0};
|
|
static const WCHAR LocalizedResourcesDirW[] = {'L','o','c','a','l','i','z','e','d','R','e','s','o','u','r','c','e','s','D','i','r',0};
|
|
static const WCHAR MAPIFolderW[] = {'M','A','P','I','F','o','l','d','e','r',0};
|
|
static const WCHAR Microsoft_Internet_Explorer_Quick_LaunchW[] = {'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\','Q','u','i','c','k',' ','L','a','u','n','c','h',0};
|
|
static const WCHAR Microsoft_Windows_Burn_BurnW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','B','u','r','n','\\','B','u','r','n',0};
|
|
static const WCHAR Microsoft_Windows_GameExplorerW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','G','a','m','e','E','x','p','l','o','r','e','r','\0'};
|
|
static const WCHAR Microsoft_Windows_DeviceMetadataStoreW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','D','e','v','i','c','e','M','e','t','a','d','a','t','a','S','t','o','r','e',0};
|
|
static const WCHAR Microsoft_Windows_HistoryW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','H','i','s','t','o','r','y',0};
|
|
static const WCHAR Microsoft_Windows_INetCacheW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','I','N','e','t','C','a','c','h','e',0};
|
|
static const WCHAR Microsoft_Windows_INetCookiesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','I','N','e','t','C','o','o','k','i','e','s',0};
|
|
static const WCHAR Microsoft_Windows_LibrariesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','L','i','b','r','a','r','i','e','s','\0'};
|
|
static const WCHAR Microsoft_Windows_Network_ShortcutsW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','N','e','t','w','o','r','k',' ','S','h','o','r','t','c','u','t','s',0};
|
|
static const WCHAR Microsoft_Windows_Photo_Gallery_Original_ImagesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','P','h','o','t','o',' ','G','a','l','l','e','r','y','\\','O','r','i','g','i','n','a','l',' ','I','m','a','g','e','s',0};
|
|
static const WCHAR Microsoft_Windows_Printer_ShortcutsW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','P','r','i','n','t','e','r',' ','S','h','o','r','t','c','u','t','s',0};
|
|
static const WCHAR Microsoft_Windows_RecentW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','R','e','c','e','n','t','\0'};
|
|
static const WCHAR Microsoft_Windows_RingtonesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','R','i','n','g','t','o','n','e','s','\0'};
|
|
static const WCHAR Microsoft_Windows_SendToW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','S','e','n','d','T','o',0};
|
|
static const WCHAR Microsoft_Windows_Sidebar_GadgetsW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','S','i','d','e','b','a','r','\\','G','a','d','g','e','t','s',0};
|
|
static const WCHAR Microsoft_Windows_Start_MenuW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','S','t','a','r','t',' ','M','e','n','u',0};
|
|
static const WCHAR Microsoft_Windows_TemplatesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','T','e','m','p','l','a','t','e','s',0};
|
|
static const WCHAR Microsoft_Windows_ThemesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','T','h','e','m','e','s',0};
|
|
static const WCHAR MoviesW[] = {'M','o','v','i','e','s','\0'};
|
|
static const WCHAR MusicW[] = {'M','u','s','i','c','\0'};
|
|
static const WCHAR MusicLibraryW[] = {'M','u','s','i','c','L','i','b','r','a','r','y',0};
|
|
static const WCHAR Music_librarymsW[] = {'M','u','s','i','c','.','l','i','b','r','a','r','y','-','m','s',0};
|
|
static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
|
|
static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
|
|
static const WCHAR My_VideosW[] = {'M','y',' ','V','i','d','e','o','s','\0'};
|
|
static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
|
|
static const WCHAR MyComputerFolderW[] = {'M','y','C','o','m','p','u','t','e','r','F','o','l','d','e','r',0};
|
|
static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
|
|
static const WCHAR NetworkPlacesFolderW[] = {'N','e','t','w','o','r','k','P','l','a','c','e','s','F','o','l','d','e','r',0};
|
|
static const WCHAR OEM_LinksW[] = {'O','E','M',' ','L','i','n','k','s','\0'};
|
|
static const WCHAR Original_ImagesW[] = {'O','r','i','g','i','n','a','l',' ','I','m','a','g','e','s',0};
|
|
static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
|
|
static const WCHAR PhotoAlbumsW[] = {'P','h','o','t','o','A','l','b','u','m','s',0};
|
|
static const WCHAR PicturesW[] = {'P','i','c','t','u','r','e','s','\0'};
|
|
static const WCHAR PicturesLibraryW[] = {'P','i','c','t','u','r','e','s','L','i','b','r','a','r','y',0};
|
|
static const WCHAR Pictures_librarymsW[] = {'P','i','c','t','u','r','e','s','.','l','i','b','r','a','r','y','-','m','s',0};
|
|
static const WCHAR PlaylistsW[] = {'P','l','a','y','l','i','s','t','s',0};
|
|
static const WCHAR PrintersFolderW[] = {'P','r','i','n','t','e','r','s','F','o','l','d','e','r',0};
|
|
static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
|
|
static const WCHAR ProfileW[] = {'P','r','o','f','i','l','e',0};
|
|
static const WCHAR ProgramDataW[] = {'P','r','o','g','r','a','m','D','a','t','a','\0'};
|
|
static const WCHAR Program_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\0'};
|
|
static const WCHAR ProgramFilesW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','\0'};
|
|
static const WCHAR ProgramFilesX86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','X','8','6','\0'};
|
|
static const WCHAR ProgramFilesX64W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','X','6','4','\0'};
|
|
static const WCHAR Program_Files_Common_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'};
|
|
static const WCHAR Program_Files_x86W[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\0'};
|
|
static const WCHAR Program_Files_x86_Common_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'};
|
|
static const WCHAR ProgramFilesCommonW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','C','o','m','m','o','n',0};
|
|
static const WCHAR ProgramFilesCommonX86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','C','o','m','m','o','n','X','8','6',0};
|
|
static const WCHAR ProgramFilesCommonX64W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','C','o','m','m','o','n','X','6','4',0};
|
|
static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
|
|
static const WCHAR ProgramFilesDirX86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
|
|
static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
|
|
static const WCHAR PublicW[] = {'P','u','b','l','i','c',0};
|
|
static const WCHAR PublicGameTasksW[] = {'P','u','b','l','i','c','G','a','m','e','T','a','s','k','s',0};
|
|
static const WCHAR PublicLibrariesW[] = {'P','u','b','l','i','c','L','i','b','r','a','r','i','e','s',0};
|
|
static const WCHAR Quick_LaunchW[] = {'Q','u','i','c','k',' ','L','a','u','n','c','h',0};
|
|
static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
|
|
static const WCHAR RecordedTVLibraryW[] = {'R','e','c','o','r','d','e','d','T','V','L','i','b','r','a','r','y',0};
|
|
static const WCHAR RecordedTV_librarymsW[] = {'R','e','c','o','r','d','e','d','T','V','.','l','i','b','r','a','r','y','-','m','s',0};
|
|
static const WCHAR RecycleBinFolderW[] = {'R','e','c','y','c','l','e','B','i','n','F','o','l','d','e','r',0};
|
|
static const WCHAR ResourceDirW[] = {'R','e','s','o','u','r','c','e','D','i','r','\0'};
|
|
static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
|
|
static const WCHAR RingtonesW[] = {'R','i','n','g','t','o','n','e','s',0};
|
|
static const WCHAR SampleMusicW[] = {'S','a','m','p','l','e','M','u','s','i','c',0};
|
|
static const WCHAR Sample_MusicW[] = {'S','a','m','p','l','e',' ','M','u','s','i','c',0};
|
|
static const WCHAR SamplePicturesW[] = {'S','a','m','p','l','e','P','i','c','t','u','r','e','s',0};
|
|
static const WCHAR Sample_PicturesW[] = {'S','a','m','p','l','e',' ','P','i','c','t','u','r','e','s',0};
|
|
static const WCHAR SamplePlaylistsW[] = {'S','a','m','p','l','e','P','l','a','y','l','i','s','t','s',0};
|
|
static const WCHAR Sample_PlaylistsW[] = {'S','a','m','p','l','e',' ','P','l','a','y','l','i','s','t','s',0};
|
|
static const WCHAR Sample_VideosW[] = {'S','a','m','p','l','e',' ','V','i','d','e','o','s',0};
|
|
static const WCHAR SampleVideosW[] = {'S','a','m','p','l','e','V','i','d','e','o','s',0};
|
|
static const WCHAR Saved_GamesW[] = {'S','a','v','e','d',' ','G','a','m','e','s','\0'};
|
|
static const WCHAR SavedGamesW[] = {'S','a','v','e','d','G','a','m','e','s','\0'};
|
|
static const WCHAR SearchesW[] = {'S','e','a','r','c','h','e','s','\0'};
|
|
static const WCHAR SearchHomeFolderW[] = {'S','e','a','r','c','h','H','o','m','e','F','o','l','d','e','r',0};
|
|
static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
|
|
static const WCHAR Slide_ShowsW[] = {'S','l','i','d','e',' ','S','h','o','w','s',0};
|
|
static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\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 SyncCenterFolderW[] = {'S','y','n','c','C','e','n','t','e','r','F','o','l','d','e','r',0};
|
|
static const WCHAR SyncResultsFolderW[] = {'S','y','n','c','R','e','s','u','l','t','s','F','o','l','d','e','r',0};
|
|
static const WCHAR SyncSetupFolderW[] = {'S','y','n','c','S','e','t','u','p','F','o','l','d','e','r',0};
|
|
static const WCHAR SystemW[] = {'S','y','s','t','e','m',0};
|
|
static const WCHAR SystemX86W[] = {'S','y','s','t','e','m','X','8','6',0};
|
|
static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
|
|
static const WCHAR User_PinnedW[] = {'U','s','e','r',' ','P','i','n','n','e','d',0};
|
|
static const WCHAR UsersW[] = {'U','s','e','r','s','\0'};
|
|
static const WCHAR UsersFilesFolderW[] = {'U','s','e','r','s','F','i','l','e','s','F','o','l','d','e','r',0};
|
|
static const WCHAR UsersLibrariesFolderW[] = {'U','s','e','r','s','L','i','b','r','a','r','i','e','s','F','o','l','d','e','r',0};
|
|
static const WCHAR UserProfilesW[] = {'U','s','e','r','P','r','o','f','i','l','e','s',0};
|
|
static const WCHAR UserProgramFilesW[] = {'U','s','e','r','P','r','o','g','r','a','m','F','i','l','e','s',0};
|
|
static const WCHAR UserProgramFilesCommonW[] = {'U','s','e','r','P','r','o','g','r','a','m','F','i','l','e','s','C','o','m','m','o','n',0};
|
|
static const WCHAR UsersPublicW[] = {'u','s','e','r','s','\\','P','u','b','l','i','c','\0'};
|
|
static const WCHAR VideosW[] = {'V','i','d','e','o','s','\0'};
|
|
static const WCHAR VideosLibraryW[] = {'V','i','d','e','o','s','L','i','b','r','a','r','y',0};
|
|
static const WCHAR Videos_librarymsW[] = {'V','i','d','e','o','s','.','l','i','b','r','a','r','y','-','m','s',0};
|
|
static const WCHAR WindowsW[] = {'W','i','n','d','o','w','s',0};
|
|
static const WCHAR Windows_Sidebar_GadgetsW[] = {'W','i','n','d','o','w','s',' ','S','i','d','e','b','a','r','\\','G','a','d','g','e','t','s',0};
|
|
static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
|
|
static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
|
|
static const WCHAR PublicProfileW[] = {'%','P','U','B','L','I','C','%',0};
|
|
static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
|
|
static const WCHAR ProgramDataVarW[] = {'%','P','r','o','g','r','a','m','D','a','t','a','%','\0'};
|
|
static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
|
|
static const WCHAR ProfileListW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','P','r','o','f','i','l','e','L','i','s','t',0};
|
|
static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
|
|
static const WCHAR szSHFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
|
|
static const WCHAR szSHUserFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
|
|
static const WCHAR szDefaultProfileDirW[] = {'u','s','e','r','s',0};
|
|
static const WCHAR szKnownFolderDescriptions[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','F','o','l','d','e','r','D','e','s','c','r','i','p','t','i','o','n','s','\0'};
|
|
static const WCHAR szKnownFolderRedirections[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s',0};
|
|
|
|
#define CHANGEREMOVEPROGRAMS_PARSING_GUID '{','7','b','8','1','b','e','6','a','-','c','e','2','b','-','4','6','7','6','-','a','2','9','e','-','e','b','9','0','7','a','5','1','2','6','c','5','}'
|
|
#define SYNCMANAGER_PARSING_GUID '{','9','C','7','3','F','5','E','5','-','7','A','E','7','-','4','E','3','2','-','A','8','E','8','-','8','D','2','3','B','8','5','2','5','5','B','F','}'
|
|
#define SYSTEMFOLDERS_PARSING_GUID '{','2','1','E','C','2','0','2','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','D','-','0','8','0','0','2','B','3','0','3','0','9','D','}'
|
|
#define USERFOLDERS_PARSING_GUID '{','5','9','0','3','1','a','4','7','-','3','f','7','2','-','4','4','a','7','-','8','9','c','5','-','5','5','9','5','f','e','6','b','3','0','e','e','}'
|
|
#define USERSLIBRARIES_PARSING_GUID '{','0','3','1','E','4','8','2','5','-','7','B','9','4','-','4','d','c','3','-','B','1','3','1','-','E','9','4','6','B','4','4','C','8','D','D','5','}'
|
|
|
|
static const WCHAR ComputerFolderParsingNameW[] = {':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0};
|
|
static const WCHAR ControlPanelFolderParsingNameW[] = {':',':','{','2','6','E','E','0','6','6','8','-','A','0','0','A','-','4','4','D','7','-','9','3','7','1','-','B','E','B','0','6','4','C','9','8','6','8','3','}','\\','0',0};
|
|
static const WCHAR ControlPanelFolderRelativePathW[] = {':',':','{','2','1','E','C','2','0','2','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','D','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0};
|
|
static const WCHAR GamesParsingNameW[] = {':',':','{','E','D','2','2','8','F','D','F','-','9','E','A','8','-','4','8','7','0','-','8','3','b','1','-','9','6','b','0','2','C','F','E','0','D','5','2','}',0};
|
|
static const WCHAR HomeGroupParsingNameW[] = {':',':','{','B','4','F','B','3','F','9','8','-','C','1','E','A','-','4','2','8','d','-','A','7','8','A','-','D','1','F','5','6','5','9','C','B','A','9','3','}',0};
|
|
static const WCHAR InternetFolderParsingNameW[] = {':',':','{','8','7','1','C','5','3','8','0','-','4','2','A','0','-','1','0','6','9','-','A','2','E','A','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0};
|
|
static const WCHAR NetworkFolderParsingNameW[] = {':',':','{','F','0','2','C','1','A','0','D','-','B','E','2','1','-','4','3','5','0','-','8','8','B','0','-','7','3','6','7','F','C','9','6','E','F','3','C','}',0};
|
|
static const WCHAR PublicParsingNameW[] = {':',':','{','4','3','3','6','a','5','4','d','-','0','3','8','b','-','4','6','8','5','-','a','b','0','2','-','9','9','b','b','5','2','d','3','f','b','8','b','}',0};
|
|
static const WCHAR RecycleBinFolderParsingNameW[] = {':',':','{','6','4','5','F','F','0','4','0','-','5','0','8','1','-','1','0','1','B','-','9','F','0','8','-','0','0','A','A','0','0','2','F','9','5','4','E','}',0};
|
|
static const WCHAR SearchHomeParsingNameW[] = {':',':','{','9','3','4','3','8','1','2','e','-','1','c','3','7','-','4','a','4','9','-','a','1','2','e','-','4','b','2','d','8','1','0','d','9','5','6','b','}',0};
|
|
static const WCHAR SEARCH_CSCParsingNameW[] = {'s','h','e','l','l',':',':',':','{','B','D','7','A','2','E','7','B','-','2','1','C','B','-','4','1','b','2','-','A','0','8','6','-','B','3','0','9','6','8','0','C','6','B','7','E','}','\\','*',0};
|
|
static const WCHAR SEARCH_MAPIParsingNameW[] = {'s','h','e','l','l',':',':',':','{','8','9','D','8','3','5','7','6','-','6','B','D','1','-','4','C','8','6','-','9','4','5','4','-','B','E','B','0','4','E','9','4','C','8','1','9','}','\\','*',0};
|
|
static const WCHAR UsersFilesParsingNameW[] = {':',':','{','5','9','0','3','1','a','4','7','-','3','f','7','2','-','4','4','a','7','-','8','9','c','5','-','5','5','9','5','f','e','6','b','3','0','e','e','}',0};
|
|
static const WCHAR UsersLibrariesParsingNameW[] = {':',':','{','0','3','1','E','4','8','2','5','-','7','B','9','4','-','4','d','c','3','-','B','1','3','1','-','E','9','4','6','B','4','4','C','8','D','D','5','}',0};
|
|
static const WCHAR AddNewProgramsParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':','{','1','5','e','a','e','9','2','e','-','f','1','7','a','-','4','4','3','1','-','9','f','2','8','-','8','0','5','e','4','8','2','d','a','f','d','4','}',0};
|
|
static const WCHAR ConnectionsFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':','{','7','0','0','7','A','C','C','7','-','3','2','0','2','-','1','1','D','1','-','A','A','D','2','-','0','0','8','0','5','F','C','1','2','7','0','E','}',0};
|
|
static const WCHAR PrintersFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':','{','2','2','2','7','A','2','8','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','E','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0};
|
|
static const WCHAR ChangeRemoveProgramsParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', CHANGEREMOVEPROGRAMS_PARSING_GUID, 0};
|
|
static const WCHAR AppUpdatesParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', CHANGEREMOVEPROGRAMS_PARSING_GUID, '\\',':',':','{','d','4','5','0','a','8','a','1','-','9','5','6','8','-','4','5','c','7','-','9','c','0','e','-','b','4','f','9','f','b','4','5','3','7','b','d','}',0};
|
|
static const WCHAR SyncManagerFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', SYNCMANAGER_PARSING_GUID, 0};
|
|
static const WCHAR ConflictFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', SYNCMANAGER_PARSING_GUID, '\\',':',':','{','E','4','1','3','D','0','4','0','-','6','7','8','8','-','4','C','2','2','-','9','5','7','E','-','1','7','5','D','1','C','5','1','3','A','3','4','}',',',0};
|
|
static const WCHAR SyncResultsFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', SYNCMANAGER_PARSING_GUID, '\\',':',':','{','B','C','4','8','B','3','2','F','-','5','9','1','0','-','4','7','F','5','-','8','5','7','0','-','5','0','7','4','A','8','A','5','6','3','6','A','}',',',0};
|
|
static const WCHAR SyncSetupFolderParsingNameW[] = {':',':', SYSTEMFOLDERS_PARSING_GUID, '\\',':',':', SYNCMANAGER_PARSING_GUID, '\\',':',':','{','F','1','3','9','0','A','9','A','-','A','3','F','4','-','4','E','5','D','-','9','C','5','F','-','9','8','F','3','B','D','8','D','9','3','5','C','}',',',0};
|
|
static const WCHAR ContactsParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','5','6','7','8','4','8','5','4','-','C','6','C','B','-','4','6','2','B','-','8','1','6','9','-','8','8','E','3','5','0','A','C','B','8','8','2','}',0};
|
|
static const WCHAR DocumentsParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','F','D','D','3','9','A','D','0','-','2','3','8','F','-','4','6','A','F','-','A','D','B','4','-','6','C','8','5','4','8','0','3','6','9','C','7','}',0};
|
|
static const WCHAR LinksParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','b','f','b','9','d','5','e','0','-','c','6','a','9','-','4','0','4','c','-','b','2','b','2','-','a','e','6','d','b','6','a','f','4','9','6','8','}',0};
|
|
static const WCHAR MusicParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','4','B','D','8','D','5','7','1','-','6','D','1','9','-','4','8','D','3','-','B','E','9','7','-','4','2','2','2','2','0','0','8','0','E','4','3','}',0};
|
|
static const WCHAR PicturesParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','3','3','E','2','8','1','3','0','-','4','E','1','E','-','4','6','7','6','-','8','3','5','A','-','9','8','3','9','5','C','3','B','C','3','B','B','}',0};
|
|
static const WCHAR SavedGamesParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','4','C','5','C','3','2','F','F','-','B','B','9','D','-','4','3','b','0','-','B','5','B','4','-','2','D','7','2','E','5','4','E','A','A','A','4','}',0};
|
|
static const WCHAR SavedSearchesParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','7','d','1','d','3','a','0','4','-','d','e','b','b','-','4','1','1','5','-','9','5','c','f','-','2','f','2','9','d','a','2','9','2','0','d','a','}',0};
|
|
static const WCHAR VideosParsingNameW[] = {':',':', USERFOLDERS_PARSING_GUID, '\\','{','1','8','9','8','9','B','1','D','-','9','9','B','5','-','4','5','5','B','-','8','4','1','C','-','A','B','7','C','7','4','E','4','D','D','F','C','}',0};
|
|
static const WCHAR DocumentsLibraryParsingNameW[] = {':',':', USERSLIBRARIES_PARSING_GUID, '\\','{','7','b','0','d','b','1','7','d','-','9','c','d','2','-','4','a','9','3','-','9','7','3','3','-','4','6','c','c','8','9','0','2','2','e','7','c','}',0};
|
|
static const WCHAR MusicLibraryParsingNameW[] = {':',':', USERSLIBRARIES_PARSING_GUID, '\\','{','2','1','1','2','A','B','0','A','-','C','8','6','A','-','4','f','f','e','-','A','3','6','8','-','0','D','E','9','6','E','4','7','0','1','2','E','}',0};
|
|
static const WCHAR PicturesLibraryParsingNameW[] = {':',':', USERSLIBRARIES_PARSING_GUID, '\\','{','A','9','9','0','A','E','9','F','-','A','0','3','B','-','4','e','8','0','-','9','4','B','C','-','9','9','1','2','D','7','5','0','4','1','0','4','}',0};
|
|
static const WCHAR VideosLibraryParsingNameW[] = {':',':', USERSLIBRARIES_PARSING_GUID, '\\','{','4','9','1','E','9','2','2','F','-','5','6','4','3','-','4','a','f','4','-','A','7','E','B','-','4','E','7','A','1','3','8','D','8','1','7','4','}',0};
|
|
|
|
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=%i\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=%i\n", This, ref);
|
|
|
|
if (ref == 0)
|
|
heap_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
|
|
{
|
|
const KNOWNFOLDERID *id;
|
|
CSIDL_Type type;
|
|
LPCWSTR szValueName;
|
|
LPCWSTR szDefaultPath; /* fallback string or resource ID */
|
|
|
|
/* KNOWNFOLDER_DEFINITION fields */
|
|
KF_CATEGORY category;
|
|
const WCHAR *pszName;
|
|
const WCHAR *pszDescription;
|
|
const KNOWNFOLDERID *fidParent;
|
|
const WCHAR *pszRelativePath;
|
|
const WCHAR *pszParsingName;
|
|
const WCHAR *pszTooltip;
|
|
const WCHAR *pszLocalizedName;
|
|
const WCHAR *pszIcon;
|
|
const WCHAR *pszSecurity;
|
|
DWORD dwAttributes;
|
|
KF_DEFINITION_FLAGS kfdFlags;
|
|
const FOLDERTYPEID *ftidType;
|
|
} CSIDL_DATA;
|
|
|
|
static const CSIDL_DATA CSIDL_Data[] =
|
|
{
|
|
{ /* 0x00 - CSIDL_DESKTOP */
|
|
&FOLDERID_Desktop,
|
|
CSIDL_Type_User,
|
|
DesktopW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
DesktopW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
DesktopW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x01 - CSIDL_INTERNET */
|
|
&FOLDERID_InternetFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
InternetFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
InternetFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x02 - CSIDL_PROGRAMS */
|
|
&FOLDERID_Programs,
|
|
CSIDL_Type_User,
|
|
ProgramsW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
ProgramsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_StartMenu, /* parent */
|
|
ProgramsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x03 - CSIDL_CONTROLS (.CPL files) */
|
|
&FOLDERID_ControlPanelFolder,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
ControlPanelFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
ControlPanelFolderRelativePathW, /* relative path */
|
|
ControlPanelFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x04 - CSIDL_PRINTERS */
|
|
&FOLDERID_PrintersFolder,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
PrintersFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
PrintersFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x05 - CSIDL_PERSONAL */
|
|
&FOLDERID_Documents,
|
|
CSIDL_Type_User,
|
|
PersonalW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
PersonalW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
DocumentsW, /* relative path */
|
|
DocumentsParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x06 - CSIDL_FAVORITES */
|
|
&FOLDERID_Favorites,
|
|
CSIDL_Type_User,
|
|
FavoritesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
FavoritesW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
FavoritesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x07 - CSIDL_STARTUP */
|
|
&FOLDERID_Startup,
|
|
CSIDL_Type_User,
|
|
StartUpW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
StartupW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Programs, /* parent */
|
|
StartUpW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x08 - CSIDL_RECENT */
|
|
&FOLDERID_Recent,
|
|
CSIDL_Type_User,
|
|
RecentW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
RecentW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_RecentW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x09 - CSIDL_SENDTO */
|
|
&FOLDERID_SendTo,
|
|
CSIDL_Type_User,
|
|
SendToW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
SendToW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_SendToW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
|
|
&FOLDERID_RecycleBinFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
RecycleBinFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
RecycleBinFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x0b - CSIDL_STARTMENU */
|
|
&FOLDERID_StartMenu,
|
|
CSIDL_Type_User,
|
|
Start_MenuW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
Start_MenuW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_Start_MenuW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x0c - CSIDL_MYDOCUMENTS */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x0d - CSIDL_MYMUSIC */
|
|
&FOLDERID_Music,
|
|
CSIDL_Type_User,
|
|
My_MusicW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
My_MusicW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
MusicW, /* relative path */
|
|
MusicParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x0e - CSIDL_MYVIDEO */
|
|
&FOLDERID_Videos,
|
|
CSIDL_Type_User,
|
|
My_VideosW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
My_VideoW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
VideosW, /* relative path */
|
|
VideosParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x0f - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
},
|
|
{ /* 0x10 - CSIDL_DESKTOPDIRECTORY */
|
|
&FOLDERID_Desktop,
|
|
CSIDL_Type_User,
|
|
DesktopW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
DesktopW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
DesktopW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x11 - CSIDL_DRIVES */
|
|
&FOLDERID_ComputerFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
MyComputerFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
ComputerFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x12 - CSIDL_NETWORK */
|
|
&FOLDERID_NetworkFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
NetworkPlacesFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NetworkFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x13 - CSIDL_NETHOOD */
|
|
&FOLDERID_NetHood,
|
|
CSIDL_Type_User,
|
|
NetHoodW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
NetHoodW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_Network_ShortcutsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x14 - CSIDL_FONTS */
|
|
&FOLDERID_Fonts,
|
|
CSIDL_Type_WindowsPath,
|
|
FontsW,
|
|
FontsW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
FontsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Windows, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&FOLDERID_Windows/* typeid */
|
|
},
|
|
{ /* 0x15 - CSIDL_TEMPLATES */
|
|
&FOLDERID_Templates,
|
|
CSIDL_Type_User,
|
|
TemplatesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
TemplatesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_TemplatesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x16 - CSIDL_COMMON_STARTMENU */
|
|
&FOLDERID_CommonStartMenu,
|
|
CSIDL_Type_ProgramData,
|
|
Common_Start_MenuW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_Start_MenuW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
Microsoft_Windows_Start_MenuW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x17 - CSIDL_COMMON_PROGRAMS */
|
|
&FOLDERID_CommonPrograms,
|
|
CSIDL_Type_ProgramData,
|
|
Common_ProgramsW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_ProgramsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_CommonStartMenu, /* parent */
|
|
ProgramsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x18 - CSIDL_COMMON_STARTUP */
|
|
&FOLDERID_CommonStartup,
|
|
CSIDL_Type_ProgramData,
|
|
Common_StartUpW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_StartupW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_CommonPrograms, /* parent */
|
|
StartUpW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
|
|
&FOLDERID_PublicDesktop,
|
|
CSIDL_Type_AllUsers,
|
|
Common_DesktopW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_DesktopW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
DesktopW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x1a - CSIDL_APPDATA */
|
|
&FOLDERID_RoamingAppData,
|
|
CSIDL_Type_User,
|
|
AppDataW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
AppDataW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
AppData_RoamingW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x1b - CSIDL_PRINTHOOD */
|
|
&FOLDERID_PrintHood,
|
|
CSIDL_Type_User,
|
|
PrintHoodW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
PrintHoodW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_Printer_ShortcutsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x1c - CSIDL_LOCAL_APPDATA */
|
|
&FOLDERID_LocalAppData,
|
|
CSIDL_Type_User,
|
|
Local_AppDataW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
Local_AppDataW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
AppData_LocalW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x1d - CSIDL_ALTSTARTUP */
|
|
&GUID_NULL,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
|
|
&GUID_NULL,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x1f - CSIDL_COMMON_FAVORITES */
|
|
&FOLDERID_Favorites,
|
|
CSIDL_Type_AllUsers,
|
|
Common_FavoritesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
FavoritesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
FavoritesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x20 - CSIDL_INTERNET_CACHE */
|
|
&FOLDERID_InternetCache,
|
|
CSIDL_Type_User,
|
|
CacheW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
CacheW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_INetCacheW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x21 - CSIDL_COOKIES */
|
|
&FOLDERID_Cookies,
|
|
CSIDL_Type_User,
|
|
CookiesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
CookiesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_INetCookiesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x22 - CSIDL_HISTORY */
|
|
&FOLDERID_History,
|
|
CSIDL_Type_User,
|
|
HistoryW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
HistoryW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_HistoryW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x23 - CSIDL_COMMON_APPDATA */
|
|
&FOLDERID_ProgramData,
|
|
CSIDL_Type_ProgramData,
|
|
Common_AppDataW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
Common_AppDataW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x24 - CSIDL_WINDOWS */
|
|
&FOLDERID_Windows,
|
|
CSIDL_Type_WindowsPath,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
WindowsW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x25 - CSIDL_SYSTEM */
|
|
&FOLDERID_System,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
SystemW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x26 - CSIDL_PROGRAM_FILES */
|
|
&FOLDERID_ProgramFiles,
|
|
CSIDL_Type_CurrVer,
|
|
ProgramFilesDirW,
|
|
Program_FilesW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x27 - CSIDL_MYPICTURES */
|
|
&FOLDERID_Pictures,
|
|
CSIDL_Type_User,
|
|
My_PicturesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
My_PicturesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
PicturesW, /* relative path */
|
|
PicturesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x28 - CSIDL_PROFILE */
|
|
&FOLDERID_Profile,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProfileW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x29 - CSIDL_SYSTEMX86 */
|
|
&FOLDERID_SystemX86,
|
|
CSIDL_Type_SystemX86Path,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
SystemX86W, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2a - CSIDL_PROGRAM_FILESX86 */
|
|
&FOLDERID_ProgramFilesX86,
|
|
CSIDL_Type_CurrVer,
|
|
ProgramFilesDirX86W,
|
|
Program_Files_x86W,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesX86W, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
|
|
&FOLDERID_ProgramFilesCommon,
|
|
CSIDL_Type_CurrVer,
|
|
CommonFilesDirW,
|
|
Program_Files_Common_FilesW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesCommonW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
|
|
&FOLDERID_ProgramFilesCommonX86,
|
|
CSIDL_Type_CurrVer,
|
|
CommonFilesDirX86W,
|
|
Program_Files_x86_Common_FilesW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesCommonX86W, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2d - CSIDL_COMMON_TEMPLATES */
|
|
&FOLDERID_CommonTemplates,
|
|
CSIDL_Type_ProgramData,
|
|
Common_TemplatesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_TemplatesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
Microsoft_Windows_TemplatesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2e - CSIDL_COMMON_DOCUMENTS */
|
|
&FOLDERID_PublicDocuments,
|
|
CSIDL_Type_AllUsers,
|
|
Common_DocumentsW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_DocumentsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
DocumentsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
|
|
&FOLDERID_CommonAdminTools,
|
|
CSIDL_Type_ProgramData,
|
|
Common_Administrative_ToolsW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Common_Administrative_ToolsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_CommonPrograms, /* parent */
|
|
Administrative_ToolsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x30 - CSIDL_ADMINTOOLS */
|
|
&FOLDERID_AdminTools,
|
|
CSIDL_Type_User,
|
|
Administrative_ToolsW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
Administrative_ToolsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Programs, /* parent */
|
|
Administrative_ToolsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x31 - CSIDL_CONNECTIONS */
|
|
&FOLDERID_ConnectionsFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
ConnectionsFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
Administrative_ToolsW, /* relative path */
|
|
ConnectionsFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x32 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x33 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x34 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x35 - CSIDL_COMMON_MUSIC */
|
|
&FOLDERID_PublicMusic,
|
|
CSIDL_Type_AllUsers,
|
|
CommonMusicW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
CommonMusicW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
MusicW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x36 - CSIDL_COMMON_PICTURES */
|
|
&FOLDERID_PublicPictures,
|
|
CSIDL_Type_AllUsers,
|
|
CommonPicturesW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
CommonPicturesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
PicturesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x37 - CSIDL_COMMON_VIDEO */
|
|
&FOLDERID_PublicVideos,
|
|
CSIDL_Type_AllUsers,
|
|
CommonVideoW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
CommonVideoW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
VideosW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x38 - CSIDL_RESOURCES */
|
|
&FOLDERID_ResourceDir,
|
|
CSIDL_Type_WindowsPath,
|
|
NULL,
|
|
ResourcesW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ResourceDirW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
|
|
&FOLDERID_LocalizedResourcesDir,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
LocalizedResourcesDirW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x3a - CSIDL_COMMON_OEM_LINKS */
|
|
&FOLDERID_CommonOEMLinks,
|
|
CSIDL_Type_ProgramData,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
OEM_LinksW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
OEM_LinksW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x3b - CSIDL_CDBURN_AREA */
|
|
&FOLDERID_CDBurning,
|
|
CSIDL_Type_User,
|
|
CD_BurningW,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
CD_BurningW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_Burn_BurnW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x3c unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3d - CSIDL_COMPUTERSNEARME */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3e - CSIDL_PROFILES */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3f */
|
|
&FOLDERID_AddNewPrograms,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
AddNewProgramsFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
AddNewProgramsParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x40 */
|
|
&FOLDERID_AppUpdates,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
AppUpdatesFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
AppUpdatesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x41 */
|
|
&FOLDERID_ChangeRemovePrograms,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
ChangeRemoveProgramsFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
ChangeRemoveProgramsParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x42 */
|
|
&FOLDERID_ConflictFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
ConflictFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
ConflictFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x43 - CSIDL_CONTACTS */
|
|
&FOLDERID_Contacts,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
ContactsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
ContactsW, /* relative path */
|
|
ContactsParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x44 */
|
|
&FOLDERID_DeviceMetadataStore,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Device_Metadata_StoreW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
Microsoft_Windows_DeviceMetadataStoreW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x45 */
|
|
&GUID_NULL,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
DocumentsW
|
|
},
|
|
{ /* 0x46 */
|
|
&FOLDERID_DocumentsLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
DocumentsLibraryW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Libraries, /* parent */
|
|
Documents_librarymsW, /* relative path */
|
|
DocumentsLibraryParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE | KFDF_STREAM, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x47 - CSIDL_DOWNLOADS */
|
|
&FOLDERID_Downloads,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
DownloadsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
DownloadsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x48 */
|
|
&FOLDERID_Games,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
GamesW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
GamesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x49 */
|
|
&FOLDERID_GameTasks,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
GameTasksW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_GameExplorerW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4a */
|
|
&FOLDERID_HomeGroup,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
HomeGroupFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
HomeGroupParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4b */
|
|
&FOLDERID_ImplicitAppShortcuts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
ImplicitAppShortcutsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_UserPinned, /* parent */
|
|
ImplicitAppShortcutsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4c */
|
|
&FOLDERID_Libraries,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
LibrariesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Windows_LibrariesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4d - CSIDL_LINKS */
|
|
&FOLDERID_Links,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
LinksW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
LinksW, /* relative path */
|
|
LinksParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4e - CSIDL_APPDATA_LOCALLOW */
|
|
&FOLDERID_LocalAppDataLow,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
LocalAppDataLowW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
AppData_LocalLowW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x4f */
|
|
&FOLDERID_MusicLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
MusicLibraryW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Libraries, /* parent */
|
|
Music_librarymsW, /* relative path */
|
|
MusicLibraryParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE | KFDF_STREAM, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x50 */
|
|
&FOLDERID_OriginalImages,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
Original_ImagesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_Photo_Gallery_Original_ImagesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x51 */
|
|
&FOLDERID_PhotoAlbums,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
PhotoAlbumsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Pictures, /* parent */
|
|
Slide_ShowsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x52 */
|
|
&FOLDERID_PicturesLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
PicturesLibraryW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Libraries, /* parent */
|
|
Pictures_librarymsW, /* relative path */
|
|
PicturesLibraryParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE | KFDF_STREAM, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x53 */
|
|
&FOLDERID_Playlists,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
PlaylistsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Music, /* parent */
|
|
PlaylistsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x54 */
|
|
&FOLDERID_ProgramFilesX64,
|
|
#ifdef _WIN64
|
|
CSIDL_Type_CurrVer,
|
|
ProgramFilesDirW,
|
|
Program_FilesW,
|
|
#else
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL,
|
|
#endif
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesX64W, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x55 */
|
|
&FOLDERID_ProgramFilesCommonX64,
|
|
#ifdef _WIN64
|
|
CSIDL_Type_CurrVer,
|
|
ProgramFilesCommonX64W,
|
|
Program_Files_Common_FilesW,
|
|
#else
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL,
|
|
#endif
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
ProgramFilesCommonX64W, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x56 */
|
|
&FOLDERID_Public,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
PublicW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
PublicParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x57 */
|
|
&FOLDERID_PublicDownloads,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
CommonDownloadsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
DownloadsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x58 */
|
|
&FOLDERID_PublicGameTasks,
|
|
CSIDL_Type_ProgramData,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
PublicGameTasksW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
Microsoft_Windows_GameExplorerW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_LOCAL_REDIRECT_ONLY, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x59 */
|
|
&FOLDERID_PublicLibraries,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
PublicLibrariesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Public, /* parent */
|
|
LibrariesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5a */
|
|
&FOLDERID_PublicRingtones,
|
|
CSIDL_Type_ProgramData,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
CommonRingtonesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramData, /* parent */
|
|
Microsoft_Windows_RingtonesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5b */
|
|
&FOLDERID_QuickLaunch,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
Quick_LaunchW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_RoamingAppData, /* parent */
|
|
Microsoft_Internet_Explorer_Quick_LaunchW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5c */
|
|
&FOLDERID_RecordedTVLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
RecordedTVLibraryW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_PublicLibraries, /* parent */
|
|
RecordedTV_librarymsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE | KFDF_STREAM, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5d */
|
|
&FOLDERID_Ringtones,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
RingtonesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_RingtonesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5e */
|
|
&FOLDERID_SampleMusic,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
SampleMusicW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_PublicMusic, /* parent */
|
|
Sample_MusicW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x5f */
|
|
&FOLDERID_SamplePictures,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
SamplePicturesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_PublicPictures, /* parent */
|
|
Sample_PicturesW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x60 */
|
|
&FOLDERID_SamplePlaylists,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
SamplePlaylistsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_PublicMusic, /* parent */
|
|
Sample_PlaylistsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x61 */
|
|
&FOLDERID_SampleVideos,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
SampleVideosW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_PublicVideos, /* parent */
|
|
Sample_VideosW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x62 - CSIDL_SAVED_GAMES */
|
|
&FOLDERID_SavedGames,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
SavedGamesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
Saved_GamesW, /* relative path */
|
|
SavedGamesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_ROAMABLE | KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x63 - CSIDL_SEARCHES */
|
|
&FOLDERID_SavedSearches,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
SearchesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_Profile, /* parent */
|
|
SearchesW, /* relative path */
|
|
SavedSearchesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE | KFDF_PUBLISHEXPANDEDPATH, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x64 */
|
|
&FOLDERID_SEARCH_CSC,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
CSCFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SEARCH_CSCParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x65 */
|
|
&FOLDERID_SEARCH_MAPI,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
MAPIFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SEARCH_MAPIParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x66 */
|
|
&FOLDERID_SearchHome,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
SearchHomeFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SearchHomeParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x67 */
|
|
&FOLDERID_SidebarDefaultParts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_COMMON, /* category */
|
|
Default_GadgetsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_ProgramFiles, /* parent */
|
|
Windows_Sidebar_GadgetsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x68 */
|
|
&FOLDERID_SidebarParts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
GadgetsW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
Microsoft_Windows_Sidebar_GadgetsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x69 */
|
|
&FOLDERID_SyncManagerFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
SyncCenterFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SyncManagerFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6a */
|
|
&FOLDERID_SyncResultsFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
SyncResultsFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SyncResultsFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6b */
|
|
&FOLDERID_SyncSetupFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
SyncSetupFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
SyncSetupFolderParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6c */
|
|
&FOLDERID_UserPinned,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
User_PinnedW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_QuickLaunch, /* parent */
|
|
User_PinnedW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_HIDDEN, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6d */
|
|
&FOLDERID_UserProfiles,
|
|
CSIDL_Type_CurrVer,
|
|
UsersW,
|
|
UsersW,
|
|
|
|
KF_CATEGORY_FIXED, /* category */
|
|
UserProfilesW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
FILE_ATTRIBUTE_READONLY, /* attributes */
|
|
KFDF_PRECREATE, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6e */
|
|
&FOLDERID_UserProgramFiles,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
UserProgramFilesW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_LocalAppData, /* parent */
|
|
ProgramsW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x6f */
|
|
&FOLDERID_UserProgramFilesCommon,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
UserProgramFilesCommonW, /* name */
|
|
NULL, /* description */
|
|
&FOLDERID_UserProgramFiles, /* parent */
|
|
CommonW, /* relative path */
|
|
NULL, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x70 */
|
|
&FOLDERID_UsersFiles,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
UsersFilesFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
UsersFilesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x71 */
|
|
&FOLDERID_UsersLibraries,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_VIRTUAL, /* category */
|
|
UsersLibrariesFolderW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
NULL, /* relative path */
|
|
UsersLibrariesParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
},
|
|
{ /* 0x72 */
|
|
&FOLDERID_VideosLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL,
|
|
|
|
KF_CATEGORY_PERUSER, /* category */
|
|
VideosLibraryW, /* name */
|
|
NULL, /* description */
|
|
&GUID_NULL, /* parent */
|
|
Videos_librarymsW, /* relative path */
|
|
VideosLibraryParsingNameW, /* parsing */
|
|
NULL, /* tooltip */
|
|
NULL, /* localized */
|
|
NULL, /* icon */
|
|
NULL, /* security */
|
|
0, /* attributes */
|
|
0, /* flags */
|
|
&GUID_NULL /* typeid */
|
|
}
|
|
};
|
|
|
|
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)
|
|
{
|
|
strcpyW(shellFolderPath, userPrefix);
|
|
PathAddBackslashW(shellFolderPath);
|
|
strcatW(shellFolderPath, szSHFolders);
|
|
pShellFolderPath = shellFolderPath;
|
|
strcpyW(userShellFolderPath, userPrefix);
|
|
PathAddBackslashW(userShellFolderPath);
|
|
strcatW(userShellFolderPath, szSHUserFolders);
|
|
pUserShellFolderPath = userShellFolderPath;
|
|
}
|
|
else
|
|
{
|
|
pUserShellFolderPath = szSHUserFolders;
|
|
pShellFolderPath = szSHFolders;
|
|
}
|
|
|
|
if (RegCreateKeyW(rootKey, pShellFolderPath, &shellFolderKey))
|
|
{
|
|
TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
|
|
return E_FAIL;
|
|
}
|
|
if (RegCreateKeyW(rootKey, pUserShellFolderPath, &userShellFolderKey))
|
|
{
|
|
TRACE("Failed to create %s\n",
|
|
debugstr_w(pUserShellFolderPath));
|
|
RegCloseKey(shellFolderKey);
|
|
return E_FAIL;
|
|
}
|
|
|
|
dwPathLen = MAX_PATH * sizeof(WCHAR);
|
|
if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
|
|
(LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
|
|
{
|
|
LONG ret;
|
|
|
|
path[dwPathLen / sizeof(WCHAR)] = '\0';
|
|
if (dwType == REG_EXPAND_SZ && path[0] == '%')
|
|
{
|
|
WCHAR szTemp[MAX_PATH];
|
|
|
|
_SHExpandEnvironmentStrings(path, szTemp);
|
|
lstrcpynW(path, szTemp, MAX_PATH);
|
|
}
|
|
ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
|
|
(strlenW(path) + 1) * sizeof(WCHAR));
|
|
if (ret != ERROR_SUCCESS)
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
else
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = E_FAIL;
|
|
RegCloseKey(shellFolderKey);
|
|
RegCloseKey(userShellFolderKey);
|
|
TRACE("returning 0x%08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static void append_relative_path(BYTE folder, WCHAR *pszPath)
|
|
{
|
|
if (CSIDL_Data[folder].pszRelativePath)
|
|
{
|
|
PathAddBackslashW(pszPath);
|
|
strcatW(pszPath, CSIDL_Data[folder].pszRelativePath);
|
|
}
|
|
else if (CSIDL_Data[folder].szDefaultPath)
|
|
{
|
|
PathAddBackslashW(pszPath);
|
|
strcatW(pszPath, CSIDL_Data[folder].szDefaultPath);
|
|
}
|
|
}
|
|
|
|
/* 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 (IsEqualGUID(CSIDL_Data[folder].fidParent, &GUID_NULL))
|
|
{
|
|
/* hit the root, sub in env var */
|
|
switch (CSIDL_Data[folder].type)
|
|
{
|
|
case CSIDL_Type_User:
|
|
strcpyW(pszPath, UserProfileW);
|
|
break;
|
|
case CSIDL_Type_AllUsers:
|
|
strcpyW(pszPath, PublicProfileW);
|
|
break;
|
|
case CSIDL_Type_ProgramData:
|
|
strcpyW(pszPath, ProgramDataVarW);
|
|
break;
|
|
case CSIDL_Type_CurrVer:
|
|
strcpyW(pszPath, SystemDriveW);
|
|
break;
|
|
default:
|
|
; /* no corresponding env. var, do nothing */
|
|
}
|
|
hr = S_OK;
|
|
}else{
|
|
/* prepend with parent */
|
|
hr = _SHGetDefaultValue(csidl_from_id(CSIDL_Data[folder].fidParent), pszPath);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
append_relative_path(folder, pszPath);
|
|
|
|
TRACE("returning 0x%08x\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\\szCurrentVersion 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%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
|
|
|
|
if (folder >= ARRAY_SIZE(CSIDL_Data))
|
|
return E_INVALIDARG;
|
|
if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
|
|
return E_INVALIDARG;
|
|
if (!pszPath)
|
|
return E_INVALIDARG;
|
|
|
|
if (dwFlags & SHGFP_TYPE_DEFAULT)
|
|
hr = _SHGetDefaultValue(folder, pszPath);
|
|
else
|
|
{
|
|
HKEY hKey;
|
|
|
|
if (RegCreateKeyW(HKEY_LOCAL_MACHINE, szCurrentVersion, &hKey))
|
|
hr = E_FAIL;
|
|
else
|
|
{
|
|
DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
|
|
|
|
if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
|
|
&dwType, (LPBYTE)pszPath, &dwPathLen) ||
|
|
(dwType != REG_SZ && dwType != REG_EXPAND_SZ))
|
|
{
|
|
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].szValueName, 0, dwType,
|
|
(LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
|
|
hr = S_OK;
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
|
|
return hr;
|
|
}
|
|
|
|
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 = heap_alloc(InfoSize);
|
|
if (UserInfo == NULL)
|
|
return NULL;
|
|
if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
|
|
&InfoSize))
|
|
{
|
|
heap_free(UserInfo);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
|
|
SidStr = NULL;
|
|
|
|
if (UserInfo != (PTOKEN_USER) InfoBuffer)
|
|
heap_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%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
|
|
|
|
if (folder >= ARRAY_SIZE(CSIDL_Data))
|
|
return E_INVALIDARG;
|
|
if (CSIDL_Data[folder].type != CSIDL_Type_User)
|
|
return E_INVALIDARG;
|
|
if (!pszPath)
|
|
return E_INVALIDARG;
|
|
|
|
if (dwFlags & SHGFP_TYPE_DEFAULT)
|
|
{
|
|
if (hToken != NULL && hToken != (HANDLE)-1)
|
|
{
|
|
FIXME("unsupported for user other than current or default\n");
|
|
return E_FAIL;
|
|
}
|
|
hr = _SHGetDefaultValue(folder, pszPath);
|
|
}
|
|
else
|
|
{
|
|
LPCWSTR userPrefix = NULL;
|
|
HKEY hRootKey;
|
|
|
|
if (hToken == (HANDLE)-1)
|
|
{
|
|
hRootKey = HKEY_USERS;
|
|
userPrefix = DefaultW;
|
|
}
|
|
else if (hToken == NULL)
|
|
hRootKey = HKEY_CURRENT_USER;
|
|
else
|
|
{
|
|
hRootKey = HKEY_USERS;
|
|
userPrefix = _GetUserSidStringFromToken(hToken);
|
|
if (userPrefix == NULL)
|
|
{
|
|
hr = E_FAIL;
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* For CSIDL_Type_User we also use the GUID if no szValueName is provided */
|
|
szValueName = CSIDL_Data[folder].szValueName;
|
|
if (!szValueName)
|
|
{
|
|
StringFromGUID2( CSIDL_Data[folder].id, buffer, 39 );
|
|
szValueName = &buffer[0];
|
|
}
|
|
|
|
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%08x (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%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
|
|
|
|
if (folder >= ARRAY_SIZE(CSIDL_Data))
|
|
return E_INVALIDARG;
|
|
if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers && 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].szValueName, pszPath);
|
|
if (FAILED(hr))
|
|
hr = _SHGetDefaultValue(folder, pszPath);
|
|
}
|
|
TRACE("returning 0x%08x (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, ProfileListW, 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,
|
|
(strlenW(szValue) + 1) * sizeof(WCHAR));
|
|
if (lRet)
|
|
hr = HRESULT_FROM_WIN32(lRet);
|
|
else
|
|
hr = S_OK;
|
|
}
|
|
TRACE("returning 0x%08x (output value is %s)\n", hr, debugstr_w(szValue));
|
|
return hr;
|
|
}
|
|
|
|
/* 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] != '%')
|
|
{
|
|
strcpyW(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);
|
|
strcpyW( def_val + 3, szDefaultProfileDirW );
|
|
|
|
hr = _SHGetProfilesValue(key, ProfilesDirectoryW, szProfilesPrefix, def_val );
|
|
}
|
|
|
|
*szDest = 0;
|
|
strcpyW(szTemp, szSrc);
|
|
while (SUCCEEDED(hr) && szTemp[0] == '%')
|
|
{
|
|
if (!strncmpiW(szTemp, AllUsersProfileW, strlenW(AllUsersProfileW)))
|
|
{
|
|
WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
|
|
|
|
GetSystemDirectoryW(def_val, MAX_PATH);
|
|
strcpyW( def_val + 3, UsersPublicW );
|
|
|
|
hr = _SHGetProfilesValue(key, PublicW, szAllUsers, def_val);
|
|
PathAppendW(szDest, szAllUsers);
|
|
PathAppendW(szDest, szTemp + strlenW(AllUsersProfileW));
|
|
}
|
|
else if (!strncmpiW(szTemp, PublicProfileW, strlenW(PublicProfileW)))
|
|
{
|
|
WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
|
|
|
|
GetSystemDirectoryW(def_val, MAX_PATH);
|
|
strcpyW( def_val + 3, UsersPublicW );
|
|
|
|
hr = _SHGetProfilesValue(key, PublicW, szAllUsers, def_val);
|
|
PathAppendW(szDest, szAllUsers);
|
|
PathAppendW(szDest, szTemp + strlenW(PublicProfileW));
|
|
}
|
|
else if (!strncmpiW(szTemp, ProgramDataVarW, strlenW(ProgramDataVarW)))
|
|
{
|
|
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, szSHFolders, &shellFolderKey))
|
|
{
|
|
if (!RegQueryValueExW(shellFolderKey, Common_AppDataW, 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);
|
|
strcpyW( def_val + 3, ProgramDataW );
|
|
}
|
|
|
|
hr = _SHGetProfilesValue(key, ProgramDataW, szProgramData, def_val);
|
|
PathAppendW(szDest, szProgramData);
|
|
PathAppendW(szDest, szTemp + strlenW(ProgramDataVarW));
|
|
}
|
|
else if (!strncmpiW(szTemp, UserProfileW, strlenW(UserProfileW)))
|
|
{
|
|
WCHAR userName[MAX_PATH];
|
|
DWORD userLen = MAX_PATH;
|
|
|
|
strcpyW(szDest, szProfilesPrefix);
|
|
GetUserNameW(userName, &userLen);
|
|
PathAppendW(szDest, userName);
|
|
PathAppendW(szDest, szTemp + strlenW(UserProfileW));
|
|
}
|
|
else if (!strncmpiW(szTemp, SystemDriveW, strlenW(SystemDriveW)))
|
|
{
|
|
GetSystemDirectoryW(szDest, MAX_PATH);
|
|
strcpyW(szDest + 3, szTemp + strlenW(SystemDriveW) + 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 (!strcmpW( szTemp, szDest )) break; /* nothing expanded */
|
|
}
|
|
if (SUCCEEDED(hr)) strcpyW(szTemp, szDest);
|
|
}
|
|
end:
|
|
if (key)
|
|
RegCloseKey(key);
|
|
TRACE("returning 0x%08x (input was %s, output is %s)\n", hr,
|
|
debugstr_w(szSrc), debugstr_w(szDest));
|
|
return hr;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* _SHGetXDGUserDirs [Internal]
|
|
*
|
|
* Get XDG directories paths from XDG configuration.
|
|
*
|
|
* PARAMS
|
|
* xdg_dirs [I] Array of XDG directories to look for.
|
|
* num_dirs [I] Number of elements in xdg_dirs.
|
|
* xdg_results [O] An array of the XDG directories paths.
|
|
*/
|
|
static inline void _SHGetXDGUserDirs(const char * const *xdg_dirs, const unsigned int num_dirs, char *** xdg_results) {
|
|
HRESULT hr;
|
|
|
|
hr = XDG_UserDirLookup(xdg_dirs, num_dirs, xdg_results);
|
|
if (FAILED(hr)) *xdg_results = NULL;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* _SHFreeXDGUserDirs [Internal]
|
|
*
|
|
* Free resources allocated by XDG_UserDirLookup().
|
|
*
|
|
* PARAMS
|
|
* num_dirs [I] Number of elements in xdg_results.
|
|
* xdg_results [I] An array of the XDG directories paths.
|
|
*/
|
|
static inline void _SHFreeXDGUserDirs(const unsigned int num_dirs, char ** xdg_results) {
|
|
UINT i;
|
|
|
|
if (xdg_results)
|
|
{
|
|
for (i = 0; i < num_dirs; i++)
|
|
heap_free(xdg_results[i]);
|
|
heap_free(xdg_results);
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
* _SHAppendToUnixPath [Internal]
|
|
*
|
|
* Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
|
|
* corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
|
|
* and replaces backslashes with slashes.
|
|
*
|
|
* PARAMS
|
|
* szBasePath [IO] The unix base path, which will be appended to (CP_UNXICP).
|
|
* pwszSubPath [I] Sub-path or resource id (use MAKEINTRESOURCEW).
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE,
|
|
* Failure: FALSE
|
|
*/
|
|
static inline BOOL _SHAppendToUnixPath(char *szBasePath, LPCWSTR pwszSubPath) {
|
|
WCHAR wszSubPath[MAX_PATH];
|
|
int cLen = strlen(szBasePath);
|
|
char *pBackslash;
|
|
|
|
if (IS_INTRESOURCE(pwszSubPath)) {
|
|
if (!LoadStringW(shell32_hInstance, LOWORD(pwszSubPath), wszSubPath, MAX_PATH)) {
|
|
/* Fall back to hard coded defaults. */
|
|
switch (LOWORD(pwszSubPath)) {
|
|
case IDS_PERSONAL:
|
|
lstrcpyW(wszSubPath, DocumentsW);
|
|
break;
|
|
case IDS_MYMUSIC:
|
|
lstrcpyW(wszSubPath, My_MusicW);
|
|
break;
|
|
case IDS_MYPICTURES:
|
|
lstrcpyW(wszSubPath, My_PicturesW);
|
|
break;
|
|
case IDS_MYVIDEOS:
|
|
lstrcpyW(wszSubPath, My_VideosW);
|
|
break;
|
|
case IDS_DOWNLOADS:
|
|
lstrcpyW(wszSubPath, DownloadsW);
|
|
break;
|
|
case IDS_TEMPLATES:
|
|
lstrcpyW(wszSubPath, TemplatesW);
|
|
break;
|
|
default:
|
|
ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath));
|
|
return FALSE;
|
|
}
|
|
}
|
|
} else {
|
|
lstrcpyW(wszSubPath, pwszSubPath);
|
|
}
|
|
|
|
if (szBasePath[cLen-1] != '/') szBasePath[cLen++] = '/';
|
|
|
|
if (!WideCharToMultiByte(CP_UNIXCP, 0, wszSubPath, -1, szBasePath + cLen,
|
|
FILENAME_MAX - cLen, NULL, NULL))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
pBackslash = szBasePath + cLen;
|
|
while ((pBackslash = strchr(pBackslash, '\\'))) *pBackslash = '/';
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHGetFolderUnixPath [Internal]
|
|
*
|
|
* Create a shell folder and get its unix path.
|
|
*
|
|
* PARAMS
|
|
* nFolder [I] CSIDL identifying the folder.
|
|
*/
|
|
static inline char * _SHGetFolderUnixPath(const int nFolder)
|
|
{
|
|
WCHAR wszTempPath[MAX_PATH];
|
|
HRESULT hr;
|
|
|
|
hr = SHGetFolderPathW(NULL, nFolder, NULL,
|
|
SHGFP_TYPE_CURRENT, wszTempPath);
|
|
if (FAILED(hr)) return NULL;
|
|
|
|
return wine_get_unix_file_name(wszTempPath);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHCreateMyDocumentsSubDirs [Internal]
|
|
*
|
|
* Create real directories for various shell folders under 'My Documents'. For
|
|
* Windows and homeless styles. Fails silently for already existing sub dirs.
|
|
*
|
|
* PARAMS
|
|
* aidsMyStuff [I] Array of IDS_* resources to create sub dirs for.
|
|
* num [I] Number of elements in aidsMyStuff.
|
|
* szPersonalTarget [I] Unix path to 'My Documents' directory.
|
|
*/
|
|
static void _SHCreateMyDocumentsSubDirs(const UINT * aidsMyStuff, const UINT num, const char * szPersonalTarget)
|
|
{
|
|
char szMyStuffTarget[FILENAME_MAX];
|
|
UINT i;
|
|
|
|
if (aidsMyStuff && szPersonalTarget)
|
|
{
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
strcpy(szMyStuffTarget, szPersonalTarget);
|
|
if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
|
|
mkdir(szMyStuffTarget, 0777);
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHCreateMyDocumentsSymbolicLink [Internal]
|
|
*
|
|
* Sets up a symbolic link for the 'My Documents' shell folder to point into
|
|
* the users home directory.
|
|
*
|
|
* PARAMS
|
|
* aidsMyStuff [I] Array of IDS_* resources to create sub dirs for.
|
|
* aids_num [I] Number of elements in aidsMyStuff.
|
|
*/
|
|
static void _SHCreateMyDocumentsSymbolicLink(const UINT * aidsMyStuff, const UINT aids_num)
|
|
{
|
|
static const char * const xdg_dirs[] = { "DOCUMENTS" };
|
|
static const unsigned int num = ARRAY_SIZE(xdg_dirs);
|
|
char szPersonalTarget[FILENAME_MAX], *pszPersonal;
|
|
struct stat statFolder;
|
|
const char *pszHome;
|
|
char ** xdg_results;
|
|
|
|
/* Get the unix path of 'My Documents'. */
|
|
pszPersonal = _SHGetFolderUnixPath(CSIDL_PERSONAL|CSIDL_FLAG_DONT_VERIFY);
|
|
if (!pszPersonal) return;
|
|
|
|
_SHGetXDGUserDirs(xdg_dirs, num, &xdg_results);
|
|
|
|
pszHome = getenv("HOME");
|
|
if (pszHome && !stat(pszHome, &statFolder) && S_ISDIR(statFolder.st_mode))
|
|
{
|
|
while (1)
|
|
{
|
|
/* Check if there's already a Wine-specific 'My Documents' folder */
|
|
strcpy(szPersonalTarget, pszHome);
|
|
if (_SHAppendToUnixPath(szPersonalTarget, MAKEINTRESOURCEW(IDS_PERSONAL)) &&
|
|
!stat(szPersonalTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
|
|
{
|
|
/* '$HOME/My Documents' exists. Create subfolders for
|
|
* 'My Pictures', 'My Videos', 'My Music' etc. or fail silently
|
|
* if they already exist.
|
|
*/
|
|
_SHCreateMyDocumentsSubDirs(aidsMyStuff, aids_num, szPersonalTarget);
|
|
break;
|
|
}
|
|
|
|
/* Try to point to the XDG Documents folder */
|
|
if (xdg_results && xdg_results[0] &&
|
|
!stat(xdg_results[0], &statFolder) &&
|
|
S_ISDIR(statFolder.st_mode))
|
|
{
|
|
strcpy(szPersonalTarget, xdg_results[0]);
|
|
break;
|
|
}
|
|
|
|
/* Or the hardcoded / OS X Documents folder */
|
|
strcpy(szPersonalTarget, pszHome);
|
|
if (_SHAppendToUnixPath(szPersonalTarget, DocumentsW) &&
|
|
!stat(szPersonalTarget, &statFolder) &&
|
|
S_ISDIR(statFolder.st_mode))
|
|
break;
|
|
|
|
/* As a last resort point to $HOME. */
|
|
strcpy(szPersonalTarget, pszHome);
|
|
break;
|
|
}
|
|
|
|
/* Create symbolic link to 'My Documents' or fail silently if a directory
|
|
* or symlink exists. */
|
|
symlink(szPersonalTarget, pszPersonal);
|
|
}
|
|
else
|
|
{
|
|
/* '$HOME' doesn't exist. Create subdirs for 'My Pictures', 'My Videos',
|
|
* 'My Music' etc. in '%USERPROFILE%\My Documents' or fail silently if
|
|
* they already exist. */
|
|
pszHome = NULL;
|
|
strcpy(szPersonalTarget, pszPersonal);
|
|
_SHCreateMyDocumentsSubDirs(aidsMyStuff, aids_num, szPersonalTarget);
|
|
}
|
|
|
|
heap_free(pszPersonal);
|
|
|
|
_SHFreeXDGUserDirs(num, xdg_results);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHCreateMyStuffSymbolicLink [Internal]
|
|
*
|
|
* Sets up a symbolic link for one of the 'My Whatever' shell folders to point
|
|
* into the users home directory.
|
|
*
|
|
* PARAMS
|
|
* nFolder [I] CSIDL identifying the folder.
|
|
*/
|
|
static void _SHCreateMyStuffSymbolicLink(int nFolder)
|
|
{
|
|
static const UINT aidsMyStuff[] = {
|
|
IDS_MYPICTURES, IDS_MYVIDEOS, IDS_MYMUSIC, IDS_DOWNLOADS, IDS_TEMPLATES
|
|
};
|
|
static const WCHAR * const MyOSXStuffW[] = {
|
|
PicturesW, MoviesW, MusicW, DownloadsW, TemplatesW
|
|
};
|
|
static const int acsidlMyStuff[] = {
|
|
CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC, CSIDL_DOWNLOADS, CSIDL_TEMPLATES
|
|
};
|
|
static const char * const xdg_dirs[] = {
|
|
"PICTURES", "VIDEOS", "MUSIC", "DOWNLOAD", "TEMPLATES"
|
|
};
|
|
static const unsigned int num = ARRAY_SIZE(xdg_dirs);
|
|
char szPersonalTarget[FILENAME_MAX], *pszPersonal;
|
|
char szMyStuffTarget[FILENAME_MAX], *pszMyStuff;
|
|
struct stat statFolder;
|
|
const char *pszHome;
|
|
char ** xdg_results;
|
|
DWORD folder = nFolder & CSIDL_FOLDER_MASK;
|
|
UINT i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(acsidlMyStuff) && acsidlMyStuff[i] != folder; i++);
|
|
if (i >= ARRAY_SIZE(acsidlMyStuff)) return;
|
|
|
|
/* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
|
|
pszPersonal = _SHGetFolderUnixPath(CSIDL_PERSONAL|CSIDL_FLAG_CREATE);
|
|
if (!pszPersonal) return;
|
|
|
|
strcpy(szPersonalTarget, pszPersonal);
|
|
if (!stat(pszPersonal, &statFolder) && S_ISLNK(statFolder.st_mode))
|
|
{
|
|
int cLen = readlink(pszPersonal, szPersonalTarget, FILENAME_MAX-1);
|
|
if (cLen >= 0) szPersonalTarget[cLen] = '\0';
|
|
}
|
|
heap_free(pszPersonal);
|
|
|
|
_SHGetXDGUserDirs(xdg_dirs, num, &xdg_results);
|
|
|
|
pszHome = getenv("HOME");
|
|
|
|
while (1)
|
|
{
|
|
/* Get the current 'My Whatever' folder unix path. */
|
|
pszMyStuff = _SHGetFolderUnixPath(acsidlMyStuff[i]|CSIDL_FLAG_DONT_VERIFY);
|
|
if (!pszMyStuff) break;
|
|
|
|
while (1)
|
|
{
|
|
/* Check for the Wine-specific '$HOME/My Documents' subfolder */
|
|
strcpy(szMyStuffTarget, szPersonalTarget);
|
|
if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])) &&
|
|
!stat(szMyStuffTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
|
|
break;
|
|
|
|
/* Try the XDG_XXX_DIR folder */
|
|
if (xdg_results && xdg_results[i])
|
|
{
|
|
strcpy(szMyStuffTarget, xdg_results[i]);
|
|
break;
|
|
}
|
|
|
|
/* Or the OS X folder (these are never localized) */
|
|
if (pszHome)
|
|
{
|
|
strcpy(szMyStuffTarget, pszHome);
|
|
if (_SHAppendToUnixPath(szMyStuffTarget, MyOSXStuffW[i]) &&
|
|
!stat(szMyStuffTarget, &statFolder) &&
|
|
S_ISDIR(statFolder.st_mode))
|
|
break;
|
|
}
|
|
|
|
/* As a last resort point to the same location as 'My Documents' */
|
|
strcpy(szMyStuffTarget, szPersonalTarget);
|
|
break;
|
|
}
|
|
symlink(szMyStuffTarget, pszMyStuff);
|
|
heap_free(pszMyStuff);
|
|
break;
|
|
}
|
|
|
|
_SHFreeXDGUserDirs(num, xdg_results);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHCreateDesktopSymbolicLink [Internal]
|
|
*
|
|
* Sets up a symbolic link for the 'Desktop' shell folder to point into the
|
|
* users home directory.
|
|
*/
|
|
static void _SHCreateDesktopSymbolicLink(void)
|
|
{
|
|
static const char * const xdg_dirs[] = { "DESKTOP" };
|
|
static const unsigned int num = ARRAY_SIZE(xdg_dirs);
|
|
char *pszPersonal;
|
|
char szDesktopTarget[FILENAME_MAX], *pszDesktop;
|
|
struct stat statFolder;
|
|
const char *pszHome;
|
|
char ** xdg_results;
|
|
char * xdg_desktop_dir;
|
|
|
|
/* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
|
|
pszPersonal = _SHGetFolderUnixPath(CSIDL_PERSONAL|CSIDL_FLAG_CREATE);
|
|
if (!pszPersonal) return;
|
|
|
|
_SHGetXDGUserDirs(xdg_dirs, num, &xdg_results);
|
|
|
|
pszHome = getenv("HOME");
|
|
|
|
if (pszHome)
|
|
strcpy(szDesktopTarget, pszHome);
|
|
else
|
|
strcpy(szDesktopTarget, pszPersonal);
|
|
heap_free(pszPersonal);
|
|
|
|
xdg_desktop_dir = xdg_results ? xdg_results[0] : NULL;
|
|
if (xdg_desktop_dir ||
|
|
(_SHAppendToUnixPath(szDesktopTarget, DesktopW) &&
|
|
!stat(szDesktopTarget, &statFolder) && S_ISDIR(statFolder.st_mode)))
|
|
{
|
|
pszDesktop = _SHGetFolderUnixPath(CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_DONT_VERIFY);
|
|
if (pszDesktop)
|
|
{
|
|
if (xdg_desktop_dir)
|
|
symlink(xdg_desktop_dir, pszDesktop);
|
|
else
|
|
symlink(szDesktopTarget, pszDesktop);
|
|
heap_free(pszDesktop);
|
|
}
|
|
}
|
|
|
|
_SHFreeXDGUserDirs(num, xdg_results);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _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)
|
|
{
|
|
static const UINT aidsMyStuff[] = {
|
|
IDS_MYPICTURES, IDS_MYVIDEOS, IDS_MYMUSIC, IDS_DOWNLOADS, IDS_TEMPLATES
|
|
};
|
|
DWORD folder = nFolder & CSIDL_FOLDER_MASK;
|
|
|
|
switch (folder) {
|
|
case CSIDL_PERSONAL:
|
|
_SHCreateMyDocumentsSymbolicLink(aidsMyStuff, ARRAY_SIZE(aidsMyStuff));
|
|
break;
|
|
case CSIDL_MYPICTURES:
|
|
case CSIDL_MYVIDEO:
|
|
case CSIDL_MYMUSIC:
|
|
case CSIDL_DOWNLOADS:
|
|
case CSIDL_TEMPLATES:
|
|
_SHCreateMyStuffSymbolicLink(folder);
|
|
break;
|
|
case CSIDL_DESKTOPDIRECTORY:
|
|
_SHCreateDesktopSymbolicLink();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* _SHCreateSymbolicLinks [Internal]
|
|
*
|
|
* Sets up symbol links for various shell folders to point into the user's home
|
|
* directory. We do an educated guess about what the user would probably want:
|
|
* - If there is a 'My Documents' directory in $HOME, the user probably wants
|
|
* wine's 'My Documents' to point there. Furthermore, we infer that the user
|
|
* is a Windows lover and has no problem with wine creating subfolders for
|
|
* 'My Pictures', 'My Music', 'My Videos' etc. under '$HOME/My Documents', if
|
|
* those do not already exist. We put appropriate symbolic links in place for
|
|
* those, too.
|
|
* - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
|
|
* point directly to $HOME. We assume the user to be a unix hacker who does not
|
|
* want wine to create anything anywhere besides the .wine directory. So, if
|
|
* there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
|
|
* shell folder to it. But if not, then we check XDG_MUSIC_DIR - "well known"
|
|
* directory, and try to link to that. If that fails, then we symlink to
|
|
* $HOME directly. The same holds for 'My Pictures', 'My Videos' etc.
|
|
* - The Desktop shell folder is symlinked to XDG_DESKTOP_DIR. If that does not
|
|
* exist, then we try '$HOME/Desktop'. If that does not exist, then we leave
|
|
* it alone.
|
|
* ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
|
|
*/
|
|
static void _SHCreateSymbolicLinks(void)
|
|
{
|
|
static const int acsidlMyStuff[] = {
|
|
CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC, CSIDL_DOWNLOADS, CSIDL_TEMPLATES, CSIDL_PERSONAL, CSIDL_DESKTOPDIRECTORY
|
|
};
|
|
UINT i;
|
|
|
|
for (i=0; i < ARRAY_SIZE(acsidlMyStuff); i++)
|
|
_SHCreateSymbolicLink(acsidlMyStuff[i]);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* 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,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_a(pszSubPath), pszPath);
|
|
|
|
if(pszPath) {
|
|
pszPathW = heap_alloc(MAX_PATH * sizeof(WCHAR));
|
|
if(!pszPathW) {
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
goto cleanup;
|
|
}
|
|
}
|
|
TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
|
|
|
|
/* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
|
|
* set (null), or an empty string.therefore call it without the parameter set
|
|
* if pszSubPath is an empty string
|
|
*/
|
|
if (pszSubPath && pszSubPath[0]) {
|
|
length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
|
|
pszSubPathW = heap_alloc(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:
|
|
heap_free(pszPathW);
|
|
heap_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,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_w(pszSubPath), pszPath);
|
|
|
|
/* Windows always NULL-terminates the resulting path regardless of success
|
|
* or failure, so do so first
|
|
*/
|
|
if (pszPath)
|
|
*pszPath = '\0';
|
|
|
|
if (folder >= ARRAY_SIZE(CSIDL_Data))
|
|
return E_INVALIDARG;
|
|
if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
|
|
return E_INVALIDARG;
|
|
szTemp[0] = 0;
|
|
type = CSIDL_Data[folder].type;
|
|
switch (type)
|
|
{
|
|
case CSIDL_Type_Disallowed:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
case CSIDL_Type_NonExistent:
|
|
hr = S_FALSE;
|
|
break;
|
|
case CSIDL_Type_WindowsPath:
|
|
GetWindowsDirectoryW(szTemp, MAX_PATH);
|
|
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
|
|
strcpyW(szBuildPath, szTemp);
|
|
|
|
if (FAILED(hr)) goto end;
|
|
|
|
if(pszSubPath) {
|
|
/* make sure the new path does not exceed the buffer length
|
|
* and remember to backslash and terminate it */
|
|
if(MAX_PATH < (lstrlenW(szBuildPath) + lstrlenW(pszSubPath) + 2)) {
|
|
hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
|
|
goto end;
|
|
}
|
|
PathAppendW(szBuildPath, pszSubPath);
|
|
PathRemoveBackslashW(szBuildPath);
|
|
}
|
|
/* Copy the path if it's available before we might return */
|
|
if (SUCCEEDED(hr) && pszPath)
|
|
strcpyW(pszPath, szBuildPath);
|
|
|
|
/* if we don't care about existing directories we are ready */
|
|
if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
|
|
|
|
if (PathFileExistsW(szBuildPath)) goto end;
|
|
|
|
/* not existing but we are not allowed to create it. The return value
|
|
* is verified against shell32 version 6.0.
|
|
*/
|
|
if (!(nFolder & CSIDL_FLAG_CREATE))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
|
|
goto end;
|
|
}
|
|
|
|
/* create symbolic links rather than directories for specific
|
|
* user shell folders */
|
|
_SHCreateSymbolicLink(folder);
|
|
|
|
/* 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%08x (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,%#x,%p\n", hwndOwner, nFolder, hToken, dwFlags, pszPath);
|
|
|
|
if (pszPath)
|
|
*pszPath = '\0';
|
|
hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
|
|
if (SUCCEEDED(hr) && pszPath)
|
|
WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
|
|
NULL);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/* 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]].szValueName;
|
|
if (!szValueName && CSIDL_Data[folders[i]].type == CSIDL_Type_User)
|
|
{
|
|
StringFromGUID2( CSIDL_Data[folders[i]].id, buffer, 39 );
|
|
szValueName = &buffer[0];
|
|
}
|
|
|
|
if (RegQueryValueExW(hUserKey, szValueName, NULL,
|
|
&dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
|
|
dwType != REG_EXPAND_SZ))
|
|
{
|
|
*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, (strlenW(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, (strlenW(path) + 1) * sizeof(WCHAR));
|
|
if (ret)
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (hUserKey)
|
|
RegCloseKey(hUserKey);
|
|
if (hKey)
|
|
RegCloseKey(hKey);
|
|
|
|
TRACE("returning 0x%08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
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;
|
|
strcpyW(userShellFolderPath, DefaultW);
|
|
PathAddBackslashW(userShellFolderPath);
|
|
strcatW(userShellFolderPath, szSHUserFolders);
|
|
pUserShellFolderPath = userShellFolderPath;
|
|
strcpyW(shellFolderPath, DefaultW);
|
|
PathAddBackslashW(shellFolderPath);
|
|
strcatW(shellFolderPath, szSHFolders);
|
|
pShellFolderPath = shellFolderPath;
|
|
}
|
|
else
|
|
{
|
|
hToken = NULL;
|
|
hRootKey = HKEY_CURRENT_USER;
|
|
pUserShellFolderPath = szSHUserFolders;
|
|
pShellFolderPath = szSHFolders;
|
|
}
|
|
|
|
hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
|
|
pShellFolderPath, folders, ARRAY_SIZE(folders));
|
|
TRACE("returning 0x%08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
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, szSHUserFolders,
|
|
szSHFolders, folders, ARRAY_SIZE(folders));
|
|
TRACE("returning 0x%08x\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)
|
|
{
|
|
static const WCHAR environW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
|
|
static const WCHAR microsoftW[] = {'M','i','c','r','o','s','o','f','t',0};
|
|
static const WCHAR TempW[] = {'T','e','m','p',0};
|
|
static const WCHAR TEMPW[] = {'T','E','M','P',0};
|
|
static const WCHAR TMPW[] = {'T','M','P',0};
|
|
WCHAR path[MAX_PATH+5];
|
|
HRESULT hr;
|
|
HKEY hkey;
|
|
DWORD type, size, ret;
|
|
|
|
ret = RegCreateKeyW( HKEY_CURRENT_USER, environW, &hkey );
|
|
if (ret) return HRESULT_FROM_WIN32( ret );
|
|
|
|
/* FIXME: should be under AppData, but we don't want spaces in the temp path */
|
|
hr = SHGetFolderPathAndSubDirW( 0, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL,
|
|
SHGFP_TYPE_DEFAULT, TempW, path );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
size = sizeof(path);
|
|
if (RegQueryValueExW( hkey, TEMPW, NULL, &type, (LPBYTE)path, &size ))
|
|
RegSetValueExW( hkey, TEMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
|
|
size = sizeof(path);
|
|
if (RegQueryValueExW( hkey, TMPW, NULL, &type, (LPBYTE)path, &size ))
|
|
RegSetValueExW( hkey, TMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
|
|
}
|
|
RegCloseKey( hkey );
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHGetFolderPathAndSubDirW( 0, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL,
|
|
SHGFP_TYPE_DEFAULT, microsoftW, path );
|
|
}
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL,
|
|
SHGFP_TYPE_DEFAULT, Microsoft_Windows_ThemesW, path);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* set_folder_attributes
|
|
*
|
|
* Set the various folder attributes registry keys.
|
|
*/
|
|
static HRESULT set_folder_attributes(void)
|
|
{
|
|
static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0 };
|
|
static const WCHAR shellfolderW[] = {'\\','S','h','e','l','l','F','o','l','d','e','r', 0 };
|
|
static const WCHAR wfparsingW[] = {'W','a','n','t','s','F','O','R','P','A','R','S','I','N','G',0};
|
|
static const WCHAR wfdisplayW[] = {'W','a','n','t','s','F','O','R','D','I','S','P','L','A','Y',0};
|
|
static const WCHAR hideasdeleteW[] = {'H','i','d','e','A','s','D','e','l','e','t','e','P','e','r','U','s','e','r',0};
|
|
static const WCHAR cfattributesW[] = {'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0};
|
|
static const WCHAR emptyW[] = {0};
|
|
|
|
static const struct
|
|
{
|
|
const CLSID *clsid;
|
|
BOOL wfparsing : 1;
|
|
BOOL wfdisplay : 1;
|
|
BOOL 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 }
|
|
};
|
|
|
|
unsigned int i;
|
|
WCHAR buffer[39 + ARRAY_SIZE(clsidW) + ARRAY_SIZE(shellfolderW)];
|
|
LONG res;
|
|
HKEY hkey;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(folders); i++)
|
|
{
|
|
strcpyW( buffer, clsidW );
|
|
StringFromGUID2( folders[i].clsid, buffer + strlenW(buffer), 39 );
|
|
strcatW( buffer, shellfolderW );
|
|
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, wfparsingW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
|
|
if (folders[i].wfdisplay)
|
|
res = RegSetValueExW( hkey, wfdisplayW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
|
|
if (folders[i].hideasdel)
|
|
res = RegSetValueExW( hkey, hideasdeleteW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
|
|
if (folders[i].attr)
|
|
res = RegSetValueExW( hkey, szAttributes, 0, REG_DWORD,
|
|
(const BYTE *)&folders[i].attr, sizeof(DWORD));
|
|
if (folders[i].call_for_attr)
|
|
res = RegSetValueExW( hkey, cfattributesW, 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%08x %p\n",
|
|
hwndOwner, nFolder, hToken, dwReserved, ppidl);
|
|
|
|
if (!ppidl)
|
|
return E_INVALIDARG;
|
|
if (dwReserved)
|
|
return E_INVALIDARG;
|
|
|
|
/* The virtual folders' locations are not user-dependent */
|
|
*ppidl = NULL;
|
|
switch (nFolder & CSIDL_FOLDER_MASK)
|
|
{
|
|
case CSIDL_DESKTOP:
|
|
*ppidl = _ILCreateDesktop();
|
|
break;
|
|
|
|
case CSIDL_PERSONAL:
|
|
*ppidl = _ILCreateMyDocuments();
|
|
break;
|
|
|
|
case CSIDL_INTERNET:
|
|
*ppidl = _ILCreateIExplore();
|
|
break;
|
|
|
|
case CSIDL_CONTROLS:
|
|
*ppidl = _ILCreateControlPanel();
|
|
break;
|
|
|
|
case CSIDL_PRINTERS:
|
|
*ppidl = _ILCreatePrinters();
|
|
break;
|
|
|
|
case CSIDL_BITBUCKET:
|
|
*ppidl = _ILCreateBitBucket();
|
|
break;
|
|
|
|
case CSIDL_DRIVES:
|
|
*ppidl = _ILCreateMyComputer();
|
|
break;
|
|
|
|
case CSIDL_NETWORK:
|
|
*ppidl = _ILCreateNetwork();
|
|
break;
|
|
|
|
default:
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
|
|
hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
|
|
SHGFP_TYPE_CURRENT, szPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD attributes=0;
|
|
|
|
TRACE("Value=%s\n", debugstr_w(szPath));
|
|
hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
|
|
}
|
|
else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
|
|
{
|
|
/* unlike SHGetFolderPath, SHGetFolderLocation in shell32
|
|
* version 6.0 returns E_FAIL for nonexistent paths
|
|
*/
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
if(*ppidl)
|
|
hr = S_OK;
|
|
|
|
TRACE("-- (new pidl %p)\n",*ppidl);
|
|
return hr;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* 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], tempW[MAX_PATH];
|
|
HRESULT hr;
|
|
CSIDL_Type type;
|
|
int ret;
|
|
int folder = csidl_from_id(rfid), shgfp_flags;
|
|
|
|
TRACE("%s, 0x%08x, %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))
|
|
{
|
|
FIXME("flags 0x%08x not supported\n", flags);
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
shgfp_flags = flags & KF_FLAG_DEFAULT_PATH ? SHGFP_TYPE_DEFAULT : SHGFP_TYPE_CURRENT;
|
|
|
|
type = CSIDL_Data[folder].type;
|
|
switch (type)
|
|
{
|
|
case CSIDL_Type_Disallowed:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
case CSIDL_Type_NonExistent:
|
|
*tempW = 0;
|
|
hr = S_FALSE;
|
|
break;
|
|
case CSIDL_Type_WindowsPath:
|
|
GetWindowsDirectoryW(tempW, MAX_PATH);
|
|
append_relative_path(folder, tempW);
|
|
hr = S_OK;
|
|
break;
|
|
case CSIDL_Type_SystemPath:
|
|
GetSystemDirectoryW(tempW, MAX_PATH);
|
|
append_relative_path(folder, tempW);
|
|
hr = S_OK;
|
|
break;
|
|
case CSIDL_Type_SystemX86Path:
|
|
if (!GetSystemWow64DirectoryW(tempW, MAX_PATH)) GetSystemDirectoryW(tempW, MAX_PATH);
|
|
append_relative_path(folder, tempW);
|
|
hr = S_OK;
|
|
break;
|
|
case CSIDL_Type_CurrVer:
|
|
hr = _SHGetCurrentVersionPath(shgfp_flags, folder, tempW);
|
|
break;
|
|
case CSIDL_Type_User:
|
|
hr = _SHGetUserProfilePath(token, shgfp_flags, folder, tempW);
|
|
break;
|
|
case CSIDL_Type_AllUsers:
|
|
case CSIDL_Type_ProgramData:
|
|
hr = _SHGetAllUsersProfilePath(shgfp_flags, folder, tempW);
|
|
break;
|
|
default:
|
|
FIXME("bogus type %d, please fix\n", type);
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
goto failed;
|
|
|
|
/* Expand environment strings if necessary */
|
|
if (*tempW == '%')
|
|
{
|
|
hr = _SHExpandEnvironmentStrings(tempW, pathW);
|
|
if (FAILED(hr))
|
|
goto failed;
|
|
}
|
|
else
|
|
strcpyW(pathW, tempW);
|
|
|
|
/* if we don't care about existing directories we are ready */
|
|
if (flags & KF_FLAG_DONT_VERIFY) goto done;
|
|
|
|
if (PathFileExistsW(pathW)) goto done;
|
|
|
|
/* Does not exist but we are not allowed to create it. The return value
|
|
* is verified against shell32 version 6.0.
|
|
*/
|
|
if (!(flags & KF_FLAG_CREATE))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
|
|
goto failed;
|
|
}
|
|
|
|
/* create symbolic links rather than directories for specific
|
|
* user shell folders */
|
|
_SHCreateSymbolicLink(folder);
|
|
|
|
/* create directory/directories */
|
|
ret = SHCreateDirectoryExW(NULL, pathW, NULL);
|
|
if (ret && ret != ERROR_ALREADY_EXISTS)
|
|
{
|
|
ERR("Failed to create directory %s.\n", debugstr_w(pathW));
|
|
hr = E_FAIL;
|
|
goto failed;
|
|
}
|
|
|
|
TRACE("Created missing system directory %s\n", debugstr_w(pathW));
|
|
|
|
done:
|
|
TRACE("Final path is %s, %#x\n", debugstr_w(pathW), hr);
|
|
|
|
*ret_path = CoTaskMemAlloc((strlenW(pathW) + 1) * sizeof(WCHAR));
|
|
if (!*ret_path)
|
|
return E_OUTOFMEMORY;
|
|
strcpyW(*ret_path, pathW);
|
|
|
|
return hr;
|
|
|
|
failed:
|
|
TRACE("Failed to get folder path, %#x.\n", hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetFolderPathEx [SHELL32.@]
|
|
*/
|
|
HRESULT WINAPI SHGetFolderPathEx(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, LPWSTR path, DWORD len)
|
|
{
|
|
HRESULT hr;
|
|
WCHAR *buffer;
|
|
|
|
TRACE("%s, 0x%08x, %p, %p, %u\n", debugstr_guid(rfid), flags, token, path, len);
|
|
|
|
if (!path || !len) return E_INVALIDARG;
|
|
|
|
hr = SHGetKnownFolderPath( rfid, flags, token, &buffer );
|
|
if (SUCCEEDED( hr ))
|
|
{
|
|
if (strlenW( buffer ) + 1 > len)
|
|
{
|
|
CoTaskMemFree( buffer );
|
|
return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
|
|
}
|
|
strcpyW( 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)
|
|
{
|
|
static const WCHAR sBackslash[] = {'\\',0};
|
|
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(szKnownFolderDescriptions)+51;
|
|
*lpPath = heap_alloc(length*sizeof(WCHAR));
|
|
if(!(*lpPath))
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
lstrcpyW(*lpPath, szKnownFolderDescriptions);
|
|
lstrcatW(*lpPath, sBackslash);
|
|
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.
|
|
* However, besides root key, path is always that same, and is stored
|
|
* as "szKnownFolderRedirections" constant
|
|
*/
|
|
static HRESULT get_known_folder_redirection_place(
|
|
REFKNOWNFOLDERID rfid,
|
|
HKEY *rootKey)
|
|
{
|
|
HRESULT hr;
|
|
LPWSTR lpRegistryPath = NULL;
|
|
KF_CATEGORY 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, szCategory, &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;
|
|
}
|
|
|
|
heap_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);
|
|
|
|
heap_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, szKnownFolderRedirections, 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) )
|
|
{
|
|
static const WCHAR sWildcard[] = {'\\','*',0};
|
|
WCHAR srcPath[MAX_PATH+1], dstPath[MAX_PATH+1];
|
|
SHFILEOPSTRUCTW fileOp;
|
|
|
|
ZeroMemory(srcPath, sizeof(srcPath));
|
|
lstrcpyW(srcPath, lpSrcPath);
|
|
lstrcatW(srcPath, sWildcard);
|
|
|
|
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);
|
|
heap_free( knownfolder->registryPath );
|
|
heap_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, 0, &hKey));
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = S_OK;
|
|
RegCloseKey(hKey);
|
|
}
|
|
else
|
|
{
|
|
/* This known folder is not registered. To mark it, we set registryPath to NULL */
|
|
heap_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, szCategory, 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%08x, %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)
|
|
{
|
|
static const WCHAR sBackslash[] = {'\\',0};
|
|
HRESULT hr;
|
|
DWORD dwSize, dwType;
|
|
WCHAR path[MAX_PATH] = {0};
|
|
WCHAR parentGuid[39];
|
|
KF_CATEGORY 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, szParentFolder, 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)) {
|
|
heap_free(parentRegistryPath);
|
|
return hr;
|
|
}
|
|
|
|
lstrcatW(path, parentPath);
|
|
lstrcatW(path, sBackslash);
|
|
|
|
heap_free(parentRegistryPath);
|
|
heap_free(parentPath);
|
|
}
|
|
|
|
/* check, if folder was redirected */
|
|
if(SUCCEEDED(hr))
|
|
hr = get_known_folder_dword(registryPath, szCategory, &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, szKnownFolderRedirections, 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, szKnownFolderRedirections, 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, szRelativePath, 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, szRelativePath, 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%08x, %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%08x, %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%08x, %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%08x, %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, szCategory, &pKFD->category);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
|
|
hr = get_known_folder_wstr(knownfolder->registryPath, szName, &pKFD->pszName);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
|
|
/* optional fields */
|
|
dwSize = sizeof(parentGuid);
|
|
hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, szParentFolder,
|
|
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, szAttributes, &pKFD->dwAttributes);
|
|
|
|
get_known_folder_wstr(knownfolder->registryPath, szRelativePath, &pKFD->pszRelativePath);
|
|
|
|
get_known_folder_wstr(knownfolder->registryPath, szParsingName, &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 = heap_alloc( 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);
|
|
heap_free( foldermanager->ids );
|
|
heap_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, 0, &hKey));
|
|
heap_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, szName, &name );
|
|
heap_free( path );
|
|
if (FAILED( hr )) return hr;
|
|
|
|
found = !strcmpiW( 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, szCategory, 0, REG_DWORD, (LPBYTE)&pKFD->category, sizeof(pKFD->category)));
|
|
|
|
if(SUCCEEDED(hr) && pKFD->dwAttributes != 0)
|
|
hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szAttributes, 0, REG_DWORD, (LPBYTE)&pKFD->dwAttributes, sizeof(pKFD->dwAttributes)));
|
|
|
|
if(SUCCEEDED(hr))
|
|
hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szName, 0, REG_SZ, (LPBYTE)pKFD->pszName, (lstrlenW(pKFD->pszName)+1)*sizeof(WCHAR) ));
|
|
|
|
if(SUCCEEDED(hr) && pKFD->pszParsingName)
|
|
hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szParsingName, 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, szParentFolder, 0, REG_SZ, (LPBYTE)sParentGuid, sizeof(sParentGuid)));
|
|
}
|
|
|
|
if(SUCCEEDED(hr) && pKFD->category != KF_CATEGORY_VIRTUAL && pKFD->pszRelativePath)
|
|
hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szRelativePath, 0, REG_SZ, (LPBYTE)pKFD->pszRelativePath, (lstrlenW(pKFD->pszRelativePath)+1)*sizeof(WCHAR) ));
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
if(FAILED(hr))
|
|
SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath);
|
|
}
|
|
|
|
heap_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));
|
|
|
|
heap_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 = heap_alloc( 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 = heap_alloc( fm->num_ids * sizeof(KNOWNFOLDERID) );
|
|
if (!fm->ids)
|
|
{
|
|
heap_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%08x, %p, %p\n", debugstr_guid(rfid), flags, token, pidl);
|
|
|
|
if (!pidl)
|
|
return E_INVALIDARG;
|
|
|
|
if (flags)
|
|
FIXME("unsupported flags: 0x%08x\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->pszName){
|
|
KNOWNFOLDER_DEFINITION kfd;
|
|
|
|
/* register_folder won't modify kfd, so cast away const instead of
|
|
* reallocating */
|
|
kfd.category = folder->category;
|
|
kfd.pszName = (WCHAR*)folder->pszName;
|
|
kfd.pszDescription = (WCHAR*)folder->pszDescription;
|
|
memcpy(&kfd.fidParent, folder->fidParent, sizeof(KNOWNFOLDERID));
|
|
kfd.pszRelativePath = (WCHAR*)folder->pszRelativePath;
|
|
kfd.pszParsingName = (WCHAR*)folder->pszParsingName;
|
|
kfd.pszTooltip = (WCHAR*)folder->pszTooltip;
|
|
kfd.pszLocalizedName = (WCHAR*)folder->pszLocalizedName;
|
|
kfd.pszIcon = (WCHAR*)folder->pszIcon;
|
|
kfd.pszSecurity = (WCHAR*)folder->pszSecurity;
|
|
kfd.dwAttributes = folder->dwAttributes;
|
|
kfd.kfdFlags = folder->kfdFlags;
|
|
memcpy(&kfd.ftidType, folder->ftidType, sizeof(FOLDERTYPEID));
|
|
|
|
register_folder(folder->id, &kfd);
|
|
}
|
|
}
|
|
}
|
|
|
|
HRESULT SHELL_RegisterShellFolders(void)
|
|
{
|
|
HRESULT hr;
|
|
|
|
/* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
|
|
* 'My Videos', 'My Music', 'Desktop' etc. in advance, so that the
|
|
* _SHRegister*ShellFolders() functions will find everything nice and clean
|
|
* and thus will not attempt to create them in the profile directory. */
|
|
_SHCreateSymbolicLinks();
|
|
|
|
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;
|
|
}
|