|
|
#include "shellprv.h"
#include "apithk.h"
#include "folder.h"
#include "ids.h"
#include "deskfldr.h"
#include <winnls.h>
#include "shitemid.h"
#include "sddl.h"
#ifdef _WIN64
#include <wow64t.h>
#endif
#include "filefldr.h"
#include "lmcons.h"
#include "netview.h"
//---------------------------------------------------------------------------
// Get the path for the CSIDL_ folders and optionally create it if it
// doesn't exist.
//
// Returns FALSE if the special folder given isn't one of those above or the
// directory couldn't be created.
// By default all the special folders are in the windows directory.
// This can be overidden by a [.Shell Folders] section in win.ini with
// entries like Desktop = c:\stuff\desktop
// This in turn can be overidden by a "per user" section in win.ini eg
// [Shell Folder Ianel] - the user name for this section is the current
// network user name, if this fails the default network user name is used
// and if this fails the name given at setup time is used.
//
// "Shell Folders" is the key that records all the absolute paths to the
// shell folders. The values there are always supposed to be present.
//
// "User Shell Folders" is the key where the user's modifications from
// the defaults are stored.
//
// When we need to find the location of a path, we look in "User Shell Folders"
// first, and if that's not there, generate the default path. In either
// case we then write the absolute path under "Shell Folders" for other
// apps to look at. This is so that HKEY_CURRENT_USER can be propagated
// to a machine with Windows installed in a different directory, and as
// long as the user hasn't changed the setting, they won't have the other
// Windows directory hard-coded in the registry.
// -- gregj, 11/10/94
typedef enum { SDIF_NONE = 0, SDIF_CREATE_IN_ROOT = 0x00000001, // create in root (not in profiles dir)
SDIF_CREATE_IN_WINDIR = 0x00000002, // create in the windows dir (not in profiles dir)
SDIF_CREATE_IN_ALLUSERS = 0x00000003, // create in "All Users" folder (not in profiles dir)
SDIF_CREATE_IN_MYDOCUMENTS = 0x00000004, // create in CSIDL_PERSONAL folder
SDIF_CREATE_IN_LOCALSET = 0x00000005, // create in <user>\Local Settings folder
SDIF_CREATE_IN_MASK = 0x0000000F, // mask for above values
SDIF_CAN_DELETE = 0x00000010, SDIF_SHORTCUT_RELATIVE = 0x00000020, // make shortcuts relative to this folder
SDIF_HIDE = 0x00000040, // hide these when we create them
SDIF_EMPTY_IF_NOT_IN_REG = 0x00000080, // does not exist if nothing in the registry
SDIF_NOT_FILESYS = 0x00000100, // not a file system folder
SDIF_NOT_TRACKED = 0x00000200, // don't track this, it can't change
SDIF_CONST_IDLIST = 0x00000400, // don't alloc or free this
SDIF_REMOVABLE = 0x00000800, // Can exist on removable media
SDIF_CANT_MOVE_RENAME = 0x00001000, // can't move or rename this
SDIF_WX86 = 0x00002000, // do Wx86 thunking
SDIF_NETWORKABLE = 0x00004000, // Can be moved to the net
SDIF_MAYBE_ALIASED = 0x00008000, // could have an alias representation
SDIF_PERSONALIZED = 0x00010000, // resource name is to be personalized
SDIF_POLICY_NO_MOVE = 0x00020000, // policy blocks move
} ;typedef DWORD FOLDER_FLAGS;
typedef void (*FOLDER_CREATE_PROC)(int id, LPCTSTR pszPath);
void _InitMyPictures(int id, LPCTSTR pszPath);void _InitMyMusic(int id, LPCTSTR pszPath);void _InitMyVideos(int id, LPCTSTR pszPath);void _InitPerUserMyMusic(int id, LPCTSTR pszPath);void _InitPerUserMyPictures(int id, LPCTSTR pszPath);void _InitRecentDocs(int id, LPCTSTR pszPath);void _InitFavorites(int id, LPCTSTR pszPath);
typedef struct { int id; // CSIDL_ value
int idsDefault; // string id of default folder name name
LPCTSTR pszValueName; // reg key (not localized)
HKEY hKey; // HKCU or HKLM (Current User or Local Machine)
FOLDER_FLAGS dwFlags; FOLDER_CREATE_PROC pfnInit; INT idsLocalizedName;} FOLDER_INFO;
// typical entry
#define FOLDER(csidl, ids, value, key, ff) \
{ csidl, ids, value, key, ff, NULL, 0}
// FIXEDFOLDER entries must have be marked SDIF_CONST_IDLIST
// or have code in _GetFolderDefaultPath() to create their path
// if they have a filesys path
#define FIXEDFOLDER(csidl, value, ff) \
{ csidl, 0, value, NULL, ff, NULL, 0}
// PROCFOLDER's have a FOLDER_CREATE_PROC pfn that gets
// run in _PostCreateStuff()
#define PROCFOLDER(csidl, ids, value, key, ff, proc, idsLocal) \
{csidl, ids, value, key, ff, proc, idsLocal}
// folder that needs SHSetLocalizedName() in _PostCreateStuff()
#define LOCALFOLDER(csidl, ids, value, key, ff, idsLocal) \
{csidl, ids, value, key, ff, NULL, idsLocal}
const FOLDER_INFO c_rgFolderInfo[] = {FOLDER( CSIDL_DESKTOP, IDS_CSIDL_DESKTOPDIRECTORY, TEXT("DesktopFolder"), NULL, SDIF_NOT_TRACKED | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_NETWORK, TEXT("NetworkFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_DRIVES, TEXT("DriveFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_INTERNET, TEXT("InternetFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_CONTROLS, TEXT("ControlPanelFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_PRINTERS, TEXT("PrintersFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_BITBUCKET, TEXT("RecycleBinFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FIXEDFOLDER( CSIDL_CONNECTIONS, TEXT("ConnectionsFolder"), SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST),
FOLDER( CSIDL_FONTS, 0, TEXT("Fonts"), HKEY_CURRENT_USER, SDIF_NOT_TRACKED | SDIF_CREATE_IN_WINDIR | SDIF_CANT_MOVE_RENAME),
FOLDER( CSIDL_DESKTOPDIRECTORY, IDS_CSIDL_DESKTOPDIRECTORY, TEXT("Desktop"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE),
// _STARTUP is a subfolder of _PROGRAMS is a subfolder of _STARTMENU -- keep that order
FOLDER( CSIDL_STARTUP, IDS_CSIDL_STARTUP, TEXT("Startup"), HKEY_CURRENT_USER, SDIF_NONE), FOLDER( CSIDL_PROGRAMS, IDS_CSIDL_PROGRAMS, TEXT("Programs"), HKEY_CURRENT_USER, SDIF_NONE),
FOLDER( CSIDL_STARTMENU, IDS_CSIDL_STARTMENU, TEXT("Start Menu"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE),
PROCFOLDER( CSIDL_RECENT, IDS_CSIDL_RECENT, TEXT("Recent"), HKEY_CURRENT_USER, SDIF_HIDE | SDIF_CANT_MOVE_RENAME | SDIF_CAN_DELETE, _InitRecentDocs, IDS_FOLDER_RECENTDOCS),
FOLDER( CSIDL_SENDTO, IDS_CSIDL_SENDTO, TEXT("SendTo"), HKEY_CURRENT_USER, SDIF_HIDE),
FOLDER( CSIDL_PERSONAL, IDS_CSIDL_PERSONAL, TEXT("Personal"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE | SDIF_NETWORKABLE | SDIF_REMOVABLE | SDIF_CONST_IDLIST | SDIF_MAYBE_ALIASED | SDIF_PERSONALIZED | SDIF_POLICY_NO_MOVE), PROCFOLDER( CSIDL_FAVORITES, IDS_CSIDL_FAVORITES, TEXT("Favorites"), HKEY_CURRENT_USER, SDIF_POLICY_NO_MOVE, _InitFavorites, IDS_FOLDER_FAVORITES),
FOLDER( CSIDL_NETHOOD, IDS_CSIDL_NETHOOD, TEXT("NetHood"), HKEY_CURRENT_USER, SDIF_HIDE),
FOLDER( CSIDL_PRINTHOOD, IDS_CSIDL_PRINTHOOD, TEXT("PrintHood"), HKEY_CURRENT_USER, SDIF_HIDE), FOLDER( CSIDL_TEMPLATES, IDS_CSIDL_TEMPLATES, TEXT("Templates"), HKEY_CURRENT_USER, SDIF_HIDE),
// Common special folders
// _STARTUP is a subfolder of _PROGRAMS is a subfolder of _STARTMENU -- keep that order
FOLDER( CSIDL_COMMON_STARTUP, IDS_CSIDL_STARTUP, TEXT("Common Startup"), HKEY_LOCAL_MACHINE, SDIF_CREATE_IN_ALLUSERS | SDIF_CANT_MOVE_RENAME | SDIF_EMPTY_IF_NOT_IN_REG), FOLDER( CSIDL_COMMON_PROGRAMS, IDS_CSIDL_PROGRAMS, TEXT("Common Programs"), HKEY_LOCAL_MACHINE, SDIF_CREATE_IN_ALLUSERS | SDIF_EMPTY_IF_NOT_IN_REG), FOLDER( CSIDL_COMMON_STARTMENU, IDS_CSIDL_STARTMENU, TEXT("Common Start Menu"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS | SDIF_EMPTY_IF_NOT_IN_REG), FOLDER( CSIDL_COMMON_DESKTOPDIRECTORY, IDS_CSIDL_DESKTOPDIRECTORY, TEXT("Common Desktop"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS), FOLDER( CSIDL_COMMON_FAVORITES, IDS_CSIDL_FAVORITES, TEXT("Common Favorites"), HKEY_LOCAL_MACHINE, SDIF_CREATE_IN_ALLUSERS),
FOLDER( CSIDL_COMMON_APPDATA, IDS_CSIDL_APPDATA, TEXT("Common AppData"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS),
FOLDER( CSIDL_COMMON_TEMPLATES, IDS_CSIDL_TEMPLATES, TEXT("Common Templates"), HKEY_LOCAL_MACHINE, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_CREATE_IN_ALLUSERS), LOCALFOLDER( CSIDL_COMMON_DOCUMENTS, IDS_CSIDL_ALLUSERS_DOCUMENTS, TEXT("Common Documents"), HKEY_LOCAL_MACHINE, SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME | SDIF_MAYBE_ALIASED | SDIF_CREATE_IN_ALLUSERS, IDS_LOCALGDN_FLD_SHARED_DOC),
// Application Data special folder
FOLDER( CSIDL_APPDATA, IDS_CSIDL_APPDATA, TEXT("AppData"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE), FOLDER( CSIDL_LOCAL_APPDATA, IDS_CSIDL_APPDATA, TEXT("Local AppData"), HKEY_CURRENT_USER, SDIF_CREATE_IN_LOCALSET),
// Non-localized startup folder (do not localize this folder name)
FOLDER( CSIDL_ALTSTARTUP, IDS_CSIDL_ALTSTARTUP, TEXT("AltStartup"), HKEY_CURRENT_USER, SDIF_EMPTY_IF_NOT_IN_REG),
// Non-localized Common StartUp group (do not localize this folde name)
FOLDER( CSIDL_COMMON_ALTSTARTUP, IDS_CSIDL_ALTSTARTUP, TEXT("Common AltStartup"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_CREATE_IN_ALLUSERS),
// Per-user Internet-related folders
FOLDER( CSIDL_INTERNET_CACHE, IDS_CSIDL_CACHE, TEXT("Cache"), HKEY_CURRENT_USER, SDIF_CREATE_IN_LOCALSET), FOLDER( CSIDL_COOKIES, IDS_CSIDL_COOKIES, TEXT("Cookies"), HKEY_CURRENT_USER, SDIF_NONE),
FOLDER( CSIDL_HISTORY, IDS_CSIDL_HISTORY, TEXT("History"), HKEY_CURRENT_USER, SDIF_CREATE_IN_LOCALSET),
FIXEDFOLDER( CSIDL_SYSTEM, TEXT("System"), SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME | SDIF_SHORTCUT_RELATIVE),
FIXEDFOLDER( CSIDL_SYSTEMX86, TEXT("SystemX86"), SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME | SDIF_WX86 | SDIF_SHORTCUT_RELATIVE),
FIXEDFOLDER( CSIDL_WINDOWS, TEXT("Windows"), SDIF_NOT_TRACKED | SDIF_SHORTCUT_RELATIVE | SDIF_CANT_MOVE_RENAME),
FIXEDFOLDER( CSIDL_PROFILE, TEXT("Profile"), SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME), PROCFOLDER( CSIDL_MYPICTURES, IDS_CSIDL_MYPICTURES, TEXT("My Pictures"), HKEY_CURRENT_USER, SDIF_CAN_DELETE | SDIF_NETWORKABLE | SDIF_REMOVABLE | SDIF_CREATE_IN_MYDOCUMENTS | SDIF_SHORTCUT_RELATIVE | SDIF_MAYBE_ALIASED | SDIF_PERSONALIZED | SDIF_POLICY_NO_MOVE, _InitPerUserMyPictures, 0),
//
// CSIDL_PROGRAM_FILES must come after CSIDL_PROGRAM_FILESX86 so that shell links for x86 apps
// work correctly on non-x86 platforms.
// Example: On IA64 a 32-bit app creates a shortcut via IShellLink to the Program
// Files directory. A WOW64 registry hive maps "Program Files" to "Program Files (x86)". The shell
// link code then tries to abstract the special folder part of the path by mapping to one of the
// entries in this table. Since CSIDL_PROGRAM_FILES and CSIDL_PROGRAM_FILESX86 are the same it
// will map to the one that appears first in this table. When the shortcut is accessed in
// 64-bit mode the cidls are no longer the same. If CSIDL_PROGRAM_FILES was used instead of
// CSIDL_PROGRAM_FILESX86 the shortcut will be broken.
#ifdef WX86
FIXEDFOLDER( CSIDL_PROGRAM_FILESX86, TEXT("ProgramFilesX86"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE|SDIF_WX86),
FIXEDFOLDER( CSIDL_PROGRAM_FILES_COMMONX86, TEXT("CommonProgramFilesX86"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_WX86),#else
FIXEDFOLDER( CSIDL_PROGRAM_FILESX86, TEXT("ProgramFilesX86"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE),
FIXEDFOLDER( CSIDL_PROGRAM_FILES_COMMONX86, TEXT("CommonProgramFilesX86"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE),#endif
// CSIDL_PROGRAM_FILES must come after CSIDL_PROGRAM_FILESX86. See comment above.
FIXEDFOLDER( CSIDL_PROGRAM_FILES, TEXT("ProgramFiles"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE),
FIXEDFOLDER( CSIDL_PROGRAM_FILES_COMMON, TEXT("CommonProgramFiles"), SDIF_NOT_TRACKED | SDIF_CAN_DELETE),
FOLDER( CSIDL_ADMINTOOLS, IDS_CSIDL_ADMINTOOLS, TEXT("Administrative Tools"), HKEY_CURRENT_USER, SDIF_NONE),
FOLDER( CSIDL_COMMON_ADMINTOOLS, IDS_CSIDL_ADMINTOOLS, TEXT("Common Administrative Tools"), HKEY_LOCAL_MACHINE, SDIF_CREATE_IN_ALLUSERS),
PROCFOLDER( CSIDL_MYMUSIC, IDS_CSIDL_MYMUSIC, TEXT("My Music"), HKEY_CURRENT_USER, SDIF_CAN_DELETE | SDIF_NETWORKABLE | SDIF_REMOVABLE | SDIF_CREATE_IN_MYDOCUMENTS | SDIF_MAYBE_ALIASED | SDIF_PERSONALIZED | SDIF_POLICY_NO_MOVE, _InitPerUserMyMusic, 0),
PROCFOLDER( CSIDL_MYVIDEO, IDS_CSIDL_MYVIDEO, TEXT("My Video"), HKEY_CURRENT_USER, SDIF_CAN_DELETE | SDIF_NETWORKABLE | SDIF_REMOVABLE | SDIF_CREATE_IN_MYDOCUMENTS | SDIF_MAYBE_ALIASED | SDIF_PERSONALIZED | SDIF_POLICY_NO_MOVE, _InitMyVideos, 0),
PROCFOLDER( CSIDL_COMMON_PICTURES, IDS_CSIDL_ALLUSERS_PICTURES, TEXT("CommonPictures"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CANT_MOVE_RENAME | SDIF_CAN_DELETE | SDIF_MAYBE_ALIASED | SDIF_CREATE_IN_ALLUSERS, _InitMyPictures, IDS_SHAREDPICTURES),
PROCFOLDER( CSIDL_COMMON_MUSIC, IDS_CSIDL_ALLUSERS_MUSIC, TEXT("CommonMusic"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CANT_MOVE_RENAME | SDIF_CAN_DELETE | SDIF_MAYBE_ALIASED | SDIF_CREATE_IN_ALLUSERS, _InitMyMusic, IDS_SHAREDMUSIC),
PROCFOLDER( CSIDL_COMMON_VIDEO,
IDS_CSIDL_ALLUSERS_VIDEO, TEXT("CommonVideo"), HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CANT_MOVE_RENAME | SDIF_CAN_DELETE | SDIF_MAYBE_ALIASED | SDIF_CREATE_IN_ALLUSERS, _InitMyVideos, IDS_SHAREDVIDEO),
FIXEDFOLDER( CSIDL_RESOURCES, TEXT("ResourceDir"), SDIF_NOT_TRACKED),
FIXEDFOLDER( CSIDL_RESOURCES_LOCALIZED, TEXT("LocalizedResourcesDir"), SDIF_NOT_TRACKED),
FOLDER( CSIDL_COMMON_OEM_LINKS, IDS_CSIDL_ALLUSERS_OEM_LINKS, TEXT("OEM Links"), HKEY_LOCAL_MACHINE, SDIF_CAN_DELETE | SDIF_CREATE_IN_ALLUSERS | SDIF_EMPTY_IF_NOT_IN_REG),
FOLDER( CSIDL_CDBURN_AREA, IDS_CSIDL_CDBURN_AREA, TEXT("CD Burning"), HKEY_CURRENT_USER, SDIF_CAN_DELETE | SDIF_CREATE_IN_LOCALSET),
FIXEDFOLDER( CSIDL_COMPUTERSNEARME, TEXT("ComputersNearMe"), SDIF_NONE),
FIXEDFOLDER(-1, NULL, SDIF_NONE)};
EXTERN_C const IDLREGITEM c_idlMyDocs ={ {sizeof(IDREGITEM), SHID_ROOT_REGITEM, SORT_ORDER_MYDOCS, { 0x450d8fba, 0xad25, 0x11d0, 0x98,0xa8,0x08,0x00,0x36,0x1b,0x11,0x03, },}, // CLSID_MyDocuments
0,} ;
EXTERN_C const IDREGITEM c_idlPrinters[] ={ {sizeof(IDREGITEM), SHID_ROOT_REGITEM, SORT_ORDER_DRIVES, { 0x20D04FE0, 0x3AEA, 0x1069, 0xA2,0xD8,0x08,0x00,0x2B,0x30,0x30,0x9D, },}, // CLSID_MyComputer
{sizeof(IDREGITEM), SHID_COMPUTER_REGITEM, 0, { 0x21EC2020, 0x3AEA, 0x1069, 0xA2,0xDD,0x08,0x00,0x2B,0x30,0x30,0x9D, },}, // CLSID_ControlPanel
{sizeof(IDREGITEM), SHID_CONTROLPANEL_REGITEM, 0, { 0x2227A280, 0x3AEA, 0x1069, 0xA2, 0xDE, 0x08, 0x00, 0x2B, 0x30, 0x30, 0x9D, },}, // CLSID_Printers
0,} ;
EXTERN_C const IDREGITEM c_idlControls[] ={ {sizeof(IDREGITEM), SHID_ROOT_REGITEM, SORT_ORDER_DRIVES, { 0x20D04FE0, 0x3AEA, 0x1069, 0xA2,0xD8,0x08,0x00,0x2B,0x30,0x30,0x9D, },}, // CLSID_MyComputer
{sizeof(IDREGITEM), SHID_COMPUTER_REGITEM, 0, { 0x21EC2020, 0x3AEA, 0x1069, 0xA2,0xDD,0x08,0x00,0x2B,0x30,0x30,0x9D, },}, // CLSID_ControlPanel
0,} ;
EXTERN_C const IDLREGITEM c_idlBitBucket ={ {sizeof(IDREGITEM), SHID_ROOT_REGITEM, SORT_ORDER_RECYCLEBIN, { 0x645FF040, 0x5081, 0x101B, 0x9F, 0x08, 0x00, 0xAA, 0x00, 0x2F, 0x95, 0x4E, },}, // CLSID_RecycleBin
0,} ;
// this array holds a cache of the values of these folders. this cache can only
// be used in the hToken == NULL case otherwise we would need a per user version
// of this cache.
#define SFENTRY(x) { (LPTSTR)-1, (LPITEMIDLIST)x , (LPITEMIDLIST)-1}
EXTERN_C const IDREGITEM c_aidlConnections[];
struct { LPTSTR psz; LPITEMIDLIST pidl; LPITEMIDLIST pidlNonAlias;} g_aFolderCache[] = { SFENTRY(&c_idlDesktop), // CSIDL_DESKTOP (0x0000)
SFENTRY(&c_idlInetRoot), // CSIDL_INTERNET (0x0001)
SFENTRY(-1), // CSIDL_PROGRAMS (0x0002)
SFENTRY(&c_idlControls), // CSIDL_CONTROLS (0x0003)
SFENTRY(&c_idlPrinters), // CSIDL_PRINTERS (0x0004)
SFENTRY(&c_idlMyDocs), // CSIDL_PERSONAL (0x0005)
SFENTRY(-1), // CSIDL_FAVORITES (0x0006)
SFENTRY(-1), // CSIDL_STARTUP (0x0007)
SFENTRY(-1), // CSIDL_RECENT (0x0008)
SFENTRY(-1), // CSIDL_SENDTO (0x0009)
SFENTRY(&c_idlBitBucket), // CSIDL_BITBUCKET (0x000a)
SFENTRY(-1), // CSIDL_STARTMENU (0x000b)
SFENTRY(-1), // CSIDL_MYDOCUMENTS (0x000c)
SFENTRY(-1), // CSIDL_MYMUSIC (0x000d)
SFENTRY(-1), // CSIDL_MYVIDEO (0x000e)
SFENTRY(-1), // <unused> (0x000f)
SFENTRY(-1), // CSIDL_DESKTOPDIRECTORY (0x0010)
SFENTRY(&c_idlDrives), // CSIDL_DRIVES (0x0011)
SFENTRY(&c_idlNet), // CSIDL_NETWORK (0x0012)
SFENTRY(-1), // CSIDL_NETHOOD (0x0013)
SFENTRY(-1), // CSIDL_FONTS (0x0014)
SFENTRY(-1), // CSIDL_TEMPLATES (0x0015)
SFENTRY(-1), // CSIDL_COMMON_STARTMENU (0x0016)
SFENTRY(-1), // CSIDL_COMMON_PROGRAMS (0X0017)
SFENTRY(-1), // CSIDL_COMMON_STARTUP (0x0018)
SFENTRY(-1), // CSIDL_COMMON_DESKTOPDIRECTORY (0x0019)
SFENTRY(-1), // CSIDL_APPDATA (0x001a)
SFENTRY(-1), // CSIDL_PRINTHOOD (0x001b)
SFENTRY(-1), // CSIDL_LOCAL_APPDATA (0x001c)
SFENTRY(-1), // CSIDL_ALTSTARTUP (0x001d)
SFENTRY(-1), // CSIDL_COMMON_ALTSTARTUP (0x001e)
SFENTRY(-1), // CSIDL_COMMON_FAVORITES (0x001f)
SFENTRY(-1), // CSIDL_INTERNET_CACHE (0x0020)
SFENTRY(-1), // CSIDL_COOKIES (0x0021)
SFENTRY(-1), // CSIDL_HISTORY (0x0022)
SFENTRY(-1), // CSIDL_COMMON_APPDATA (0x0023)
SFENTRY(-1), // CSIDL_WINDOWS (0x0024)
SFENTRY(-1), // CSIDL_SYSTEM (0x0025)
SFENTRY(-1), // CSIDL_PROGRAM_FILES (0x0026)
SFENTRY(-1), // CSIDL_MYPICTURES (0x0027)
SFENTRY(-1), // CSIDL_PROFILE (0x0028)
SFENTRY(-1), // CSIDL_SYSTEMX86 (0x0029)
SFENTRY(-1), // CSIDL_PROGRAM_FILESX86 (0x002a)
SFENTRY(-1), // CSIDL_PROGRAM_FILES_COMMON (0x002b)
SFENTRY(-1), // CSIDL_PROGRAM_FILES_COMMONX86 (0x002c)
SFENTRY(-1), // CSIDL_COMMON_TEMPLATES (0x002d)
SFENTRY(-1), // CSIDL_COMMON_DOCUMENTS (0x002e)
SFENTRY(-1), // CSIDL_COMMON_ADMINTOOLS (0x002f)
SFENTRY(-1), // CSIDL_ADMINTOOLS (0x0030)
SFENTRY(c_aidlConnections), // CSIDL_CONNECTIONS (0x0031)
SFENTRY(-1), // (0x0032)
SFENTRY(-1), // (0x0033)
SFENTRY(-1), // (0x0034)
SFENTRY(-1), // CSIDL_COMMON_MUSIC (0x0035)
SFENTRY(-1), // CSIDL_COMMON_PICTURES (0x0036)
SFENTRY(-1), // CSIDL_COMMON_VIDEO (0x0037)
SFENTRY(-1), // CSIDL_RESOURCES (0x0038)
SFENTRY(-1), // CSIDL_RESOURCES_LOCALIZED (0x0039)
SFENTRY(-1), // CSIDL_COMMON_OEM_LINKS (0x003a)
SFENTRY(-1), // CSIDL_CDBURN_AREA (0x003b)
SFENTRY(-1), // <unused> (0x003c)
SFENTRY(-1), // CSIDL_COMPUTERSNEARME (0x003d)
};
HRESULT _OpenKeyForFolder(const FOLDER_INFO *pfi, HANDLE hToken, LPCTSTR pszSubKey, HKEY *phkey);void _UpdateShellFolderCache(void);BOOL GetUserProfileDir(HANDLE hToken, TCHAR *pszPath);HRESULT VerifyAndCreateFolder(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPTSTR pszPath) ;
#define _IsDefaultUserToken(hToken) ((HANDLE)-1 == hToken)
const FOLDER_INFO *_GetFolderInfo(int csidl){ const FOLDER_INFO *pfi;
// make sure g_aFolderCache can be indexed by the CSIDL values
COMPILETIME_ASSERT((ARRAYSIZE(g_aFolderCache) - 1) == CSIDL_COMPUTERSNEARME);
for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { if (pfi->id == csidl) return pfi; } return NULL;}
// expand an individual enviornment variable
// in:
// pszVar "%USERPROFILE%
// pszValue "c:\winnt\profiles\user"
//
// in/out:
// pszToExpand in: %USERPROFILE%\My Docs", out: c:\winnt\profiles\user\My Docs"
BOOL ExpandEnvVar(LPCTSTR pszVar, LPCTSTR pszValue, LPTSTR pszToExpand){ TCHAR *pszStart = StrStrI(pszToExpand, pszVar); if (pszStart) { TCHAR szAfter[MAX_PATH];
lstrcpy(szAfter, pszStart + lstrlen(pszVar)); // save the tail
lstrcpyn(pszStart, pszValue, (int) (MAX_PATH - (pszStart - pszToExpand))); StrCatBuff(pszToExpand, szAfter, MAX_PATH); // put the tail back on
return TRUE; } return FALSE;}
HANDLE GetCurrentUserToken(){ HANDLE hToken; if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken) || OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_IMPERSONATE, &hToken)) return hToken; return NULL;}
// like ExpandEnvironmentStrings but is robust to the enviornment variables
// not being set. this works on...
// %SYSTEMROOT%
// %SYSTEMDRIVE%
// %USERPROFILE%
// %ALLUSERSPROFILE%
//
// in the rare case (Winstone!) that there is a NULL enviornment block
DWORD ExpandEnvironmentStringsNoEnv(HANDLE hToken, LPCTSTR pszExpand, LPTSTR pszOut, UINT cchOut){ TCHAR szPath[MAX_PATH]; if (hToken && !_IsDefaultUserToken(hToken)) { if (!ExpandEnvironmentStringsForUser(hToken, pszExpand, pszOut, cchOut)) lstrcpyn(pszOut, pszExpand, cchOut); } else if (hToken == NULL) { // to debug env expansion failure...
// lstrcpyn(pszOut, pszExpand, cchOut);
SHExpandEnvironmentStrings(pszExpand, pszOut, cchOut); }
// manually expand in this order since
// %USERPROFILE% -> %SYSTEMDRIVE%\Docs & Settings
if (StrChr(pszOut, TEXT('%')) && (hToken == NULL)) { hToken = GetCurrentUserToken(); if (hToken) { // this does %USERPROFILE% and other per user stuff
ExpandEnvironmentStringsForUser(hToken, pszExpand, pszOut, cchOut); CloseHandle(hToken); } } else if (_IsDefaultUserToken(hToken) && StrChr(pszOut, TEXT('%'))) { GetUserProfileDir(hToken, szPath); ExpandEnvVar(TEXT("%USERPROFILE%"), szPath, pszOut); }
if (*pszOut == TEXT('%')) { GetAllUsersDirectory(szPath); ExpandEnvVar(TEXT("%ALLUSERSPROFILE%"), szPath, pszOut); }
if (*pszOut == TEXT('%')) { GetSystemWindowsDirectory(szPath, ARRAYSIZE(szPath)); ExpandEnvVar(TEXT("%SYSTEMROOT%"), szPath, pszOut); }
if (*pszOut == TEXT('%')) { GetSystemWindowsDirectory(szPath, ARRAYSIZE(szPath)); ASSERT(szPath[1] == TEXT(':')); // this better not be a UNC!
szPath[2] = 0; // SYSTEMDRIVE = 'c:', not 'c:\'
ExpandEnvVar(TEXT("%SYSTEMDRIVE%"), szPath, pszOut); }
if (*pszOut == TEXT('%')) *pszOut = 0;
return lstrlen(pszOut) + 1; // +1 to cover the NULL
}
// get the user profile directory:
// uses the hToken as needed to determine the proper user profile
BOOL GetUserProfileDir(HANDLE hToken, TCHAR *pszPath){ DWORD dwcch = MAX_PATH; HANDLE hClose = NULL; BOOL fRet; *pszPath = 0; // in case of error
if (!hToken) { hClose = hToken = GetCurrentUserToken(); } if (_IsDefaultUserToken(hToken)) { fRet = GetDefaultUserProfileDirectory(pszPath, &dwcch); } else { fRet = GetUserProfileDirectory(hToken, pszPath, &dwcch); } if (hClose) { CloseHandle(hClose); } return fRet;}
#ifdef WX86
void SetUseKnownWx86Dll(const FOLDER_INFO *pfi, BOOL bValue){ if (pfi->dwFlags & SDIF_WX86) { // GetSystemDirectory() knows we're looking for the Wx86 system
// directory when this flag is set.
NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = bValue ? TRUE : FALSE; }}#else
#define SetUseKnownWx86Dll(pfi, bValue)
#endif
// read from registry
BOOL GetProgramFiles(LPCTSTR pszValue, LPTSTR pszPath){ DWORD cbPath = MAX_PATH * sizeof(*pszPath);
*pszPath = 0;
SHGetValue(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion"), pszValue, NULL, pszPath, &cbPath); return (BOOL)*pszPath;}
LPTSTR GetFontsDirectory(LPTSTR pszPath){ if (GetWindowsDirectory(pszPath, MAX_PATH)) { PathAppend(pszPath, TEXT("Fonts")); }
return pszPath;}
void LoadDefaultString(int idString, LPTSTR lpBuffer, int cchBufferMax){ BOOL fSucceeded = FALSE; HRSRC hResInfo; HANDLE hStringSeg; LPWSTR lpsz; int cch; HMODULE hmod = GetModuleHandle(TEXT("SHELL32")); // Make sure the parms are valid.
if (lpBuffer == NULL || cchBufferMax == 0) { return; }
cch = 0; // String Tables are broken up into 16 string segments. Find the segment
// containing the string we are interested in.
if (hResInfo = FindResourceExW(hmod, (LPCWSTR)RT_STRING, (LPWSTR)((LONG_PTR)(((USHORT)idString >> 4) + 1)), GetSystemDefaultUILanguage())) { // Load that segment.
hStringSeg = LoadResource(hmod, hResInfo); // Lock the resource.
if (lpsz = (LPWSTR)LockResource(hStringSeg)) { // Move past the other strings in this segment.
// (16 strings in a segment -> & 0x0F)
idString &= 0x0F; while (TRUE) { cch = *((WORD *)lpsz++); // PASCAL like string count
// first UTCHAR is count if TCHARs
if (idString-- == 0) break; lpsz += cch; // Step to start if next string
} // Account for the NULL
cchBufferMax--; // Don't copy more than the max allowed.
if (cch > cchBufferMax) cch = cchBufferMax; // Copy the string into the buffer.
CopyMemory(lpBuffer, lpsz, cch*sizeof(WCHAR));
// Attach Null terminator.
lpBuffer[cch] = 0;
fSucceeded = TRUE;
} }
if (!fSucceeded) { LoadString(HINST_THISDLL, idString, lpBuffer, cchBufferMax); }}
BOOL GetLocalSettingsDir(HANDLE hToken, LPTSTR pszPath){ *pszPath = 0;
GetUserProfileDir(hToken, pszPath);
if (*pszPath) { TCHAR szEntry[MAX_PATH]; LoadDefaultString(IDS_LOCALSETTINGS, szEntry, ARRAYSIZE(szEntry)); PathAppend(pszPath, szEntry); } return *pszPath ? TRUE : FALSE;}
HRESULT GetResourcesDir(IN BOOL fLocalized, IN LPTSTR pszPath, IN DWORD cchSize){ HRESULT hr = E_FAIL; TCHAR szTemp[MAX_PATH];
RIP(IS_VALID_WRITE_BUFFER(pszPath, TCHAR, cchSize)); pszPath[0] = 0; // Terminate in case we fail.
if (SHGetSystemWindowsDirectory(szTemp, ARRAYSIZE(szTemp))) { // It's now "%windir%\resources\".
PathAppend(szTemp, TEXT("resources"));
if (fLocalized) { LANGID lidUI = GetUserDefaultUILanguage(); TCHAR szSubDir[10];
// Now make it "%windir%\resources\<LangID>\"
wnsprintfW(szSubDir, ARRAYSIZE(szSubDir), TEXT("%04x"), lidUI); PathAppend(szTemp, szSubDir); }
StrCpyN(pszPath, szTemp, cchSize); hr = S_OK; }
return hr;}
// out:
// pszPath fills in with the full path with no env gunk (MAX_PATH)
HRESULT _GetFolderDefaultPath(const FOLDER_INFO *pfi, HANDLE hToken, LPTSTR pszPath){ ASSERT(!(pfi->dwFlags & SDIF_NOT_FILESYS)); // speical folders should not come here
*pszPath = 0;
TCHAR szEntry[MAX_PATH];
switch (pfi->id) { case CSIDL_PROFILE: GetUserProfileDir(hToken, pszPath); break;
case CSIDL_PROGRAM_FILES: GetProgramFiles(TEXT("ProgramFilesDir"), pszPath); break;
case CSIDL_PROGRAM_FILES_COMMON: GetProgramFiles(TEXT("CommonFilesDir"), pszPath); break;
case CSIDL_PROGRAM_FILESX86: GetProgramFiles(TEXT("ProgramFilesDir (x86)"), pszPath); break;
case CSIDL_PROGRAM_FILES_COMMONX86: GetProgramFiles(TEXT("CommonFilesDir (x86)"), pszPath); break;#ifdef _WIN64
case CSIDL_SYSTEMX86: //
// downlevel systems do not have GetSystemWindowsDirectory export,
// but shell thunking layer handles this gracefully
GetSystemWindowsDirectory(pszPath, MAX_PATH); //
// tack on subdirectory
//
PathCombine(pszPath, pszPath, TEXT(WOW64_SYSTEM_DIRECTORY)); break;#else
case CSIDL_SYSTEMX86:#endif
case CSIDL_SYSTEM: GetSystemDirectory(pszPath, MAX_PATH); break;
case CSIDL_WINDOWS: GetWindowsDirectory(pszPath, MAX_PATH); break;
case CSIDL_RESOURCES: GetResourcesDir(FALSE, pszPath, MAX_PATH); break;
case CSIDL_RESOURCES_LOCALIZED: GetResourcesDir(TRUE, pszPath, MAX_PATH); break;
case CSIDL_COMPUTERSNEARME: // no path for this
break;
case CSIDL_FONTS: GetFontsDirectory(pszPath); break;
default: switch (pfi->dwFlags & SDIF_CREATE_IN_MASK) { case SDIF_CREATE_IN_ROOT: GetWindowsDirectory(pszPath, MAX_PATH); PathStripToRoot(pszPath); break;
case SDIF_CREATE_IN_ALLUSERS: GetAllUsersDirectory(pszPath); break;
case SDIF_CREATE_IN_WINDIR: GetWindowsDirectory(pszPath, MAX_PATH); break;
case SDIF_CREATE_IN_MYDOCUMENTS: // 99/10/21 Mil#104600: When asking for folders in "My Documents" don't
// verify their existance. Just return the path. The caller will make
// the decision to create the folder or not.
// on failure *pszPath will be empty
SHGetFolderPath(NULL, CSIDL_PERSONAL | CSIDL_FLAG_DONT_VERIFY, hToken, SHGFP_TYPE_CURRENT, pszPath); break;
case SDIF_CREATE_IN_LOCALSET: GetLocalSettingsDir(hToken, pszPath); break;
default: GetUserProfileDir(hToken, pszPath); break; }
if (*pszPath) { LoadDefaultString(pfi->idsDefault, szEntry, ARRAYSIZE(szEntry)); PathAppend(pszPath, szEntry); } break; } return *pszPath ? S_OK : E_FAIL;}
void RegSetFolderPath(const FOLDER_INFO *pfi, LPCTSTR pszSubKey, LPCTSTR pszPath){ HKEY hk; if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, pszSubKey, &hk))) { if (pszPath) RegSetValueEx(hk, pfi->pszValueName, 0, REG_SZ, (LPBYTE)pszPath, (1 + lstrlen(pszPath)) * sizeof(TCHAR)); else RegDeleteValue(hk, pfi->pszValueName); RegCloseKey(hk); }}
BOOL RegQueryPath(HKEY hk, LPCTSTR pszValue, LPTSTR pszPath){ DWORD cbPath = MAX_PATH * sizeof(TCHAR);
*pszPath = 0; SHQueryValueEx(hk, pszValue, 0, NULL, pszPath, &cbPath); return (BOOL)*pszPath;}
// More than 50 is silly
#define MAX_TEMP_FILE_TRIES 50
// returns:
// S_OK the path exists and it is a folder
// FAILED() result
HRESULT _IsFolderNotFile(LPCTSTR pszFolder){ HRESULT hr; DWORD dwAttribs = GetFileAttributes(pszFolder); if (dwAttribs == -1) { DWORD err = GetLastError(); hr = HRESULT_FROM_WIN32(err); } else { // see if it is a file, if so we need to rename that file
if (dwAttribs & FILE_ATTRIBUTE_DIRECTORY) { hr = S_OK; } else { int iExt = 0; do { TCHAR szExt[32], szDst[MAX_PATH];
wsprintf(szExt, TEXT(".%03d"), iExt); lstrcpy(szDst, pszFolder); lstrcat(szDst, szExt); if (MoveFile(pszFolder, szDst)) iExt = 0; else { // Normally we fail because .00x already exists but that may not be true.
DWORD dwError = GetLastError(); if (ERROR_ALREADY_EXISTS == dwError) iExt++; // Try the next one...
else iExt = 0; // We have problems and need to give up. (No write access?)
}
} while (iExt && (iExt < MAX_TEMP_FILE_TRIES));
hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND); } } return hr;}
HRESULT _OpenKeyForFolder(const FOLDER_INFO *pfi, HANDLE hToken, LPCTSTR pszSubKey, HKEY *phkey){ TCHAR szRegPath[255]; LONG err; HKEY hkRoot, hkeyToFree = NULL;
*phkey = NULL;
lstrcpy(szRegPath, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\")); lstrcat(szRegPath, pszSubKey);
if (_IsDefaultUserToken(hToken) && (pfi->hKey == HKEY_CURRENT_USER)) { if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_USERS, TEXT(".Default"), 0, KEY_READ, &hkRoot)) hkeyToFree = hkRoot; else return E_FAIL; } else if (hToken && (pfi->hKey == HKEY_CURRENT_USER)) { if (GetUserProfileKey(hToken, &hkRoot)) hkeyToFree = hkRoot; else return E_FAIL; } else hkRoot = pfi->hKey;
err = RegCreateKeyEx(hkRoot, szRegPath, 0, NULL, REG_OPTION_NON_VOLATILE, MAXIMUM_ALLOWED, NULL, phkey, NULL); if (hkeyToFree) RegCloseKey(hkeyToFree);
return HRESULT_FROM_WIN32(err);}
//
// Roaming Profiles can set up the environment variables and registry
// keys like so:
//
// HOMESHARE=\\server\share\user
// HOMEPATH=\// My Music=%HOMESHARE%%HOMEPATH%\My Music
//
// so you end up with "\\server\share\user\\My Music", which is an
// invalid path. Clean them up; otherwise SHGetSpecialFolderLocation will
// fail.
//
void _CleanExpandedEnvironmentPath(LPTSTR szExpand){ // Search for "\\" at a location other than the start of the string.
// If found, collapse it.
LPTSTR pszWhackWhack; while (lstrlen(szExpand) > 2 && (pszWhackWhack = StrStr(szExpand+1, TEXT("\\\\")))) { StrCpy(pszWhackWhack+1, pszWhackWhack+2); }}
// returns:
// S_OK found in registry, path well formed
// S_FALSE empty registry
// FAILED() failure result
HRESULT _GetFolderFromReg(const FOLDER_INFO *pfi, HANDLE hToken, LPTSTR pszPath){ HKEY hkUSF; HRESULT hr;
*pszPath = 0;
hr = _OpenKeyForFolder(pfi, hToken, TEXT("User Shell Folders"), &hkUSF); if (SUCCEEDED(hr)) { TCHAR szExpand[MAX_PATH]; DWORD dwType, cbPath = sizeof(szExpand);
if (RegQueryValueEx(hkUSF, pfi->pszValueName, 0, &dwType, (BYTE *)szExpand, &cbPath) == ERROR_SUCCESS) { if (REG_SZ == dwType) { lstrcpyn(pszPath, szExpand, MAX_PATH); } else if (REG_EXPAND_SZ == dwType) { ExpandEnvironmentStringsNoEnv(hToken, szExpand, pszPath, MAX_PATH); _CleanExpandedEnvironmentPath(pszPath); } TraceMsg(TF_PATH, "_CreateFolderPath 'User Shell Folders' %s = %s", pfi->pszValueName, pszPath); }
if (*pszPath == 0) { hr = S_FALSE; // empty registry, success but empty
} else if ((PathGetDriveNumber(pszPath) != -1) || PathIsUNC(pszPath)) { hr = S_OK; // good reg path, fully qualified
} else { *pszPath = 0; // bad reg data
hr = E_INVALIDARG; }
RegCloseKey(hkUSF); } return hr;}
HRESULT _GetFolderPath(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPTSTR pszPath){ HRESULT hr;
*pszPath = 0; // assume failure
if (pfi->hKey) { hr = _GetFolderFromReg(pfi, hToken, pszPath); if (SUCCEEDED(hr)) { if (hr == S_FALSE) { // empty registry, SDIF_EMPTY_IF_NOT_IN_REG means they don't exist
// if the registry is not populated with a value. this lets us disable
// the common items on platforms that don't want them
if (pfi->dwFlags & SDIF_EMPTY_IF_NOT_IN_REG) return S_FALSE; // success, but empty
hr = _GetFolderDefaultPath(pfi, hToken, pszPath); }
if (!(uFlags & CSIDL_FLAG_DONT_VERIFY)) { hr = VerifyAndCreateFolder(hwnd, pfi, uFlags, pszPath) ; }
if (hr != S_OK) { *pszPath = 0; }
if (!(uFlags & CSIDL_FLAG_DONT_VERIFY)) { HKEY hkey; // record value in "Shell Folders", even in the failure case
// NOTE: we only do this for historical reasons. there may be some
// apps that depend on these values being in the registry, but in general
// the contetens here are unreliable as they are only written after someone
// asks for the folder through this API.
if (SUCCEEDED(_OpenKeyForFolder(pfi, hToken, TEXT("Shell Folders"), &hkey))) { RegSetValueEx(hkey, pfi->pszValueName, 0, REG_SZ, (LPBYTE)pszPath, (1 + lstrlen(pszPath)) * sizeof(TCHAR)); RegCloseKey(hkey); } } } } else { hr = _GetFolderDefaultPath(pfi, hToken, pszPath);
if ((S_OK == hr) && !(uFlags & CSIDL_FLAG_DONT_VERIFY)) { hr = VerifyAndCreateFolder(hwnd, pfi, uFlags, pszPath); } if (hr != S_OK) { *pszPath = 0; } }
ASSERT(hr == S_OK ? *pszPath != 0 : *pszPath == 0); return hr;}
void _PostCreateStuff(const FOLDER_INFO *pfi, LPTSTR pszPath, BOOL fUpgrade){ if (pfi->pfnInit || pfi->idsLocalizedName || (pfi->dwFlags & SDIF_PERSONALIZED)) { if (fUpgrade) { // if we are upgrading, torch all our previous meta data
TCHAR sz[MAX_PATH]; PathCombine(sz, pszPath, TEXT("desktop.ini"));
if (PathFileExistsAndAttributes(sz, NULL)) { WritePrivateProfileSection(TEXT(".ShellClassInfo"), NULL, sz); // in the upgrade case, sometimes the desktop.ini
// file was there but the folder wasnt marked.
// insure that it is marked.
PathMakeSystemFolder(pszPath); } } // now call the create proc if we have one
if (pfi->pfnInit) pfi->pfnInit(pfi->id, pszPath);
// does the table specify a localized resource name that we should be
// using for this object?
if (pfi->idsLocalizedName) SHSetLocalizedName(pszPath, TEXT("shell32.dll"), pfi->idsLocalizedName);
// do we need to store the user name for this folder?
if (pfi->dwFlags & SDIF_PERSONALIZED) { TCHAR szName[UNLEN+1]; DWORD dwName = ARRAYSIZE(szName); if (GetUserName(szName, &dwName)) { // CSharedDocuments depends on a per system list of MyDocs folders
// this is where we make sure that list is setup
if (!IsOS(OS_DOMAINMEMBER) && (pfi->id == CSIDL_PERSONAL)) { SKSetValue(SHELLKEY_HKLM_EXPLORER, L"DocFolderPaths", szName, REG_SZ, pszPath, (lstrlen(pszPath) + 1) * sizeof(TCHAR)); }
SetFolderString(TRUE, pszPath, NULL, L"DeleteOnCopy", SZ_CANBEUNICODE TEXT("Owner"), szName); wsprintf(szName, L"%d", pfi->id); SetFolderString(TRUE, pszPath, NULL, L"DeleteOnCopy", TEXT("Personalized"), szName); LoadDefaultString(pfi->idsDefault, szName, ARRAYSIZE(szName)); SetFolderString(TRUE, pszPath, NULL, L"DeleteOnCopy", SZ_CANBEUNICODE TEXT("PersonalizedName"), szName); } } }}
HRESULT VerifyAndCreateFolder(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPTSTR pszPath){ HRESULT hr = _IsFolderNotFile(pszPath);
// this code supports a UI mode of this API. but generally this is not used
// this code should be removed
if ((hr != S_OK) && hwnd) { // we might be able to reconnect if this is a net path
if (PathIsUNC(pszPath)) { if (SHValidateUNC(hwnd, pszPath, 0)) hr = _IsFolderNotFile(pszPath); } else if (IsDisconnectedNetDrive(DRIVEID(pszPath))) { TCHAR szDrive[3]; PathBuildSimpleRoot(DRIVEID(pszPath), szDrive);
if (WNetRestoreConnection(hwnd, szDrive) == WN_SUCCESS) hr = _IsFolderNotFile(pszPath); } }
// to avoid a sequence of long net timeouts or calls we know won't
// succeed test for these specific errors and don't try to create
// the folder
if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) || hr == HRESULT_FROM_WIN32(ERROR_BAD_NETPATH)) { return hr; }
if ((hr != S_OK) && (uFlags & CSIDL_FLAG_CREATE)) { DWORD err = SHCreateDirectory(NULL, pszPath); hr = HRESULT_FROM_WIN32(err); if (hr == S_OK) { ASSERT(NULL == StrChr(pszPath, TEXT('%')));
if (pfi->dwFlags & SDIF_HIDE) SetFileAttributes(pszPath, GetFileAttributes(pszPath) | FILE_ATTRIBUTE_HIDDEN);
_PostCreateStuff(pfi, pszPath, FALSE); } } else if (hr == S_OK) { if (uFlags & CSIDL_FLAG_PER_USER_INIT) _PostCreateStuff(pfi, pszPath, TRUE); }
return hr;}
void _SetPathCache(const FOLDER_INFO *pfi, LPCTSTR psz){ LPTSTR pszOld = (LPTSTR)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].psz, (void *)psz); if (pszOld && pszOld != (LPTSTR)-1) { // check for the concurent use... very rare case
LocalFree(pszOld); }}
HRESULT _GetFolderPathCached(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPTSTR pszPath){ HRESULT hr;
*pszPath = 0;
// can only cache for the current user, hToken == NULL or per machine folders
if (!hToken || (pfi->hKey != HKEY_CURRENT_USER)) { _UpdateShellFolderCache();
LPTSTR pszCache = (LPTSTR)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].psz, (void *)-1); if ((pszCache == (LPTSTR)-1) || (pszCache == NULL)) { // either not cached or cached failed state
if ((pszCache == (LPTSTR)-1) || (uFlags & (CSIDL_FLAG_CREATE | CSIDL_FLAG_DONT_VERIFY))) { hr = _GetFolderPath(hwnd, pfi, hToken, uFlags, pszPath);
// only set the cache value if CSIDL_FLAG_DONT_VERIFY was NOT passed
if (!(uFlags & CSIDL_FLAG_DONT_VERIFY)) { if (hr == S_OK) { // dupe the string so we can add it to the cache
pszCache = StrDup(pszPath); } else { // we failed to get the folder path, null out the cache
ASSERT(*pszPath == 0); pszCache = NULL; } _SetPathCache(pfi, pszCache); } } else { // cache was null and user didnt pass create flag so we just fail
ASSERT(pszCache == NULL); ASSERT(*pszPath == 0); hr = E_FAIL; } } else { // cache hit case: copy the cached string and then restore the cached value back
lstrcpyn(pszPath, pszCache, MAX_PATH); _SetPathCache(pfi, pszCache); hr = S_OK; } } else { hr = _GetFolderPath(hwnd, pfi, hToken, uFlags, pszPath); }
return hr;}
// NOTE: possibly we need a csidlSkip param to avoid recursion?
BOOL _ReparentAliases(HWND hwnd, HANDLE hToken, LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlAlias, DWORD dwXlateAliases){ static const struct {DWORD dwXlate; int idPath; int idAlias; BOOL fCommon;} s_rgidAliases[]= { { XLATEALIAS_MYDOCS, CSIDL_PERSONAL | CSIDL_FLAG_NO_ALIAS, CSIDL_PERSONAL, FALSE}, { XLATEALIAS_COMMONDOCS, CSIDL_COMMON_DOCUMENTS | CSIDL_FLAG_NO_ALIAS, CSIDL_COMMON_DOCUMENTS, FALSE}, { XLATEALIAS_DESKTOP, CSIDL_DESKTOPDIRECTORY, CSIDL_DESKTOP, FALSE}, { XLATEALIAS_DESKTOP, CSIDL_COMMON_DESKTOPDIRECTORY, CSIDL_DESKTOP, TRUE}, }; BOOL fContinue = TRUE; *ppidlAlias = NULL; for (int i = 0; fContinue && i < ARRAYSIZE(s_rgidAliases); i++) { LPITEMIDLIST pidlPath; if ((dwXlateAliases & s_rgidAliases[i].dwXlate) && (S_OK == SHGetFolderLocation(hwnd, s_rgidAliases[i].idPath, hToken, 0, &pidlPath))) { LPCITEMIDLIST pidlChild = ILFindChild(pidlPath, pidl); if (pidlChild) { // ok we need to use the alias instead of the path
LPITEMIDLIST pidlAlias; if (S_OK == SHGetFolderLocation(hwnd, s_rgidAliases[i].idAlias, hToken, 0, &pidlAlias)) { if (SUCCEEDED(SHILCombine(pidlAlias, pidlChild, ppidlAlias))) { if (s_rgidAliases[i].fCommon && !ILIsEmpty(*ppidlAlias)) { // find the size of the special part (subtacting for null pidl terminator)
UINT cbSize = ILGetSize(pidlAlias) - sizeof(pidlAlias->mkid.cb); LPITEMIDLIST pidlChildFirst = _ILSkip(*ppidlAlias, cbSize);
// We set the first ID under the common path to have the SHID_FS_COMMONITEM so that when we bind we
// can hand this to the proper merged psf
pidlChildFirst->mkid.abID[0] |= SHID_FS_COMMONITEM; } ILFree(pidlAlias); } fContinue = FALSE; } } ILFree(pidlPath); } }
return (*ppidlAlias != NULL);}
STDAPI SHILAliasTranslate(LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlAlias, DWORD dwXlateAliases){ return _ReparentAliases(NULL, NULL, pidl, ppidlAlias, dwXlateAliases) ? S_OK : E_FAIL;} HRESULT _CreateFolderIDList(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPITEMIDLIST *ppidl){ HRESULT hr = S_OK;
*ppidl = NULL; // assume failure or empty
if (pfi->id == CSIDL_PRINTERS && (ACF_STAROFFICE5PRINTER & SHGetAppCompatFlags(ACF_STAROFFICE5PRINTER))) { // Star Office 5.0 relies on the fact that the printer pidl used to be like below. They skip the
// first simple pidl (My Computer) and do not check if there is anything else, they assume that the
// second simple pidl is the Printer folder one. (stephstm, 07/30/99)
// CLSID_MyComputer, CLSID_Printers
hr = ILCreateFromPathEx(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}"), NULL, ILCFP_FLAG_NO_MAP_ALIAS, ppidl, NULL); } else if (pfi->id == CSIDL_COMPUTERSNEARME) { if (IsOS(OS_DOMAINMEMBER)) { // only if you are in a workgroup - fail otherwise
hr = E_FAIL; } else { // we computer this IDLIST from the domain/workgroup you are a member of
hr = SHGetDomainWorkgroupIDList(ppidl); } } else if ((pfi->id == CSIDL_COMMON_DOCUMENTS) && !(uFlags & CSIDL_FLAG_NO_ALIAS)) { // CLSID_MyComputer \ SharedDocumnets (canonical name)
hr = ILCreateFromPathEx(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{59031a47-3f72-44a7-89c5-5595fe6b30ee},SharedDocuments"), NULL, ILCFP_FLAG_NO_MAP_ALIAS, ppidl, NULL); } else if ((pfi->dwFlags & SDIF_CONST_IDLIST) && (!(uFlags & CSIDL_FLAG_NO_ALIAS) || !(pfi->dwFlags & SDIF_MAYBE_ALIASED))) { // these are CONST, never change
hr = SHILClone(g_aFolderCache[pfi->id].pidl, ppidl); } else { TCHAR szPath[MAX_PATH]; hr = _GetFolderPathCached(hwnd, pfi, hToken, uFlags, szPath); if (hr == S_OK) { HRESULT hrInit = SHCoInitialize(); hr = ILCreateFromPathEx(szPath, NULL, ILCFP_FLAG_SKIPJUNCTIONS, ppidl, NULL);
// attempt to reparent aliased pidls.
if (SUCCEEDED(hr) && (pfi->dwFlags & SDIF_MAYBE_ALIASED) && !(uFlags & CSIDL_FLAG_NO_ALIAS)) { LPITEMIDLIST pidlAlias; if (_ReparentAliases(hwnd, hToken, *ppidl, &pidlAlias, XLATEALIAS_ALL)) { ILFree(*ppidl); *ppidl = pidlAlias; } } SHCoUninitialize(hrInit); } } return hr;}
void _SetIDListCache(const FOLDER_INFO *pfi, LPCITEMIDLIST pidl, BOOL fNonAlias){ if (fNonAlias || !(pfi->dwFlags & SDIF_CONST_IDLIST)) { void **ppv = (void **) (fNonAlias ? &g_aFolderCache[pfi->id].pidlNonAlias : &g_aFolderCache[pfi->id].pidl); LPITEMIDLIST pidlOld = (LPITEMIDLIST)InterlockedExchangePointer(ppv, (void *)pidl); if (pidlOld && pidlOld != (LPITEMIDLIST)-1) { // check for the concurent use... very rare case
// ASSERT(pidl == (LPCITEMIDLIST)-1); // should not really be ASSERT
ILFree(pidlOld); } }}
LPITEMIDLIST _GetIDListCache(const FOLDER_INFO *pfi, BOOL fNonAlias){ void **ppv = (void **) (fNonAlias ? &g_aFolderCache[pfi->id].pidlNonAlias : &g_aFolderCache[pfi->id].pidl); ASSERT(fNonAlias || !(pfi->dwFlags & SDIF_CONST_IDLIST)); return (LPITEMIDLIST)InterlockedExchangePointer(ppv, (void *)-1);}
// hold this lock for the minimal amout of time possible to avoid other users
// of this resource requring them to re-create the pidl
HRESULT _GetFolderIDListCached(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPITEMIDLIST *ppidl){ HRESULT hr; BOOL fNonAlias = uFlags & CSIDL_FLAG_NO_ALIAS;
ASSERT(pfi->id < ARRAYSIZE(g_aFolderCache));
if ((pfi->dwFlags & SDIF_CONST_IDLIST) && (!fNonAlias || !(pfi->dwFlags & SDIF_MAYBE_ALIASED))) { // these are CONST, never change
hr = SHILClone(g_aFolderCache[pfi->id].pidl, ppidl); } else { LPITEMIDLIST pidlCache;
_UpdateShellFolderCache(); pidlCache = _GetIDListCache(pfi, fNonAlias);
if ((pidlCache == (LPCITEMIDLIST)-1) || (pidlCache == NULL)) { // either uninitalized cache state OR cached failure (NULL)
if ((pidlCache == (LPCITEMIDLIST)-1) || (uFlags & CSIDL_FLAG_CREATE)) { // not initialized (or concurent use) try creating it for this use
hr = _CreateFolderIDList(hwnd, pfi, NULL, uFlags, ppidl); if (S_OK == hr) hr = SHILClone(*ppidl, &pidlCache); // create cache copy
else pidlCache = NULL; } else hr = E_FAIL; // return cached failure
} else { hr = SHILClone(pidlCache, ppidl); // cache hit
}
// store back the PIDL if it is non NULL or they specified CREATE
// and we failed to create it (cache the not existant state). this is needed
// so we don't cache a NULL if the first callers don't ask for create and
// subsequent callers do
if (pidlCache || (uFlags & CSIDL_FLAG_CREATE)) _SetIDListCache(pfi, pidlCache, fNonAlias); }
return hr;}
void _ClearCacheEntry(const FOLDER_INFO *pfi){ if (!(pfi->dwFlags & SDIF_CONST_IDLIST)) _SetIDListCache(pfi, (LPCITEMIDLIST)-1, FALSE);
if (pfi->dwFlags & SDIF_MAYBE_ALIASED) _SetIDListCache(pfi, (LPCITEMIDLIST)-1, TRUE); _SetPathCache(pfi, (LPCTSTR)-1);}
void _ClearAllCacheEntrys(){ for (const FOLDER_INFO *pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { _ClearCacheEntry(pfi); }}
void _ClearAllAliasCacheEntrys(){ for (const FOLDER_INFO *pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { if (pfi->dwFlags & SDIF_MAYBE_ALIASED) { _SetIDListCache(pfi, (LPCITEMIDLIST)-1, FALSE); // nuke the aliased pidl
} }}
// Per instance count of mods to Special Folder cache.
EXTERN_C HANDLE g_hCounter;HANDLE g_hCounter = NULL; // Global count of mods to Special Folder cache.
int g_lPerProcessCount = 0;
// Make sure the special folder cache is up to date.
void _UpdateShellFolderCache(void){ HANDLE hCounter = SHGetCachedGlobalCounter(&g_hCounter, &GUID_SystemPidlChange);
// Is the cache up to date?
long lGlobalCount = SHGlobalCounterGetValue(hCounter); if (lGlobalCount != g_lPerProcessCount) { _ClearAllCacheEntrys(); g_lPerProcessCount = lGlobalCount; }}
STDAPI_(void) SHFlushSFCache(void){ // Increment the shared variable; the per-process versions will no
// longer match, causing this and/or other processes to refresh their
// pidl caches when they next need to access a folder.
if (g_hCounter) SHGlobalCounterIncrement(g_hCounter);}
// use SHGetFolderLocation() instead using CSIDL_FLAG_CREATE
STDAPI_(LPITEMIDLIST) SHCloneSpecialIDList(HWND hwnd, int csidl, BOOL fCreate){ LPITEMIDLIST pidlReturn;
if (fCreate) csidl |= CSIDL_FLAG_CREATE;
SHGetSpecialFolderLocation(hwnd, csidl, &pidlReturn); return pidlReturn;}
STDAPI SHGetSpecialFolderLocation(HWND hwnd, int csidl, LPITEMIDLIST *ppidl){ HRESULT hr = SHGetFolderLocation(hwnd, csidl, NULL, 0, ppidl); if (hr == S_FALSE) hr = E_FAIL; // mail empty case into failure for compat with this API
return hr;}
// return IDLIST for special folder
// fCreate encoded in csidl with CSIDL_FLAG_CREATE (new for NT5)
//
// in:
// hwnd should be NULL
// csidl CSIDL_ value with CSIDL_FLAG_ values ORed in as well
// dwType must be SHGFP_TYPE_CURRENT
//
// out:
// *ppild NULL on failure or empty, PIDL to be freed by caller on success
//
// returns:
// S_OK *ppidl is non NULL
// S_FALISE *ppidl is NULL, but valid csidl was passed (folder does not exist)
// FAILED(hr)
STDAPI SHGetFolderLocation(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPITEMIDLIST *ppidl){ const FOLDER_INFO *pfi; HRESULT hr;
*ppidl = NULL; // in case of error or empty
// -1 is an invalid csidl
if ((dwType != SHGFP_TYPE_CURRENT) || (-1 == csidl)) return E_INVALIDARG; // no flags used yet, validate this param
pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK); if (pfi) { HANDLE hTokenToFree = NULL;
if ((hToken == NULL) && (pfi->hKey == HKEY_CURRENT_USER)) { if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken)) hTokenToFree = hToken; } if (hToken && (pfi->hKey == HKEY_CURRENT_USER)) { // we don't cache PIDLs for other users, do all of the work
hr = _CreateFolderIDList(hwnd, pfi, hToken, csidl & CSIDL_FLAG_MASK, (LPITEMIDLIST *)ppidl); } else { hr = _GetFolderIDListCached(hwnd, pfi, csidl & CSIDL_FLAG_MASK, ppidl); }
if (hTokenToFree) CloseHandle(hTokenToFree); } else hr = E_INVALIDARG; // bad CSIDL (apps can check to veryify our support)
return hr;}
STDAPI_(BOOL) SHGetSpecialFolderPath(HWND hwnd, LPWSTR pszPath, int csidl, BOOL fCreate){ if (fCreate) csidl |= CSIDL_FLAG_CREATE; return SHGetFolderPath(hwnd, csidl, NULL, 0, pszPath) == S_OK;}
// in:
// hwnd should be NULL
// csidl CSIDL_ value with CSIDL_FLAG_ values ORed in as well
// dwType must be SHGFP_TYPE_CURRENT
//
// out:
// *pszPath MAX_PATH buffer to get path name, zeroed on failure or empty case
//
// returns:
// S_OK filled in pszPath with path value
// S_FALSE pszPath is NULL, valid CSIDL value, but this folder does not exist
// E_FAIL
STDAPI SHGetFolderPath(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPWSTR pszPath){ HRESULT hr = E_INVALIDARG; const FOLDER_INFO *pfi;
ASSERT(IS_VALID_WRITE_BUFFER(pszPath, TCHAR, MAX_PATH)); *pszPath = 0;
pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK); if (pfi && !(pfi->dwFlags & SDIF_NOT_FILESYS)) { switch (dwType) { case SHGFP_TYPE_DEFAULT: ASSERT((csidl & CSIDL_FLAG_MASK) == 0); // meaningless for default
hr = _GetFolderDefaultPath(pfi, hToken, pszPath); break; case SHGFP_TYPE_CURRENT: { HANDLE hTokenToFree = NULL; if ((hToken == NULL) && (pfi->hKey == HKEY_CURRENT_USER)) { if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken)) hTokenToFree = hToken; } hr = _GetFolderPathCached(hwnd, pfi, hToken, csidl & CSIDL_FLAG_MASK, pszPath);
if (hTokenToFree) CloseHandle(hTokenToFree); } break; } } return hr;}
STDAPI SHGetFolderPathA(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPSTR pszPath){ WCHAR wsz[MAX_PATH]; HRESULT hr = SHGetFolderPath(hwnd, csidl, hToken, dwType, wsz);
ASSERT(IS_VALID_WRITE_BUFFER(pszPath, CHAR, MAX_PATH));
SHUnicodeToAnsi(wsz, pszPath, MAX_PATH); return hr;}
STDAPI_(BOOL) SHGetSpecialFolderPathA(HWND hwnd, LPSTR pszPath, int csidl, BOOL fCreate){ if (fCreate) csidl |= CSIDL_FLAG_CREATE; return SHGetFolderPathA(hwnd, csidl, NULL, 0, pszPath) == S_OK;}
// Similar to SHGetFolderPath, but appends an optional subdirectory path after
// the csidl folder path. Handles creating the subdirectories.
STDAPI SHGetFolderPathAndSubDir(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubDir, LPWSTR pszPath){ HRESULT hr = SHGetFolderPath(hwnd, csidl, hToken, dwFlags, pszPath);
if (S_OK == hr && pszSubDir && *pszSubDir) { if (!PathAppend(pszPath, pszSubDir)) { hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE); } else if (csidl & CSIDL_FLAG_CREATE) { int err = SHCreateDirectoryEx(NULL, pszPath, NULL);
if (ERROR_ALREADY_EXISTS == err) { err = ERROR_SUCCESS; } hr = HRESULT_FROM_WIN32(err); } else if (!(csidl & CSIDL_FLAG_DONT_VERIFY)) { DWORD dwAttributes;
if (PathFileExistsAndAttributes(pszPath, &dwAttributes)) { if ((dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { hr = HRESULT_FROM_WIN32(ERROR_FILE_EXISTS); } } else { hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND); } }
if (S_OK != hr) { *pszPath = 0; } }
return hr;}
STDAPI SHGetFolderPathAndSubDirA(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubDir, LPSTR pszPath){ WCHAR wsz[MAX_PATH]; WCHAR wszSubDir[MAX_PATH];
SHAnsiToUnicode(pszSubDir, wszSubDir, MAX_PATH);
HRESULT hr = SHGetFolderPathAndSubDir(hwnd, csidl, hToken, dwFlags, wszSubDir, wsz);
ASSERT(IS_VALID_WRITE_BUFFER(pszPath, CHAR, MAX_PATH));
SHUnicodeToAnsi(wsz, pszPath, MAX_PATH); return hr;}
// HRESULT SHSetFolderPath (int csidl, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath)
//
// in:
// csidl CSIDL_ value with CSIDL_FLAG_ values ORed in as well
// dwFlags reserved: should be 0x00000000
// pszPath path to change shell folder to (will optionally be unexpanded)
//
// returns:
// S_OK function succeeded and flushed cache
STDAPI SHSetFolderPath(int csidl, HANDLE hToken, DWORD dwFlags, LPCTSTR pszPath){ HRESULT hr = E_INVALIDARG;
// Validate csidl and dwFlags. Add extra valid flags as needed.
RIPMSG(((csidl & CSIDL_FLAG_MASK) & ~(CSIDL_FLAG_DONT_UNEXPAND | 0x00000000)) == 0, "SHSetFolderPath: CSIDL flag(s) invalid"); RIPMSG(dwFlags == 0, "SHSetFolderPath: dwFlags parameter must be 0x00000000");
// Exit with E_INVALIDARG if bad parameters.
if ((((csidl & CSIDL_FLAG_MASK) & ~(CSIDL_FLAG_DONT_UNEXPAND | 0x00000000)) != 0) || (dwFlags != 0) || (pszPath == NULL) || (pszPath[0] == 0)) { return hr; }
const FOLDER_INFO *pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK);
// Only allow setting for SDIF_NOT_FILESYS is clear
// SDIF_NOT_TRACKED is clear
// SDIF_CANT_MOVE_RENAME is clear
// and for non-NULL value
// If HKLM is used then rely on security or registry restrictions
// to enforce whether the change can be made.
if ((pfi != NULL) && ((pfi->dwFlags & (SDIF_NOT_FILESYS | SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME)) == 0)) { BOOL fSuccessfulUnexpand, fSuccessfulExpand, fEmptyOrNullPath; LONG lError; HANDLE hTokenToFree; TCHAR szPath[MAX_PATH]; TCHAR szExpandedPath[MAX_PATH]; // holds expanded path for "Shell Folder" compat key
LPCTSTR pszWritePath;
hTokenToFree = NULL; if ((hToken == NULL) && (pfi->hKey == HKEY_CURRENT_USER)) { if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken)) { hTokenToFree = hToken; } }
fEmptyOrNullPath = ((pszPath == NULL) || (pszPath[0] == 0)); if (fEmptyOrNullPath) { HKEY hKeyDefaultUser;
pszWritePath = NULL; if (SUCCEEDED(_OpenKeyForFolder(pfi, (HANDLE)-1, TEXT("User Shell Folders"), &hKeyDefaultUser))) { DWORD dwPathSize = sizeof(szPath); if (ERROR_SUCCESS == RegQueryValueEx(hKeyDefaultUser, pfi->pszValueName, NULL, NULL, (LPBYTE)szPath, &dwPathSize)) { pszWritePath = szPath; } RegCloseKey(hKeyDefaultUser); } fSuccessfulUnexpand = TRUE; } else if (csidl & CSIDL_FLAG_DONT_UNEXPAND) { // Does the caller want to write the string as is? Leave
// it alone if so.
pszWritePath = pszPath; fSuccessfulUnexpand = TRUE; } else { if (pfi->hKey == HKEY_CURRENT_USER) { fSuccessfulUnexpand = (PathUnExpandEnvStringsForUser(hToken, pszPath, szPath, ARRAYSIZE(szPath)) != FALSE); } else { fSuccessfulUnexpand = FALSE; }
// Choose the appropriate source if the unexpansion was successful or not.
// Either way the unexpansion failure should be ignored.
if (fSuccessfulUnexpand) { pszWritePath = szPath; } else { fSuccessfulUnexpand = TRUE; pszWritePath = pszPath; } }
if (fSuccessfulUnexpand) { HKEY hKeyUser, hKeyUSF, hKeyToFree;
// we also get the fully expanded path so that we can write it out to the "Shell Folders" key for apps that depend on
// the old registry values
fSuccessfulExpand = (SHExpandEnvironmentStringsForUser(hToken, pszPath, szExpandedPath, ARRAYSIZE(szExpandedPath)) != 0);
// Get either the current users HKCU or HKU\SID if a token
// was specified and running in NT.
if (hToken && GetUserProfileKey(hToken, &hKeyUser)) { hKeyToFree = hKeyUser; } else { hKeyUser = pfi->hKey; hKeyToFree = NULL; }
// Open the key to the User Shell Folders and write the string
// there. Clear the shell folder cache.
// NOTE: This functionality is duplicated in SetFolderPath but
// that function deals with the USF key only. This function
// requires HKU\SID so while there is identical functionality
// from the point of view of settings the USF value that is
// where it ends. To make this function simple it just writes
// the value to registry itself.
// Additional note: there is a threading issue here with
// clearing the cache entry incrementing the counter. This
// should be locked access.
lError = RegOpenKeyEx(hKeyUser, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"), 0, KEY_READ | KEY_WRITE, &hKeyUSF); if (lError == ERROR_SUCCESS) { if (pszWritePath) { lError = RegSetValueEx(hKeyUSF, pfi->pszValueName, 0, REG_EXPAND_SZ, (LPBYTE)pszWritePath, (lstrlen(pszWritePath) + sizeof('\0')) * sizeof(TCHAR)); } else { lError = RegDeleteValue(hKeyUSF, pfi->pszValueName); } RegCloseKey(hKeyUSF);
// nuke the cache state for this folder
_ClearCacheEntry(pfi);
// and all folders that might be aliased as those
// could be related to this folder (under MyDocs for example)
// and now their aliases forms my no longer be valid
_ClearAllAliasCacheEntrys();
g_lPerProcessCount = SHGlobalCounterIncrement(g_hCounter); }
// update the old "Shell Folders" value for compat
if ((lError == ERROR_SUCCESS) && fSuccessfulExpand) { HKEY hkeySF;
if (RegOpenKeyEx(hKeyUser, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"), 0, KEY_READ | KEY_WRITE, &hkeySF) == ERROR_SUCCESS) { if (pszWritePath) { RegSetValueEx(hkeySF, pfi->pszValueName, 0, REG_SZ, (LPBYTE)szExpandedPath, (lstrlen(szExpandedPath) + sizeof('\0')) * sizeof(TCHAR)); } else { RegDeleteValue(hkeySF, pfi->pszValueName); }
RegCloseKey(hkeySF); } }
if ((lError == ERROR_SUCCESS) && (pfi->hKey == HKEY_CURRENT_USER)) { switch (csidl & ~CSIDL_FLAG_MASK) { case CSIDL_APPDATA: { HKEY hKeyVolatileEnvironment;
// In the case of AppData there is a matching environment variable
// for this shell folder. Make sure the place in the registry where
// userenv.dll places this value is updated and correct so that when
// the user context is created by winlogon it will have the updated
// value.
// It's probably also a good thing to check for a %APPDATA% variable
// in the calling process' context but this would only be good for
// the life of the process. What is really required is a mechanism
// to change the environment variable for the entire logon session.
lError = RegOpenKeyEx(hKeyUser, TEXT("Volatile Environment"), 0, KEY_READ | KEY_WRITE, &hKeyVolatileEnvironment); if (lError == ERROR_SUCCESS) { if (SUCCEEDED(SHGetFolderPath(NULL, csidl | CSIDL_FLAG_DONT_VERIFY, hToken, SHGFP_TYPE_CURRENT, szPath))) { lError = RegSetValueEx(hKeyVolatileEnvironment, TEXT("APPDATA"), 0, REG_SZ, (LPBYTE)szPath, (lstrlen(szPath) + sizeof('\0')) * sizeof(TCHAR)); } RegCloseKey(hKeyVolatileEnvironment); } break; } } }
if (hKeyToFree) { RegCloseKey(hKeyToFree); }
if (lError == ERROR_SUCCESS) { hr = S_OK; } else { hr = HRESULT_FROM_WIN32(lError); } } if (hTokenToFree) { CloseHandle(hTokenToFree); }
SHChangeDWORDAsIDList dwidl = { sizeof(dwidl) - sizeof(dwidl.cbZero), SHCNEE_UPDATEFOLDERLOCATION, csidl & ~CSIDL_FLAG_MASK, 0}; SHChangeNotify(SHCNE_EXTENDED_EVENT, SHCNF_ONLYNOTIFYINTERNALS | SHCNF_IDLIST, (LPCITEMIDLIST)&dwidl, NULL); }
return hr;}
STDAPI SHSetFolderPathA(int csidl, HANDLE hToken, DWORD dwType, LPCSTR pszPath){ WCHAR wsz[MAX_PATH];
SHAnsiToUnicode(pszPath, wsz, ARRAYSIZE(wsz)); return SHSetFolderPath(csidl, hToken, dwType, wsz);}
// NOTE: called from DllEntry
void SpecialFolderIDTerminate(){ ASSERTDLLENTRY // does not require a critical section
_ClearAllCacheEntrys();
if (g_hCounter) { CloseHandle(g_hCounter); g_hCounter = NULL; }}
// update our cache and the registry for pfi with pszPath. this also invalidates the
// cache in other processes so they stay in sync
void SetFolderPath(const FOLDER_INFO *pfi, LPCTSTR pszPath){ _ClearCacheEntry(pfi); if (pszPath) { HKEY hk; if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, TEXT("User Shell Folders"), &hk))) { LONG err; TCHAR szDefaultPath[MAX_PATH]; // Check for an existing path, and if the unexpanded version
// of the existing path does not match the new path, then
// write the new path to the registry.
//
// RegQueryPath expands the environment variables for us
// so we can't just blindly set the new value to the registry.
//
RegQueryPath(hk, pfi->pszValueName, szDefaultPath); if (lstrcmpi(szDefaultPath, pszPath) != 0) { // The paths are different. Write to the registry as file
// system path.
err = SHRegSetPath(hk, NULL, pfi->pszValueName, pszPath, 0); } else { err = ERROR_SUCCESS; } // clear out any temp paths
RegSetFolderPath(pfi, TEXT("User Shell Folders\\New"), NULL); if (err == ERROR_SUCCESS) { // this will force a new creation (see TRUE as fCreate).
// This will also copy the path from "User Shell Folders"
// to "Shell Folders".
LPITEMIDLIST pidl; if (S_OK == _GetFolderIDListCached(NULL, pfi, CSIDL_FLAG_CREATE, &pidl)) { ILFree(pidl); } else { // failed! null out the entry. this will go back to our default
RegDeleteValue(hk, pfi->pszValueName); _ClearCacheEntry(pfi); } } RegCloseKey(hk); } } else { RegSetFolderPath(pfi, TEXT("User Shell Folders"), NULL); // clear out any temp paths
RegSetFolderPath(pfi, TEXT("User Shell Folders\\New"), NULL); } // set the global different from the per process variable
// to signal an update needs to happen other processes
g_lPerProcessCount = SHGlobalCounterIncrement(g_hCounter);}
// file system change notifies come in here AFTER the folders have been moved/deleted
// we fix up the registry to match what occured in the file system
EXTERN_C void SFP_FSEvent(LONG lEvent, LPITEMIDLIST pidl, LPITEMIDLIST pidlExtra){ const FOLDER_INFO *pfi; TCHAR szSrc[MAX_PATH];
if (!(lEvent & (SHCNE_RENAMEFOLDER | SHCNE_RMDIR | SHCNE_MKDIR)) || !SHGetPathFromIDList(pidl, szSrc) || (pidlExtra && ILIsEqual(pidl, pidlExtra))) // when volume label changes, pidl==pidlExtra so we detect this case and skip it for perf
{ return; }
for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { if (0 == (pfi->dwFlags & (SDIF_NOT_TRACKED | SDIF_NOT_FILESYS))) { TCHAR szCurrent[MAX_PATH]; if (S_OK == _GetFolderPathCached(NULL, pfi, NULL, CSIDL_FLAG_DONT_VERIFY, szCurrent) && PathIsEqualOrSubFolder(szSrc, szCurrent)) { TCHAR szDest[MAX_PATH];
szDest[0] = 0;
if (lEvent & SHCNE_RMDIR) { // complete the "move accross volume" case
HKEY hk; if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, TEXT("User Shell Folders\\New"), &hk))) { RegQueryPath(hk, pfi->pszValueName, szDest); RegCloseKey(hk); } } else if (pidlExtra) { SHGetPathFromIDList(pidlExtra, szDest); }
if (szDest[0]) { // rename the specal folder
UINT cch = PathCommonPrefix(szCurrent, szSrc, NULL); ASSERT(cch != 0); if (szCurrent[cch]) { PathAppend(szDest, szCurrent + cch); }
SetFolderPath(pfi, szDest); } } } }}
ULONG _ILGetChildOffset(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild){ DWORD cbOff = 0; LPCITEMIDLIST pidlChildT = ILFindChild(pidlParent, pidlChild); if (pidlChildT) { cbOff = (ULONG)((LPBYTE)pidlChildT - (LPBYTE)pidlChild); } return cbOff;}
// returns the first special folder CSIDL_ id that is a parent
// of the passed in pidl or 0 if not found. only CSIDL_ entries marked as
// SDIF_SHORTCUT_RELATIVE are considered for this.
//
// returns:
// CSIDL_ values
// *pcbOffset offset into pidl
STDAPI_(int) GetSpecialFolderParentIDAndOffset(LPCITEMIDLIST pidl, ULONG *pcbOffset){ int iRet = 0; // everything is desktop relative
const FOLDER_INFO *pfi;
*pcbOffset = 0;
for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { if (pfi->dwFlags & SDIF_SHORTCUT_RELATIVE) { LPITEMIDLIST pidlFolder; if (S_OK == _GetFolderIDListCached(NULL, pfi, 0, &pidlFolder)) { ULONG cbOff = _ILGetChildOffset(pidlFolder, pidl); if (cbOff > *pcbOffset) { *pcbOffset = cbOff; iRet = pfi->id; } ILFree(pidlFolder); } } } return iRet;}
// note, only works for file system path (bummer, we would like others supported too)
STDAPI_(BOOL) MakeShellURLFromPath(LPCTSTR pszPathIn, LPTSTR pszUrl, DWORD dwCch){ const FOLDER_INFO *pfi;
for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++) { if ((pfi->dwFlags & SDIF_SHORTCUT_RELATIVE) && !(pfi->dwFlags & SDIF_NOT_FILESYS)) { TCHAR szCurrent[MAX_PATH]; if (S_OK == _GetFolderPathCached(NULL, pfi, 0, CSIDL_FLAG_DONT_VERIFY, szCurrent)) { if (PathIsPrefix(szCurrent, pszPathIn)) { StrCpy(pszUrl, TEXT("shell:")); StrCat(pszUrl, pfi->pszValueName); PathAppend(pszUrl, &pszPathIn[lstrlen(szCurrent)]);
return TRUE; } } } } return FALSE;}
STDAPI_(BOOL) MakeShellURLFromPathA(LPCSTR pszPathIn, LPSTR pszUrl, DWORD dwCch){ WCHAR szTmp1[MAX_PATH], szTmp2[MAX_PATH]; SHAnsiToUnicode(pszPathIn, szTmp1, ARRAYSIZE(szTmp1));
BOOL bRet = MakeShellURLFromPathW(szTmp1, szTmp2, ARRAYSIZE(szTmp2));
SHUnicodeToAnsi(szTmp2, pszUrl, dwCch); return bRet;}
BOOL MoveBlockedByPolicy(const FOLDER_INFO *pfi){ BOOL bRet = FALSE; if (pfi->dwFlags & SDIF_POLICY_NO_MOVE) { // similar to code in mydocs.dll
TCHAR szValue[128]; wnsprintf(szValue, ARRAYSIZE(szValue), TEXT("Disable%sDirChange"), pfi->pszValueName); if (ERROR_SUCCESS == SHGetValue(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer"), szValue, NULL, NULL, NULL)) { bRet = TRUE; } } return bRet;}
// this is called from the copy engine (like all other copy hooks)
// this is where we put up UI blocking the delete/move of some special folders
EXTERN_C int PathCopyHookCallback(HWND hwnd, UINT wFunc, LPCTSTR pszSrc, LPCTSTR pszDest){ int ret = IDYES;
if ((wFunc == FO_DELETE) || (wFunc == FO_MOVE) || (wFunc == FO_RENAME)) { const FOLDER_INFO *pfi;
// is one of our system directories being affected?
for (pfi = c_rgFolderInfo; ret == IDYES && pfi->id != -1; pfi++) { // even non tracked folders (windows, system) come through here
if (0 == (pfi->dwFlags & SDIF_NOT_FILESYS)) { TCHAR szCurrent[MAX_PATH]; if (S_OK == _GetFolderPathCached(NULL, pfi, NULL, CSIDL_FLAG_DONT_VERIFY, szCurrent) && PathIsEqualOrSubFolder(pszSrc, szCurrent)) { // Yes
if (wFunc == FO_DELETE) { if (pfi->dwFlags & SDIF_CAN_DELETE) { SetFolderPath(pfi, NULL); // Let them delete some folders
} else { ShellMessageBox(HINST_THISDLL, hwnd, MAKEINTRESOURCE(IDS_CANTDELETESPECIALDIR), MAKEINTRESOURCE(IDS_DELETE), MB_OK | MB_ICONINFORMATION, PathFindFileName(pszSrc)); ret = IDNO; } } else { int idSrc = PathGetDriveNumber(pszSrc); int idDest = PathGetDriveNumber(pszDest);
ASSERT((wFunc == FO_MOVE) || (wFunc == FO_RENAME));
if ((pfi->dwFlags & SDIF_CANT_MOVE_RENAME) || ((idSrc != -1) && (idDest == -1) && !(pfi->dwFlags & SDIF_NETWORKABLE)) || ((idSrc != idDest) && PathIsRemovable(pszDest) && !(pfi->dwFlags & SDIF_REMOVABLE)) || MoveBlockedByPolicy(pfi)) { ShellMessageBox(HINST_THISDLL, hwnd, MAKEINTRESOURCE(IDS_CANTMOVESPECIALDIRHERE), wFunc == FO_MOVE ? MAKEINTRESOURCE(IDS_MOVE) : MAKEINTRESOURCE(IDS_RENAME), MB_ICONERROR, PathFindFileName(pszSrc)); ret = IDNO; } else { //
// store this info here
// if we need it we will use it.
//
// we used to try to optimise in the case of same
// volume renames. we assumed that if it was the same
// volume we would later get a SHCNE_RENAME. but sometimes
// we have to do a copy even on the same volume. so
// we need to always set this value.
//
RegSetFolderPath(pfi, TEXT("User Shell Folders\\New"), pszDest); } } } } } } return ret;}
// Given a key name ("programs", "desktop", "start menu"), convert it to
// the corresponding CSIDL.
STDAPI_(int) SHGetSpecialFolderID(LPCWSTR pszName){ // make sure g_aFolderCache can be indexed by the CSIDL values
COMPILETIME_ASSERT((ARRAYSIZE(g_aFolderCache) - 1) == CSIDL_COMPUTERSNEARME);
for (int i = 0; c_rgFolderInfo[i].id != -1; i++) { if (c_rgFolderInfo[i].pszValueName && (0 == StrCmpI(pszName, c_rgFolderInfo[i].pszValueName))) { return c_rgFolderInfo[i].id; } }
return -1;}
// Given a CSIDL, returns the key name -- the opposite of
// SHGetSpecialFolderID
STDAPI_(LPCTSTR) SHGetSpecialFolderKey(int csidl){ const FOLDER_INFO *pfi = _GetFolderInfo(csidl); return pfi ? pfi->pszValueName : NULL;}
// Return the special folder ID, if this folder is one of them.
// At this point, we handle PROGRAMS folder only.
//
// GetSpecialFolderID()
// this allows a list of CSIDLs to be passed in.
// they will be searched in order for the specified csidl
// and the path will be checked against it.
// if -1 is specified as the csidl, then all of array entries should
// be checked for a match with the folder.
//
int GetSpecialFolderID(LPCTSTR pszFolder, const int *rgcsidl, UINT count){ for (UINT i = 0; i < count; i++) { int csidlSpecial = rgcsidl[i] & ~TEST_SUBFOLDER; TCHAR szPath[MAX_PATH]; if (S_OK == SHGetFolderPath(NULL, csidlSpecial | CSIDL_FLAG_DONT_VERIFY, NULL, SHGFP_TYPE_CURRENT, szPath)) { if (((rgcsidl[i] & TEST_SUBFOLDER) && PathIsEqualOrSubFolder(szPath, pszFolder)) || (lstrcmpi(szPath, pszFolder) == 0)) { return csidlSpecial; } } }
return -1;}
/**
* Tacks a name onto a CSIDL, e.g. gets a pidl for * CSIDL_COMMON_PICTURES\Sample Pictures * if it exists. * Called must free ppidlSampleMedia * Note: The folder is *not* created if it does not exist. */HRESULT _AppendPathToPIDL(int nAllUsersMediaFolder, LPCWSTR pszName, LPITEMIDLIST *ppidlSampleMedia){ LPITEMIDLIST pidlAllUsersMedia; HRESULT hr = SHGetFolderLocation(NULL, nAllUsersMediaFolder, NULL, 0, &pidlAllUsersMedia);
if (SUCCEEDED(hr)) { // Get the shellfolder for this guy.
IShellFolder *psf; hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidlAllUsersMedia, &psf)); if (SUCCEEDED(hr)) { // And now the pidl for the sample folder
LPITEMIDLIST pidlSampleMediaRel; ULONG dwAttributes = 0; hr = psf->ParseDisplayName(NULL, NULL, (LPOLESTR)pszName, NULL, &pidlSampleMediaRel, &dwAttributes); if (SUCCEEDED(hr)) { // It exists!
hr = SHILCombine(pidlAllUsersMedia, pidlSampleMediaRel, ppidlSampleMedia); ILFree(pidlSampleMediaRel); } psf->Release(); } ILFree(pidlAllUsersMedia); }
return hr;}
/**
* Returns a pidl to the samples folder under a particular CSIDL * Caller must free ppidlSampleMedia */HRESULT _ParseSubfolderResource(int csidl, UINT ids, LPITEMIDLIST *ppidl){ WCHAR szSub[MAX_PATH]; LoadDefaultString(ids, szSub, ARRAYSIZE(szSub));
return _AppendPathToPIDL(csidl, szSub, ppidl);}
HRESULT SHGetSampleMediaFolder(int nAllUsersMediaFolder, LPITEMIDLIST *ppidlSampleMedia){ UINT uID = -1; switch (nAllUsersMediaFolder) { case CSIDL_COMMON_PICTURES: uID = IDS_SAMPLEPICTURES; break; case CSIDL_COMMON_MUSIC: uID = IDS_SAMPLEMUSIC; break; default: ASSERT(FALSE); return E_INVALIDARG; break; } return _ParseSubfolderResource(nAllUsersMediaFolder, uID, ppidlSampleMedia);}
void _CreateLinkToSampleMedia(LPCWSTR pszNewFolderPath, int nAllUsersMediaFolder, UINT uIDSampleFolderName){ LPITEMIDLIST pidl; if (SUCCEEDED(SHGetSampleMediaFolder(nAllUsersMediaFolder, &pidl))) { // Check to make sure the link doesn't already exist.
WCHAR szSampleFolderName[MAX_PATH]; WCHAR szFullLnkPath[MAX_PATH]; LoadString(HINST_THISDLL, uIDSampleFolderName, szSampleFolderName, ARRAYSIZE(szSampleFolderName)); StrCatBuff(szSampleFolderName, L".lnk", ARRAYSIZE(szSampleFolderName)); if (PathCombine(szFullLnkPath, pszNewFolderPath, szSampleFolderName)) { if (!PathFileExists(szFullLnkPath)) { // MUI-WARNING - we are not doing a SHSetLocalizedName for this link - ZekeL - 15-MAY-2001
// this means that this link is always created in the default system UI language
// we should probably call SHSetLocalizedName() here but i am scared right now of perf implications.
CreateLinkToPidl(pidl, pszNewFolderPath, NULL, 0); } }
ILFree(pidl); }}
void _InitFolder(LPCTSTR pszPath, UINT idsInfoTip, HINSTANCE hinstIcon, UINT idiIcon){ // Set the default custom settings for the folder.
SHFOLDERCUSTOMSETTINGS fcs = {sizeof(fcs), 0}; TCHAR szInfoTip[128]; TCHAR szPath[MAX_PATH];
// Get the infotip for this folder
if (idsInfoTip) { wnsprintf(szInfoTip,ARRAYSIZE(szInfoTip),TEXT("@Shell32.dll,-%u"),idsInfoTip); fcs.pszInfoTip = szInfoTip; fcs.cchInfoTip = ARRAYSIZE(szInfoTip);
fcs.dwMask |= FCSM_INFOTIP; }
// this will be encoded to the %SystemRoot% style path when setting the folder information.
if (idiIcon) { GetModuleFileName(hinstIcon, szPath, ARRAYSIZE(szPath));
fcs.pszIconFile = szPath; fcs.cchIconFile = ARRAYSIZE(szPath); fcs.iIconIndex = idiIcon;
fcs.dwMask |= FCSM_ICONFILE; }
// NOTE: we need FCS_FORCEWRITE because we didn't used to specify iIconIndex
// and so "0" was written to the ini file. When we upgrade, this API won't
// fix the ini file unless we pass FCS_FORCEWRITE
SHGetSetFolderCustomSettings(&fcs, pszPath, FCS_FORCEWRITE);}
void _InitMyPictures(int id, LPCTSTR pszPath){ // Get the path to the icon. We reference MyDocs.dll for backwards compat.
HINSTANCE hinstMyDocs = LoadLibrary(TEXT("mydocs.dll")); if (hinstMyDocs) { _InitFolder(pszPath, IDS_FOLDER_MYPICS_TT, hinstMyDocs, -101); // known index for IDI_MYPICS in mydocs.dll
FreeLibrary(hinstMyDocs); }}
void _InitMyMusic(int id, LPCTSTR pszPath){ _InitFolder(pszPath, IDS_FOLDER_MYMUSIC_TT, HINST_THISDLL, -IDI_MYMUSIC);}
void _InitPerUserMyPictures(int id, LPCTSTR pszPath){ _InitMyPictures(id, pszPath);
_CreateLinkToSampleMedia(pszPath, CSIDL_COMMON_PICTURES, IDS_SAMPLEPICTURES);}
void _InitPerUserMyMusic(int id, LPCTSTR pszPath){ _InitMyMusic(id, pszPath);
_CreateLinkToSampleMedia(pszPath, CSIDL_COMMON_MUSIC, IDS_SAMPLEMUSIC);}
void _InitMyVideos(int id, LPCTSTR pszPath){ _InitFolder(pszPath, IDS_FOLDER_MYVIDEOS_TT, HINST_THISDLL, -IDI_MYVIDEOS);}
void _InitRecentDocs(int id, LPCTSTR pszPath){ _InitFolder(pszPath, IDS_FOLDER_RECENTDOCS_TT, HINST_THISDLL, -IDI_STDOCS); }
void _InitFavorites(int id, LPCTSTR pszPath){ _InitFolder(pszPath, 0, HINST_THISDLL, -IDI_FAVORITES);}
|
