4 * Copyright 1998, 1999, 2000 Juergen Schmied
5 * Copyright 2004 Juan Lang
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 * Many of these functions are in SHLWAPI.DLL also
28 #include "wine/port.h"
34 #include "wine/debug.h"
44 #include "shell32_main.h"
45 #include "undocshell.h"
47 #include "wine/unicode.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
55 ########## Combining and Constructing paths ##########
58 /*************************************************************************
59 * PathAppend [SHELL32.36]
61 BOOL WINAPI
PathAppendAW(
65 if (SHELL_OsIsUnicode())
66 return PathAppendW(lpszPath1
, lpszPath2
);
67 return PathAppendA(lpszPath1
, lpszPath2
);
70 /*************************************************************************
71 * PathCombine [SHELL32.37]
73 LPVOID WINAPI
PathCombineAW(
78 if (SHELL_OsIsUnicode())
79 return PathCombineW( szDest
, lpszDir
, lpszFile
);
80 return PathCombineA( szDest
, lpszDir
, lpszFile
);
83 /*************************************************************************
84 * PathAddBackslash [SHELL32.32]
86 LPVOID WINAPI
PathAddBackslashAW(LPVOID lpszPath
)
88 if(SHELL_OsIsUnicode())
89 return PathAddBackslashW(lpszPath
);
90 return PathAddBackslashA(lpszPath
);
93 /*************************************************************************
94 * PathBuildRoot [SHELL32.30]
96 LPVOID WINAPI
PathBuildRootAW(LPVOID lpszPath
, int drive
)
98 if(SHELL_OsIsUnicode())
99 return PathBuildRootW(lpszPath
, drive
);
100 return PathBuildRootA(lpszPath
, drive
);
104 Extracting Component Parts
107 /*************************************************************************
108 * PathFindFileName [SHELL32.34]
110 LPVOID WINAPI
PathFindFileNameAW(LPCVOID lpszPath
)
112 if(SHELL_OsIsUnicode())
113 return PathFindFileNameW(lpszPath
);
114 return PathFindFileNameA(lpszPath
);
117 /*************************************************************************
118 * PathFindExtension [SHELL32.31]
120 LPVOID WINAPI
PathFindExtensionAW(LPCVOID lpszPath
)
122 if (SHELL_OsIsUnicode())
123 return PathFindExtensionW(lpszPath
);
124 return PathFindExtensionA(lpszPath
);
128 /*************************************************************************
129 * PathGetExtensionA [internal]
132 * exported by ordinal
133 * return value points to the first char after the dot
135 static LPSTR
PathGetExtensionA(LPCSTR lpszPath
)
137 TRACE("(%s)\n",lpszPath
);
139 lpszPath
= PathFindExtensionA(lpszPath
);
140 return (LPSTR
)(*lpszPath
?(lpszPath
+1):lpszPath
);
143 /*************************************************************************
144 * PathGetExtensionW [internal]
146 static LPWSTR
PathGetExtensionW(LPCWSTR lpszPath
)
148 TRACE("(%s)\n",debugstr_w(lpszPath
));
150 lpszPath
= PathFindExtensionW(lpszPath
);
151 return (LPWSTR
)(*lpszPath
?(lpszPath
+1):lpszPath
);
154 /*************************************************************************
155 * PathGetExtension [SHELL32.158]
157 LPVOID WINAPI
PathGetExtensionAW(LPCVOID lpszPath
,DWORD void1
, DWORD void2
)
159 if (SHELL_OsIsUnicode())
160 return PathGetExtensionW(lpszPath
);
161 return PathGetExtensionA(lpszPath
);
164 /*************************************************************************
165 * PathGetArgs [SHELL32.52]
167 LPVOID WINAPI
PathGetArgsAW(LPVOID lpszPath
)
169 if (SHELL_OsIsUnicode())
170 return PathGetArgsW(lpszPath
);
171 return PathGetArgsA(lpszPath
);
174 /*************************************************************************
175 * PathGetDriveNumber [SHELL32.57]
177 int WINAPI
PathGetDriveNumberAW(LPVOID lpszPath
)
179 if (SHELL_OsIsUnicode())
180 return PathGetDriveNumberW(lpszPath
);
181 return PathGetDriveNumberA(lpszPath
);
184 /*************************************************************************
185 * PathRemoveFileSpec [SHELL32.35]
187 BOOL WINAPI
PathRemoveFileSpecAW(LPVOID lpszPath
)
189 if (SHELL_OsIsUnicode())
190 return PathRemoveFileSpecW(lpszPath
);
191 return PathRemoveFileSpecA(lpszPath
);
194 /*************************************************************************
195 * PathStripPath [SHELL32.38]
197 void WINAPI
PathStripPathAW(LPVOID lpszPath
)
199 if (SHELL_OsIsUnicode())
200 PathStripPathW(lpszPath
);
202 PathStripPathA(lpszPath
);
205 /*************************************************************************
206 * PathStripToRoot [SHELL32.50]
208 BOOL WINAPI
PathStripToRootAW(LPVOID lpszPath
)
210 if (SHELL_OsIsUnicode())
211 return PathStripToRootW(lpszPath
);
212 return PathStripToRootA(lpszPath
);
215 /*************************************************************************
216 * PathRemoveArgs [SHELL32.251]
218 void WINAPI
PathRemoveArgsAW(LPVOID lpszPath
)
220 if (SHELL_OsIsUnicode())
221 PathRemoveArgsW(lpszPath
);
223 PathRemoveArgsA(lpszPath
);
226 /*************************************************************************
227 * PathRemoveExtension [SHELL32.250]
229 void WINAPI
PathRemoveExtensionAW(LPVOID lpszPath
)
231 if (SHELL_OsIsUnicode())
232 PathRemoveExtensionW(lpszPath
);
234 PathRemoveExtensionA(lpszPath
);
242 /*************************************************************************
243 * PathGetShortPathA [internal]
245 static void PathGetShortPathA(LPSTR pszPath
)
249 TRACE("%s\n", pszPath
);
251 if (GetShortPathNameA(pszPath
, path
, MAX_PATH
))
253 lstrcpyA(pszPath
, path
);
257 /*************************************************************************
258 * PathGetShortPathW [internal]
260 static void PathGetShortPathW(LPWSTR pszPath
)
262 WCHAR path
[MAX_PATH
];
264 TRACE("%s\n", debugstr_w(pszPath
));
266 if (GetShortPathNameW(pszPath
, path
, MAX_PATH
))
268 lstrcpyW(pszPath
, path
);
272 /*************************************************************************
273 * PathGetShortPath [SHELL32.92]
275 VOID WINAPI
PathGetShortPathAW(LPVOID pszPath
)
277 if(SHELL_OsIsUnicode())
278 PathGetShortPathW(pszPath
);
279 PathGetShortPathA(pszPath
);
282 /*************************************************************************
283 * PathRemoveBlanks [SHELL32.33]
285 void WINAPI
PathRemoveBlanksAW(LPVOID str
)
287 if(SHELL_OsIsUnicode())
288 PathRemoveBlanksW(str
);
290 PathRemoveBlanksA(str
);
293 /*************************************************************************
294 * PathQuoteSpaces [SHELL32.55]
296 VOID WINAPI
PathQuoteSpacesAW (LPVOID lpszPath
)
298 if(SHELL_OsIsUnicode())
299 PathQuoteSpacesW(lpszPath
);
301 PathQuoteSpacesA(lpszPath
);
304 /*************************************************************************
305 * PathUnquoteSpaces [SHELL32.56]
307 VOID WINAPI
PathUnquoteSpacesAW(LPVOID str
)
309 if(SHELL_OsIsUnicode())
310 PathUnquoteSpacesW(str
);
312 PathUnquoteSpacesA(str
);
315 /*************************************************************************
316 * PathParseIconLocation [SHELL32.249]
318 int WINAPI
PathParseIconLocationAW (LPVOID lpszPath
)
320 if(SHELL_OsIsUnicode())
321 return PathParseIconLocationW(lpszPath
);
322 return PathParseIconLocationA(lpszPath
);
326 ########## Path Testing ##########
328 /*************************************************************************
329 * PathIsUNC [SHELL32.39]
331 BOOL WINAPI
PathIsUNCAW (LPCVOID lpszPath
)
333 if (SHELL_OsIsUnicode())
334 return PathIsUNCW( lpszPath
);
335 return PathIsUNCA( lpszPath
);
338 /*************************************************************************
339 * PathIsRelative [SHELL32.40]
341 BOOL WINAPI
PathIsRelativeAW (LPCVOID lpszPath
)
343 if (SHELL_OsIsUnicode())
344 return PathIsRelativeW( lpszPath
);
345 return PathIsRelativeA( lpszPath
);
348 /*************************************************************************
349 * PathIsRoot [SHELL32.29]
351 BOOL WINAPI
PathIsRootAW(LPCVOID lpszPath
)
353 if (SHELL_OsIsUnicode())
354 return PathIsRootW(lpszPath
);
355 return PathIsRootA(lpszPath
);
358 /*************************************************************************
359 * PathIsExeA [internal]
361 static BOOL
PathIsExeA (LPCSTR lpszPath
)
363 LPCSTR lpszExtension
= PathGetExtensionA(lpszPath
);
365 static const char * const lpszExtensions
[] =
366 {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL
};
368 TRACE("path=%s\n",lpszPath
);
370 for(i
=0; lpszExtensions
[i
]; i
++)
371 if (!lstrcmpiA(lpszExtension
,lpszExtensions
[i
])) return TRUE
;
376 /*************************************************************************
377 * PathIsExeW [internal]
379 static BOOL
PathIsExeW (LPCWSTR lpszPath
)
381 LPCWSTR lpszExtension
= PathGetExtensionW(lpszPath
);
383 static const WCHAR lpszExtensions
[][4] =
384 {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
385 {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
386 {'s','c','r','\0'}, {'\0'} };
388 TRACE("path=%s\n",debugstr_w(lpszPath
));
390 for(i
=0; lpszExtensions
[i
][0]; i
++)
391 if (!strcmpiW(lpszExtension
,lpszExtensions
[i
])) return TRUE
;
396 /*************************************************************************
397 * PathIsExe [SHELL32.43]
399 BOOL WINAPI
PathIsExeAW (LPCVOID path
)
401 if (SHELL_OsIsUnicode())
402 return PathIsExeW (path
);
403 return PathIsExeA(path
);
406 /*************************************************************************
407 * PathIsDirectory [SHELL32.159]
409 BOOL WINAPI
PathIsDirectoryAW (LPCVOID lpszPath
)
411 if (SHELL_OsIsUnicode())
412 return PathIsDirectoryW (lpszPath
);
413 return PathIsDirectoryA (lpszPath
);
416 /*************************************************************************
417 * PathFileExists [SHELL32.45]
419 BOOL WINAPI
PathFileExistsAW (LPCVOID lpszPath
)
421 if (SHELL_OsIsUnicode())
422 return PathFileExistsW (lpszPath
);
423 return PathFileExistsA (lpszPath
);
426 /*************************************************************************
427 * PathMatchSpec [SHELL32.46]
429 BOOL WINAPI
PathMatchSpecAW(LPVOID name
, LPVOID mask
)
431 if (SHELL_OsIsUnicode())
432 return PathMatchSpecW( name
, mask
);
433 return PathMatchSpecA( name
, mask
);
436 /*************************************************************************
437 * PathIsSameRoot [SHELL32.650]
439 BOOL WINAPI
PathIsSameRootAW(LPCVOID lpszPath1
, LPCVOID lpszPath2
)
441 if (SHELL_OsIsUnicode())
442 return PathIsSameRootW(lpszPath1
, lpszPath2
);
443 return PathIsSameRootA(lpszPath1
, lpszPath2
);
446 /*************************************************************************
447 * IsLFNDriveA [SHELL32.41]
449 BOOL WINAPI
IsLFNDriveA(LPCSTR lpszPath
)
453 if (!GetVolumeInformationA(lpszPath
, NULL
, 0, NULL
, &fnlen
, NULL
, NULL
, 0))
458 /*************************************************************************
459 * IsLFNDriveW [SHELL32.42]
461 BOOL WINAPI
IsLFNDriveW(LPCWSTR lpszPath
)
465 if (!GetVolumeInformationW(lpszPath
, NULL
, 0, NULL
, &fnlen
, NULL
, NULL
, 0))
470 /*************************************************************************
471 * IsLFNDrive [SHELL32.119]
473 BOOL WINAPI
IsLFNDriveAW(LPCVOID lpszPath
)
475 if (SHELL_OsIsUnicode())
476 return IsLFNDriveW(lpszPath
);
477 return IsLFNDriveA(lpszPath
);
481 ########## Creating Something Unique ##########
483 /*************************************************************************
484 * PathMakeUniqueNameA [internal]
486 BOOL WINAPI
PathMakeUniqueNameA(
489 LPCSTR lpszShortName
,
493 FIXME("%p %u %s %s %s stub\n",
494 lpszBuffer
, dwBuffSize
, debugstr_a(lpszShortName
),
495 debugstr_a(lpszLongName
), debugstr_a(lpszPathName
));
499 /*************************************************************************
500 * PathMakeUniqueNameW [internal]
502 BOOL WINAPI
PathMakeUniqueNameW(
505 LPCWSTR lpszShortName
,
506 LPCWSTR lpszLongName
,
507 LPCWSTR lpszPathName
)
509 FIXME("%p %u %s %s %s stub\n",
510 lpszBuffer
, dwBuffSize
, debugstr_w(lpszShortName
),
511 debugstr_w(lpszLongName
), debugstr_w(lpszPathName
));
515 /*************************************************************************
516 * PathMakeUniqueName [SHELL32.47]
518 BOOL WINAPI
PathMakeUniqueNameAW(
521 LPCVOID lpszShortName
,
522 LPCVOID lpszLongName
,
523 LPCVOID lpszPathName
)
525 if (SHELL_OsIsUnicode())
526 return PathMakeUniqueNameW(lpszBuffer
,dwBuffSize
, lpszShortName
,lpszLongName
,lpszPathName
);
527 return PathMakeUniqueNameA(lpszBuffer
,dwBuffSize
, lpszShortName
,lpszLongName
,lpszPathName
);
530 /*************************************************************************
531 * PathYetAnotherMakeUniqueName [SHELL32.75]
534 * exported by ordinal
536 BOOL WINAPI
PathYetAnotherMakeUniqueName(
538 LPCWSTR lpszPathName
,
539 LPCWSTR lpszShortName
,
540 LPCWSTR lpszLongName
)
542 FIXME("(%p, %s, %s ,%s):stub.\n",
543 lpszBuffer
, debugstr_w(lpszPathName
), debugstr_w(lpszShortName
), debugstr_w(lpszLongName
));
549 ########## cleaning and resolving paths ##########
552 /*************************************************************************
553 * PathFindOnPath [SHELL32.145]
555 BOOL WINAPI
PathFindOnPathAW(LPVOID sFile
, LPCVOID
*sOtherDirs
)
557 if (SHELL_OsIsUnicode())
558 return PathFindOnPathW(sFile
, (LPCWSTR
*)sOtherDirs
);
559 return PathFindOnPathA(sFile
, (LPCSTR
*)sOtherDirs
);
562 /*************************************************************************
563 * PathCleanupSpec [SHELL32.171]
565 * lpszFile is changed in place.
567 int WINAPI
PathCleanupSpec( LPCWSTR lpszPathW
, LPWSTR lpszFileW
)
573 if (SHELL_OsIsUnicode())
575 LPWSTR p
= lpszFileW
;
577 TRACE("Cleanup %s\n",debugstr_w(lpszFileW
));
580 length
= strlenW(lpszPathW
);
584 int gct
= PathGetCharTypeW(*p
);
585 if (gct
== GCT_INVALID
|| gct
== GCT_WILD
|| gct
== GCT_SEPARATOR
)
588 rc
|= PCS_REPLACEDCHAR
;
594 if (length
+ i
== MAX_PATH
)
596 rc
|= PCS_FATAL
| PCS_PATHTOOLONG
;
604 LPSTR lpszFileA
= (LPSTR
)lpszFileW
;
605 LPCSTR lpszPathA
= (LPCSTR
)lpszPathW
;
608 TRACE("Cleanup %s\n",debugstr_a(lpszFileA
));
611 length
= strlen(lpszPathA
);
615 int gct
= PathGetCharTypeA(*p
);
616 if (gct
== GCT_INVALID
|| gct
== GCT_WILD
|| gct
== GCT_SEPARATOR
)
619 rc
|= PCS_REPLACEDCHAR
;
625 if (length
+ i
== MAX_PATH
)
627 rc
|= PCS_FATAL
| PCS_PATHTOOLONG
;
636 /*************************************************************************
637 * PathQualifyA [SHELL32]
639 BOOL WINAPI
PathQualifyA(LPCSTR pszPath
)
641 FIXME("%s\n",pszPath
);
645 /*************************************************************************
646 * PathQualifyW [SHELL32]
648 BOOL WINAPI
PathQualifyW(LPCWSTR pszPath
)
650 FIXME("%s\n",debugstr_w(pszPath
));
654 /*************************************************************************
655 * PathQualify [SHELL32.49]
657 BOOL WINAPI
PathQualifyAW(LPCVOID pszPath
)
659 if (SHELL_OsIsUnicode())
660 return PathQualifyW(pszPath
);
661 return PathQualifyA(pszPath
);
664 /*************************************************************************
665 * PathResolveA [SHELL32.51]
667 BOOL WINAPI
PathResolveA(
672 FIXME("(%s,%p,0x%08x),stub!\n",
673 lpszPath
, *alpszPaths
, dwFlags
);
677 /*************************************************************************
678 * PathResolveW [SHELL32]
680 BOOL WINAPI
PathResolveW(
685 FIXME("(%s,%p,0x%08x),stub!\n",
686 debugstr_w(lpszPath
), debugstr_w(*alpszPaths
), dwFlags
);
690 /*************************************************************************
691 * PathResolve [SHELL32.51]
693 BOOL WINAPI
PathResolveAW(
698 if (SHELL_OsIsUnicode())
699 return PathResolveW(lpszPath
, (LPCWSTR
*)alpszPaths
, dwFlags
);
700 return PathResolveA(lpszPath
, (LPCSTR
*)alpszPaths
, dwFlags
);
703 /*************************************************************************
704 * PathProcessCommandA [SHELL32.653]
706 LONG WINAPI
PathProcessCommandA (
712 FIXME("%s %p 0x%04x 0x%04x stub\n",
713 lpszPath
, lpszBuff
, dwBuffSize
, dwFlags
);
714 if(!lpszPath
) return -1;
715 if(lpszBuff
) strcpy(lpszBuff
, lpszPath
);
716 return strlen(lpszPath
);
719 /*************************************************************************
720 * PathProcessCommandW
722 LONG WINAPI
PathProcessCommandW (
728 FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
729 debugstr_w(lpszPath
), lpszBuff
, dwBuffSize
, dwFlags
);
730 if(!lpszPath
) return -1;
731 if(lpszBuff
) strcpyW(lpszBuff
, lpszPath
);
732 return strlenW(lpszPath
);
735 /*************************************************************************
736 * PathProcessCommand (SHELL32.653)
738 LONG WINAPI
PathProcessCommandAW (
744 if (SHELL_OsIsUnicode())
745 return PathProcessCommandW(lpszPath
, lpszBuff
, dwBuffSize
, dwFlags
);
746 return PathProcessCommandA(lpszPath
, lpszBuff
, dwBuffSize
, dwFlags
);
750 ########## special ##########
753 /*************************************************************************
754 * PathSetDlgItemPath (SHELL32.48)
756 VOID WINAPI
PathSetDlgItemPathAW(HWND hDlg
, int id
, LPCVOID pszPath
)
758 if (SHELL_OsIsUnicode())
759 PathSetDlgItemPathW(hDlg
, id
, pszPath
);
761 PathSetDlgItemPathA(hDlg
, id
, pszPath
);
764 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'};
765 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'};
766 static const WCHAR AppDataW
[] = {'A','p','p','D','a','t','a','\0'};
767 static const WCHAR CacheW
[] = {'C','a','c','h','e','\0'};
768 static const WCHAR CD_BurningW
[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
769 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'};
770 static const WCHAR Common_AppDataW
[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
771 static const WCHAR Common_DesktopW
[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
772 static const WCHAR Common_DocumentsW
[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
773 static const WCHAR CommonFilesDirW
[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
774 static const WCHAR CommonMusicW
[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
775 static const WCHAR CommonPicturesW
[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
776 static const WCHAR Common_ProgramsW
[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
777 static const WCHAR Common_StartUpW
[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
778 static const WCHAR Common_Start_MenuW
[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
779 static const WCHAR Common_TemplatesW
[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
780 static const WCHAR CommonVideoW
[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
781 static const WCHAR CookiesW
[] = {'C','o','o','k','i','e','s','\0'};
782 static const WCHAR DesktopW
[] = {'D','e','s','k','t','o','p','\0'};
783 static const WCHAR FavoritesW
[] = {'F','a','v','o','r','i','t','e','s','\0'};
784 static const WCHAR FontsW
[] = {'F','o','n','t','s','\0'};
785 static const WCHAR HistoryW
[] = {'H','i','s','t','o','r','y','\0'};
786 static const WCHAR Local_AppDataW
[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
787 static const WCHAR My_MusicW
[] = {'M','y',' ','M','u','s','i','c','\0'};
788 static const WCHAR My_PicturesW
[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
789 static const WCHAR My_VideoW
[] = {'M','y',' ','V','i','d','e','o','s','\0'};
790 static const WCHAR NetHoodW
[] = {'N','e','t','H','o','o','d','\0'};
791 static const WCHAR PersonalW
[] = {'P','e','r','s','o','n','a','l','\0'};
792 static const WCHAR PrintHoodW
[] = {'P','r','i','n','t','H','o','o','d','\0'};
793 static const WCHAR ProgramFilesDirW
[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
794 static const WCHAR ProgramsW
[] = {'P','r','o','g','r','a','m','s','\0'};
795 static const WCHAR RecentW
[] = {'R','e','c','e','n','t','\0'};
796 static const WCHAR ResourcesW
[] = {'R','e','s','o','u','r','c','e','s','\0'};
797 static const WCHAR SendToW
[] = {'S','e','n','d','T','o','\0'};
798 static const WCHAR StartUpW
[] = {'S','t','a','r','t','U','p','\0'};
799 static const WCHAR Start_MenuW
[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
800 static const WCHAR TemplatesW
[] = {'T','e','m','p','l','a','t','e','s','\0'};
801 static const WCHAR DefaultW
[] = {'.','D','e','f','a','u','l','t','\0'};
802 static const WCHAR AllUsersProfileW
[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
803 static const WCHAR UserProfileW
[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
804 static const WCHAR SystemDriveW
[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
805 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};
806 static const WCHAR ProfilesDirectoryW
[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
807 static const WCHAR AllUsersProfileValueW
[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
808 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'};
809 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'};
810 /* This defaults to L"Documents and Settings" on Windows 2000/XP, but we're
811 * acting more Windows 9x-like for now.
813 static const WCHAR szDefaultProfileDirW
[] = {'p','r','o','f','i','l','e','s','\0'};
814 static const WCHAR AllUsersW
[] = {'A','l','l',' ','U','s','e','r','s','\0'};
816 typedef enum _CSIDL_Type
{
820 CSIDL_Type_Disallowed
,
821 CSIDL_Type_NonExistent
,
822 CSIDL_Type_WindowsPath
,
823 CSIDL_Type_SystemPath
,
830 LPCWSTR szDefaultPath
; /* fallback string or resource ID */
833 static const CSIDL_DATA CSIDL_Data
[] =
835 { /* 0x00 - CSIDL_DESKTOP */
838 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY
)
840 { /* 0x01 - CSIDL_INTERNET */
841 CSIDL_Type_Disallowed
,
845 { /* 0x02 - CSIDL_PROGRAMS */
848 MAKEINTRESOURCEW(IDS_PROGRAMS
)
850 { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
851 CSIDL_Type_SystemPath
,
855 { /* 0x04 - CSIDL_PRINTERS */
856 CSIDL_Type_SystemPath
,
860 { /* 0x05 - CSIDL_PERSONAL */
863 MAKEINTRESOURCEW(IDS_PERSONAL
)
865 { /* 0x06 - CSIDL_FAVORITES */
868 MAKEINTRESOURCEW(IDS_FAVORITES
)
870 { /* 0x07 - CSIDL_STARTUP */
873 MAKEINTRESOURCEW(IDS_STARTUP
)
875 { /* 0x08 - CSIDL_RECENT */
878 MAKEINTRESOURCEW(IDS_RECENT
)
880 { /* 0x09 - CSIDL_SENDTO */
883 MAKEINTRESOURCEW(IDS_SENDTO
)
885 { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
886 CSIDL_Type_Disallowed
,
890 { /* 0x0b - CSIDL_STARTMENU */
893 MAKEINTRESOURCEW(IDS_STARTMENU
)
895 { /* 0x0c - CSIDL_MYDOCUMENTS */
896 CSIDL_Type_Disallowed
, /* matches WinXP--can't get its path */
900 { /* 0x0d - CSIDL_MYMUSIC */
903 MAKEINTRESOURCEW(IDS_MYMUSIC
)
905 { /* 0x0e - CSIDL_MYVIDEO */
908 MAKEINTRESOURCEW(IDS_MYVIDEO
)
910 { /* 0x0f - unassigned */
911 CSIDL_Type_Disallowed
,
915 { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
918 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY
)
920 { /* 0x11 - CSIDL_DRIVES */
921 CSIDL_Type_Disallowed
,
925 { /* 0x12 - CSIDL_NETWORK */
926 CSIDL_Type_Disallowed
,
930 { /* 0x13 - CSIDL_NETHOOD */
933 MAKEINTRESOURCEW(IDS_NETHOOD
)
935 { /* 0x14 - CSIDL_FONTS */
936 CSIDL_Type_WindowsPath
,
940 { /* 0x15 - CSIDL_TEMPLATES */
943 MAKEINTRESOURCEW(IDS_TEMPLATES
)
945 { /* 0x16 - CSIDL_COMMON_STARTMENU */
948 MAKEINTRESOURCEW(IDS_STARTMENU
)
950 { /* 0x17 - CSIDL_COMMON_PROGRAMS */
953 MAKEINTRESOURCEW(IDS_PROGRAMS
)
955 { /* 0x18 - CSIDL_COMMON_STARTUP */
958 MAKEINTRESOURCEW(IDS_STARTUP
)
960 { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
963 MAKEINTRESOURCEW(IDS_DESKTOP
)
965 { /* 0x1a - CSIDL_APPDATA */
968 MAKEINTRESOURCEW(IDS_APPDATA
)
970 { /* 0x1b - CSIDL_PRINTHOOD */
973 MAKEINTRESOURCEW(IDS_PRINTHOOD
)
975 { /* 0x1c - CSIDL_LOCAL_APPDATA */
978 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA
)
980 { /* 0x1d - CSIDL_ALTSTARTUP */
981 CSIDL_Type_NonExistent
,
985 { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
986 CSIDL_Type_NonExistent
,
990 { /* 0x1f - CSIDL_COMMON_FAVORITES */
993 MAKEINTRESOURCEW(IDS_FAVORITES
)
995 { /* 0x20 - CSIDL_INTERNET_CACHE */
998 MAKEINTRESOURCEW(IDS_INTERNET_CACHE
)
1000 { /* 0x21 - CSIDL_COOKIES */
1003 MAKEINTRESOURCEW(IDS_COOKIES
)
1005 { /* 0x22 - CSIDL_HISTORY */
1008 MAKEINTRESOURCEW(IDS_HISTORY
)
1010 { /* 0x23 - CSIDL_COMMON_APPDATA */
1011 CSIDL_Type_AllUsers
,
1013 MAKEINTRESOURCEW(IDS_APPDATA
)
1015 { /* 0x24 - CSIDL_WINDOWS */
1016 CSIDL_Type_WindowsPath
,
1020 { /* 0x25 - CSIDL_SYSTEM */
1021 CSIDL_Type_SystemPath
,
1025 { /* 0x26 - CSIDL_PROGRAM_FILES */
1028 MAKEINTRESOURCEW(IDS_PROGRAM_FILES
)
1030 { /* 0x27 - CSIDL_MYPICTURES */
1033 MAKEINTRESOURCEW(IDS_MYPICTURES
)
1035 { /* 0x28 - CSIDL_PROFILE */
1040 { /* 0x29 - CSIDL_SYSTEMX86 */
1041 CSIDL_Type_NonExistent
,
1045 { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
1046 CSIDL_Type_NonExistent
,
1050 { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
1053 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON
)
1055 { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
1056 CSIDL_Type_NonExistent
,
1060 { /* 0x2d - CSIDL_COMMON_TEMPLATES */
1061 CSIDL_Type_AllUsers
,
1063 MAKEINTRESOURCEW(IDS_TEMPLATES
)
1065 { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
1066 CSIDL_Type_AllUsers
,
1068 MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS
)
1070 { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
1071 CSIDL_Type_AllUsers
,
1072 Common_Administrative_ToolsW
,
1073 MAKEINTRESOURCEW(IDS_ADMINTOOLS
)
1075 { /* 0x30 - CSIDL_ADMINTOOLS */
1077 Administrative_ToolsW
,
1078 MAKEINTRESOURCEW(IDS_ADMINTOOLS
)
1080 { /* 0x31 - CSIDL_CONNECTIONS */
1081 CSIDL_Type_Disallowed
,
1085 { /* 0x32 - unassigned */
1086 CSIDL_Type_Disallowed
,
1090 { /* 0x33 - unassigned */
1091 CSIDL_Type_Disallowed
,
1095 { /* 0x34 - unassigned */
1096 CSIDL_Type_Disallowed
,
1100 { /* 0x35 - CSIDL_COMMON_MUSIC */
1101 CSIDL_Type_AllUsers
,
1103 MAKEINTRESOURCEW(IDS_COMMON_MUSIC
)
1105 { /* 0x36 - CSIDL_COMMON_PICTURES */
1106 CSIDL_Type_AllUsers
,
1108 MAKEINTRESOURCEW(IDS_COMMON_PICTURES
)
1110 { /* 0x37 - CSIDL_COMMON_VIDEO */
1111 CSIDL_Type_AllUsers
,
1113 MAKEINTRESOURCEW(IDS_COMMON_VIDEO
)
1115 { /* 0x38 - CSIDL_RESOURCES */
1116 CSIDL_Type_WindowsPath
,
1120 { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
1121 CSIDL_Type_NonExistent
,
1125 { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
1126 CSIDL_Type_NonExistent
,
1130 { /* 0x3b - CSIDL_CDBURN_AREA */
1133 MAKEINTRESOURCEW(IDS_CDBURN_AREA
)
1135 { /* 0x3c unassigned */
1136 CSIDL_Type_Disallowed
,
1140 { /* 0x3d - CSIDL_COMPUTERSNEARME */
1141 CSIDL_Type_Disallowed
, /* FIXME */
1145 { /* 0x3e - CSIDL_PROFILES */
1146 CSIDL_Type_Disallowed
, /* oddly, this matches WinXP */
1152 static HRESULT
_SHExpandEnvironmentStrings(LPCWSTR szSrc
, LPWSTR szDest
);
1154 /* Gets the value named value from the registry key
1155 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1156 * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
1157 * is assumed to be MAX_PATH WCHARs in length.
1158 * If it exists, expands the value and writes the expanded value to
1159 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
1160 * Returns successful error code if the value was retrieved from the registry,
1161 * and a failure otherwise.
1163 static HRESULT
_SHGetUserShellFolderPath(HKEY rootKey
, LPCWSTR userPrefix
,
1164 LPCWSTR value
, LPWSTR path
)
1167 WCHAR shellFolderPath
[MAX_PATH
], userShellFolderPath
[MAX_PATH
];
1168 LPCWSTR pShellFolderPath
, pUserShellFolderPath
;
1169 DWORD dwType
, dwPathLen
= MAX_PATH
;
1170 HKEY userShellFolderKey
, shellFolderKey
;
1172 TRACE("%p,%s,%s,%p\n",rootKey
, debugstr_w(userPrefix
), debugstr_w(value
),
1177 strcpyW(shellFolderPath
, userPrefix
);
1178 PathAddBackslashW(shellFolderPath
);
1179 strcatW(shellFolderPath
, szSHFolders
);
1180 pShellFolderPath
= shellFolderPath
;
1181 strcpyW(userShellFolderPath
, userPrefix
);
1182 PathAddBackslashW(userShellFolderPath
);
1183 strcatW(userShellFolderPath
, szSHUserFolders
);
1184 pUserShellFolderPath
= userShellFolderPath
;
1188 pUserShellFolderPath
= szSHUserFolders
;
1189 pShellFolderPath
= szSHFolders
;
1192 if (RegCreateKeyW(rootKey
, pShellFolderPath
, &shellFolderKey
))
1194 TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath
));
1197 if (RegCreateKeyW(rootKey
, pUserShellFolderPath
, &userShellFolderKey
))
1199 TRACE("Failed to create %s\n",
1200 debugstr_w(pUserShellFolderPath
));
1201 RegCloseKey(shellFolderKey
);
1205 if (!RegQueryValueExW(userShellFolderKey
, value
, NULL
, &dwType
,
1206 (LPBYTE
)path
, &dwPathLen
) && (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
))
1210 path
[dwPathLen
/ sizeof(WCHAR
)] = '\0';
1211 if (dwType
== REG_EXPAND_SZ
&& path
[0] == '%')
1213 WCHAR szTemp
[MAX_PATH
];
1215 _SHExpandEnvironmentStrings(path
, szTemp
);
1216 lstrcpynW(path
, szTemp
, MAX_PATH
);
1218 ret
= RegSetValueExW(shellFolderKey
, value
, 0, REG_SZ
, (LPBYTE
)path
,
1219 (strlenW(path
) + 1) * sizeof(WCHAR
));
1220 if (ret
!= ERROR_SUCCESS
)
1221 hr
= HRESULT_FROM_WIN32(ret
);
1227 RegCloseKey(shellFolderKey
);
1228 RegCloseKey(userShellFolderKey
);
1229 TRACE("returning 0x%08x\n", hr
);
1233 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
1234 * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
1235 * - The entry's szDefaultPath may be either a string value or an integer
1236 * resource identifier. In the latter case, the string value of the resource
1238 * - Depending on the entry's type, the path may begin with an (unexpanded)
1239 * environment variable name. The caller is responsible for expanding
1240 * environment strings if so desired.
1241 * The types that are prepended with environment variables are:
1242 * CSIDL_Type_User: %USERPROFILE%
1243 * CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1244 * CSIDL_Type_CurrVer: %SystemDrive%
1245 * (Others might make sense too, but as yet are unneeded.)
1247 static HRESULT
_SHGetDefaultValue(BYTE folder
, LPWSTR pszPath
)
1250 WCHAR resourcePath
[MAX_PATH
];
1251 LPCWSTR pDefaultPath
= NULL
;
1253 TRACE("0x%02x,%p\n", folder
, pszPath
);
1255 if (folder
>= sizeof(CSIDL_Data
) / sizeof(CSIDL_Data
[0]))
1256 return E_INVALIDARG
;
1258 return E_INVALIDARG
;
1260 if (CSIDL_Data
[folder
].szDefaultPath
&&
1261 IS_INTRESOURCE(CSIDL_Data
[folder
].szDefaultPath
))
1263 if (LoadStringW(shell32_hInstance
,
1264 LOWORD(CSIDL_Data
[folder
].szDefaultPath
), resourcePath
, MAX_PATH
))
1267 pDefaultPath
= resourcePath
;
1271 FIXME("(%d,%s), LoadString failed, missing translation?\n", folder
,
1272 debugstr_w(pszPath
));
1279 pDefaultPath
= CSIDL_Data
[folder
].szDefaultPath
;
1283 switch (CSIDL_Data
[folder
].type
)
1285 case CSIDL_Type_User
:
1286 strcpyW(pszPath
, UserProfileW
);
1288 case CSIDL_Type_AllUsers
:
1289 strcpyW(pszPath
, AllUsersProfileW
);
1291 case CSIDL_Type_CurrVer
:
1292 strcpyW(pszPath
, SystemDriveW
);
1295 ; /* no corresponding env. var, do nothing */
1299 PathAddBackslashW(pszPath
);
1300 strcatW(pszPath
, pDefaultPath
);
1303 TRACE("returning 0x%08x\n", hr
);
1307 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1308 * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
1309 * can be overridden in the HKLM\\szCurrentVersion key.
1310 * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1311 * the registry, uses _SHGetDefaultValue to get the value.
1313 static HRESULT
_SHGetCurrentVersionPath(DWORD dwFlags
, BYTE folder
,
1318 TRACE("0x%08x,0x%02x,%p\n", dwFlags
, folder
, pszPath
);
1320 if (folder
>= sizeof(CSIDL_Data
) / sizeof(CSIDL_Data
[0]))
1321 return E_INVALIDARG
;
1322 if (CSIDL_Data
[folder
].type
!= CSIDL_Type_CurrVer
)
1323 return E_INVALIDARG
;
1325 return E_INVALIDARG
;
1327 if (dwFlags
& SHGFP_TYPE_DEFAULT
)
1328 hr
= _SHGetDefaultValue(folder
, pszPath
);
1333 if (RegCreateKeyW(HKEY_LOCAL_MACHINE
, szCurrentVersion
, &hKey
))
1337 DWORD dwType
, dwPathLen
= MAX_PATH
* sizeof(WCHAR
);
1339 if (RegQueryValueExW(hKey
, CSIDL_Data
[folder
].szValueName
, NULL
,
1340 &dwType
, (LPBYTE
)pszPath
, &dwPathLen
) ||
1341 (dwType
!= REG_SZ
&& dwType
!= REG_EXPAND_SZ
))
1343 hr
= _SHGetDefaultValue(folder
, pszPath
);
1344 dwType
= REG_EXPAND_SZ
;
1345 RegSetValueExW(hKey
, CSIDL_Data
[folder
].szValueName
, 0, dwType
,
1346 (LPBYTE
)pszPath
, (strlenW(pszPath
)+1)*sizeof(WCHAR
));
1350 pszPath
[dwPathLen
/ sizeof(WCHAR
)] = '\0';
1356 TRACE("returning 0x%08x (output path is %s)\n", hr
, debugstr_w(pszPath
));
1360 static LPWSTR
_GetUserSidStringFromToken(HANDLE Token
)
1362 char InfoBuffer
[64];
1363 PTOKEN_USER UserInfo
;
1367 UserInfo
= (PTOKEN_USER
) InfoBuffer
;
1368 if (! GetTokenInformation(Token
, TokenUser
, InfoBuffer
, sizeof(InfoBuffer
),
1371 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER
)
1373 UserInfo
= HeapAlloc(GetProcessHeap(), 0, InfoSize
);
1374 if (UserInfo
== NULL
)
1376 if (! GetTokenInformation(Token
, TokenUser
, UserInfo
, InfoSize
,
1379 HeapFree(GetProcessHeap(), 0, UserInfo
);
1384 if (! ConvertSidToStringSidW(UserInfo
->User
.Sid
, &SidStr
))
1387 if (UserInfo
!= (PTOKEN_USER
) InfoBuffer
)
1388 HeapFree(GetProcessHeap(), 0, UserInfo
);
1393 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1394 * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
1395 * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
1396 * - if hToken is -1, looks in HKEY_USERS\.Default
1397 * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1398 * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
1399 * calls _SHGetDefaultValue for it.
1401 static HRESULT
_SHGetUserProfilePath(HANDLE hToken
, DWORD dwFlags
, BYTE folder
,
1406 TRACE("%p,0x%08x,0x%02x,%p\n", hToken
, dwFlags
, folder
, pszPath
);
1408 if (folder
>= sizeof(CSIDL_Data
) / sizeof(CSIDL_Data
[0]))
1409 return E_INVALIDARG
;
1410 if (CSIDL_Data
[folder
].type
!= CSIDL_Type_User
)
1411 return E_INVALIDARG
;
1413 return E_INVALIDARG
;
1415 if (dwFlags
& SHGFP_TYPE_DEFAULT
)
1417 if (hToken
!= NULL
&& hToken
!= (HANDLE
)-1)
1419 FIXME("unsupported for user other than current or default\n");
1422 hr
= _SHGetDefaultValue(folder
, pszPath
);
1426 LPCWSTR userPrefix
= NULL
;
1429 if (hToken
== (HANDLE
)-1)
1431 hRootKey
= HKEY_USERS
;
1432 userPrefix
= DefaultW
;
1434 else if (hToken
== NULL
)
1435 hRootKey
= HKEY_CURRENT_USER
;
1438 hRootKey
= HKEY_USERS
;
1439 userPrefix
= _GetUserSidStringFromToken(hToken
);
1440 if (userPrefix
== NULL
)
1446 hr
= _SHGetUserShellFolderPath(hRootKey
, userPrefix
,
1447 CSIDL_Data
[folder
].szValueName
, pszPath
);
1448 if (FAILED(hr
) && hRootKey
!= HKEY_LOCAL_MACHINE
)
1449 hr
= _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE
, NULL
,
1450 CSIDL_Data
[folder
].szValueName
, pszPath
);
1452 hr
= _SHGetDefaultValue(folder
, pszPath
);
1453 if (userPrefix
!= NULL
&& userPrefix
!= DefaultW
)
1454 LocalFree((HLOCAL
) userPrefix
);
1457 TRACE("returning 0x%08x (output path is %s)\n", hr
, debugstr_w(pszPath
));
1461 /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
1462 * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
1463 * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1464 * If this fails, falls back to _SHGetDefaultValue.
1466 static HRESULT
_SHGetAllUsersProfilePath(DWORD dwFlags
, BYTE folder
,
1471 TRACE("0x%08x,0x%02x,%p\n", dwFlags
, folder
, pszPath
);
1473 if (folder
>= sizeof(CSIDL_Data
) / sizeof(CSIDL_Data
[0]))
1474 return E_INVALIDARG
;
1475 if (CSIDL_Data
[folder
].type
!= CSIDL_Type_AllUsers
)
1476 return E_INVALIDARG
;
1478 return E_INVALIDARG
;
1480 if (dwFlags
& SHGFP_TYPE_DEFAULT
)
1481 hr
= _SHGetDefaultValue(folder
, pszPath
);
1484 hr
= _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE
, NULL
,
1485 CSIDL_Data
[folder
].szValueName
, pszPath
);
1487 hr
= _SHGetDefaultValue(folder
, pszPath
);
1489 TRACE("returning 0x%08x (output path is %s)\n", hr
, debugstr_w(pszPath
));
1493 static HRESULT
_SHOpenProfilesKey(PHKEY pKey
)
1498 lRet
= RegCreateKeyExW(HKEY_LOCAL_MACHINE
, ProfileListW
, 0, NULL
, 0,
1499 KEY_ALL_ACCESS
, NULL
, pKey
, &disp
);
1500 return HRESULT_FROM_WIN32(lRet
);
1503 /* Reads the value named szValueName from the key profilesKey (assumed to be
1504 * opened by _SHOpenProfilesKey) into szValue, which is assumed to be MAX_PATH
1505 * WCHARs in length. If it doesn't exist, returns szDefault (and saves
1506 * szDefault to the registry).
1508 static HRESULT
_SHGetProfilesValue(HKEY profilesKey
, LPCWSTR szValueName
,
1509 LPWSTR szValue
, LPCWSTR szDefault
)
1512 DWORD type
, dwPathLen
= MAX_PATH
* sizeof(WCHAR
);
1515 TRACE("%p,%s,%p,%s\n", profilesKey
, debugstr_w(szValueName
), szValue
,
1516 debugstr_w(szDefault
));
1517 lRet
= RegQueryValueExW(profilesKey
, szValueName
, NULL
, &type
,
1518 (LPBYTE
)szValue
, &dwPathLen
);
1519 if (!lRet
&& (type
== REG_SZ
|| type
== REG_EXPAND_SZ
) && dwPathLen
1522 dwPathLen
/= sizeof(WCHAR
);
1523 szValue
[dwPathLen
] = '\0';
1528 /* Missing or invalid value, set a default */
1529 lstrcpynW(szValue
, szDefault
, MAX_PATH
);
1530 TRACE("Setting missing value %s to %s\n", debugstr_w(szValueName
),
1531 debugstr_w(szValue
));
1532 lRet
= RegSetValueExW(profilesKey
, szValueName
, 0, REG_EXPAND_SZ
,
1534 (strlenW(szValue
) + 1) * sizeof(WCHAR
));
1536 hr
= HRESULT_FROM_WIN32(lRet
);
1540 TRACE("returning 0x%08x (output value is %s)\n", hr
, debugstr_w(szValue
));
1544 /* Attempts to expand environment variables from szSrc into szDest, which is
1545 * assumed to be MAX_PATH characters in length. Before referring to the
1546 * environment, handles a few variables directly, because the environment
1547 * variables may not be set when this is called (as during Wine's installation
1548 * when default values are being written to the registry).
1549 * The directly handled environment variables, and their source, are:
1550 * - ALLUSERSPROFILE, USERPROFILE: reads from the registry
1551 * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
1553 * If one of the directly handled environment variables is expanded, only
1554 * expands a single variable, and only in the beginning of szSrc.
1556 static HRESULT
_SHExpandEnvironmentStrings(LPCWSTR szSrc
, LPWSTR szDest
)
1559 WCHAR szTemp
[MAX_PATH
], szProfilesPrefix
[MAX_PATH
] = { 0 };
1562 TRACE("%s, %p\n", debugstr_w(szSrc
), szDest
);
1564 if (!szSrc
|| !szDest
) return E_INVALIDARG
;
1566 /* short-circuit if there's nothing to expand */
1567 if (szSrc
[0] != '%')
1569 strcpyW(szDest
, szSrc
);
1573 /* Get the profile prefix, we'll probably be needing it */
1574 hr
= _SHOpenProfilesKey(&key
);
1577 WCHAR szDefaultProfilesPrefix
[MAX_PATH
];
1579 GetWindowsDirectoryW(szDefaultProfilesPrefix
, MAX_PATH
);
1580 PathAddBackslashW(szDefaultProfilesPrefix
);
1581 PathAppendW(szDefaultProfilesPrefix
, szDefaultProfileDirW
);
1582 hr
= _SHGetProfilesValue(key
, ProfilesDirectoryW
, szProfilesPrefix
,
1583 szDefaultProfilesPrefix
);
1587 strcpyW(szTemp
, szSrc
);
1588 while (SUCCEEDED(hr
) && szTemp
[0] == '%')
1590 if (!strncmpiW(szTemp
, AllUsersProfileW
, strlenW(AllUsersProfileW
)))
1592 WCHAR szAllUsers
[MAX_PATH
];
1594 strcpyW(szDest
, szProfilesPrefix
);
1595 hr
= _SHGetProfilesValue(key
, AllUsersProfileValueW
,
1596 szAllUsers
, AllUsersW
);
1597 PathAppendW(szDest
, szAllUsers
);
1598 PathAppendW(szDest
, szTemp
+ strlenW(AllUsersProfileW
));
1600 else if (!strncmpiW(szTemp
, UserProfileW
, strlenW(UserProfileW
)))
1602 WCHAR userName
[MAX_PATH
];
1603 DWORD userLen
= MAX_PATH
;
1605 strcpyW(szDest
, szProfilesPrefix
);
1606 GetUserNameW(userName
, &userLen
);
1607 PathAppendW(szDest
, userName
);
1608 PathAppendW(szDest
, szTemp
+ strlenW(UserProfileW
));
1610 else if (!strncmpiW(szTemp
, SystemDriveW
, strlenW(SystemDriveW
)))
1612 GetSystemDirectoryW(szDest
, MAX_PATH
);
1613 if (szDest
[1] != ':')
1615 FIXME("non-drive system paths unsupported\n");
1620 strcpyW(szDest
+ 3, szTemp
+ strlenW(SystemDriveW
) + 1);
1626 DWORD ret
= ExpandEnvironmentStringsW(szSrc
, szDest
, MAX_PATH
);
1629 hr
= HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER
);
1631 hr
= HRESULT_FROM_WIN32(GetLastError());
1635 if (SUCCEEDED(hr
) && szDest
[0] == '%')
1636 strcpyW(szTemp
, szDest
);
1639 /* terminate loop */
1646 TRACE("returning 0x%08x (input was %s, output is %s)\n", hr
,
1647 debugstr_w(szSrc
), debugstr_w(szDest
));
1651 /*************************************************************************
1652 * SHGetFolderPathW [SHELL32.@]
1654 * Convert nFolder to path.
1658 * Failure: standard HRESULT error codes.
1661 * Most values can be overridden in either
1662 * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1663 * or in the same location in HKLM.
1664 * The "Shell Folders" registry key was used in NT4 and earlier systems.
1665 * Beginning with Windows 2000, the "User Shell Folders" key is used, so
1666 * changes made to it are made to the former key too. This synchronization is
1667 * done on-demand: not until someone requests the value of one of these paths
1668 * (by calling one of the SHGet functions) is the value synchronized.
1669 * Furthermore, the HKCU paths take precedence over the HKLM paths.
1671 HRESULT WINAPI
SHGetFolderPathW(
1672 HWND hwndOwner
, /* [I] owner window */
1673 int nFolder
, /* [I] CSIDL identifying the folder */
1674 HANDLE hToken
, /* [I] access token */
1675 DWORD dwFlags
, /* [I] which path to return */
1676 LPWSTR pszPath
) /* [O] converted path */
1679 WCHAR szBuildPath
[MAX_PATH
], szTemp
[MAX_PATH
];
1680 DWORD folder
= nFolder
& CSIDL_FOLDER_MASK
;
1684 TRACE("%p,%p,nFolder=0x%04x\n", hwndOwner
,pszPath
,nFolder
);
1686 /* Windows always NULL-terminates the resulting path regardless of success
1687 * or failure, so do so first
1691 if (folder
>= sizeof(CSIDL_Data
) / sizeof(CSIDL_Data
[0]))
1692 return E_INVALIDARG
;
1694 type
= CSIDL_Data
[folder
].type
;
1697 case CSIDL_Type_Disallowed
:
1700 case CSIDL_Type_NonExistent
:
1703 case CSIDL_Type_WindowsPath
:
1704 GetWindowsDirectoryW(szTemp
, MAX_PATH
);
1705 if (CSIDL_Data
[folder
].szDefaultPath
&&
1706 !IS_INTRESOURCE(CSIDL_Data
[folder
].szDefaultPath
) &&
1707 *CSIDL_Data
[folder
].szDefaultPath
)
1709 PathAddBackslashW(szTemp
);
1710 strcatW(szTemp
, CSIDL_Data
[folder
].szDefaultPath
);
1714 case CSIDL_Type_SystemPath
:
1715 GetSystemDirectoryW(szTemp
, MAX_PATH
);
1716 if (CSIDL_Data
[folder
].szDefaultPath
&&
1717 !IS_INTRESOURCE(CSIDL_Data
[folder
].szDefaultPath
) &&
1718 *CSIDL_Data
[folder
].szDefaultPath
)
1720 PathAddBackslashW(szTemp
);
1721 strcatW(szTemp
, CSIDL_Data
[folder
].szDefaultPath
);
1725 case CSIDL_Type_CurrVer
:
1726 hr
= _SHGetCurrentVersionPath(dwFlags
, folder
, szTemp
);
1728 case CSIDL_Type_User
:
1729 hr
= _SHGetUserProfilePath(hToken
, dwFlags
, folder
, szTemp
);
1731 case CSIDL_Type_AllUsers
:
1732 hr
= _SHGetAllUsersProfilePath(dwFlags
, folder
, szTemp
);
1735 FIXME("bogus type %d, please fix\n", type
);
1740 /* Expand environment strings if necessary */
1742 hr
= _SHExpandEnvironmentStrings(szTemp
, szBuildPath
);
1744 strcpyW(szBuildPath
, szTemp
);
1745 /* Copy the path if it's available before we might return */
1746 if (SUCCEEDED(hr
) && pszPath
)
1747 strcpyW(pszPath
, szBuildPath
);
1749 if (FAILED(hr
)) goto end
;
1751 /* if we don't care about existing directories we are ready */
1752 if(nFolder
& CSIDL_FLAG_DONT_VERIFY
) goto end
;
1754 if (PathFileExistsW(szBuildPath
)) goto end
;
1756 /* not existing but we are not allowed to create it. The return value
1757 * is verified against shell32 version 6.0.
1759 if (!(nFolder
& CSIDL_FLAG_CREATE
))
1761 hr
= HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
1765 /* create directory/directories */
1766 ret
= SHCreateDirectoryExW(hwndOwner
, szBuildPath
, NULL
);
1767 if (ret
&& ret
!= ERROR_ALREADY_EXISTS
)
1769 ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath
));
1774 TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath
));
1776 TRACE("returning 0x%08x (final path is %s)\n", hr
, debugstr_w(szBuildPath
));
1780 /*************************************************************************
1781 * SHGetFolderPathA [SHELL32.@]
1783 * See SHGetFolderPathW.
1785 HRESULT WINAPI
SHGetFolderPathA(
1792 WCHAR szTemp
[MAX_PATH
];
1795 TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner
,pszPath
,nFolder
);
1799 hr
= SHGetFolderPathW(hwndOwner
, nFolder
, hToken
, dwFlags
, szTemp
);
1800 if (SUCCEEDED(hr
) && pszPath
)
1801 WideCharToMultiByte(CP_ACP
, 0, szTemp
, -1, pszPath
, MAX_PATH
, NULL
,
1807 /* For each folder in folders, if its value has not been set in the registry,
1808 * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
1809 * folder's type) to get the unexpanded value first.
1810 * Writes the unexpanded value to User Shell Folders, and queries it with
1811 * SHGetFolderPathW to force the creation of the directory if it doesn't
1812 * already exist. SHGetFolderPathW also returns the expanded value, which
1813 * this then writes to Shell Folders.
1815 static HRESULT
_SHRegisterFolders(HKEY hRootKey
, HANDLE hToken
,
1816 LPCWSTR szUserShellFolderPath
, LPCWSTR szShellFolderPath
, const UINT folders
[],
1820 WCHAR path
[MAX_PATH
];
1822 HKEY hUserKey
= NULL
, hKey
= NULL
;
1823 DWORD dwType
, dwPathLen
;
1826 TRACE("%p,%p,%s,%p,%u\n", hRootKey
, hToken
,
1827 debugstr_w(szUserShellFolderPath
), folders
, foldersLen
);
1829 ret
= RegCreateKeyW(hRootKey
, szUserShellFolderPath
, &hUserKey
);
1831 hr
= HRESULT_FROM_WIN32(ret
);
1834 ret
= RegCreateKeyW(hRootKey
, szShellFolderPath
, &hKey
);
1836 hr
= HRESULT_FROM_WIN32(ret
);
1838 for (i
= 0; SUCCEEDED(hr
) && i
< foldersLen
; i
++)
1840 dwPathLen
= MAX_PATH
* sizeof(WCHAR
);
1841 if (RegQueryValueExW(hUserKey
, CSIDL_Data
[folders
[i
]].szValueName
, NULL
,
1842 &dwType
, (LPBYTE
)path
, &dwPathLen
) || (dwType
!= REG_SZ
&&
1843 dwType
!= REG_EXPAND_SZ
))
1846 if (CSIDL_Data
[folders
[i
]].type
== CSIDL_Type_User
)
1847 _SHGetUserProfilePath(hToken
, SHGFP_TYPE_DEFAULT
, folders
[i
],
1849 else if (CSIDL_Data
[folders
[i
]].type
== CSIDL_Type_AllUsers
)
1850 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT
, folders
[i
], path
);
1851 else if (CSIDL_Data
[folders
[i
]].type
== CSIDL_Type_WindowsPath
)
1852 GetWindowsDirectoryW(path
, MAX_PATH
);
1857 ret
= RegSetValueExW(hUserKey
,
1858 CSIDL_Data
[folders
[i
]].szValueName
, 0, REG_EXPAND_SZ
,
1859 (LPBYTE
)path
, (strlenW(path
) + 1) * sizeof(WCHAR
));
1861 hr
= HRESULT_FROM_WIN32(ret
);
1864 hr
= SHGetFolderPathW(NULL
, folders
[i
] | CSIDL_FLAG_CREATE
,
1865 hToken
, SHGFP_TYPE_DEFAULT
, path
);
1866 ret
= RegSetValueExW(hKey
,
1867 CSIDL_Data
[folders
[i
]].szValueName
, 0, REG_SZ
,
1868 (LPBYTE
)path
, (strlenW(path
) + 1) * sizeof(WCHAR
));
1870 hr
= HRESULT_FROM_WIN32(ret
);
1876 RegCloseKey(hUserKey
);
1880 TRACE("returning 0x%08x\n", hr
);
1884 static HRESULT
_SHRegisterUserShellFolders(BOOL bDefault
)
1886 static const UINT folders
[] = {
1897 CSIDL_DESKTOPDIRECTORY
,
1901 CSIDL_LOCAL_APPDATA
,
1902 CSIDL_INTERNET_CACHE
,
1908 WCHAR userShellFolderPath
[MAX_PATH
], shellFolderPath
[MAX_PATH
];
1909 LPCWSTR pUserShellFolderPath
, pShellFolderPath
;
1914 TRACE("%s\n", bDefault
? "TRUE" : "FALSE");
1917 hToken
= (HANDLE
)-1;
1918 hRootKey
= HKEY_USERS
;
1919 strcpyW(userShellFolderPath
, DefaultW
);
1920 PathAddBackslashW(userShellFolderPath
);
1921 strcatW(userShellFolderPath
, szSHUserFolders
);
1922 pUserShellFolderPath
= userShellFolderPath
;
1923 strcpyW(shellFolderPath
, DefaultW
);
1924 PathAddBackslashW(shellFolderPath
);
1925 strcatW(shellFolderPath
, szSHFolders
);
1926 pShellFolderPath
= shellFolderPath
;
1931 hRootKey
= HKEY_CURRENT_USER
;
1932 pUserShellFolderPath
= szSHUserFolders
;
1933 pShellFolderPath
= szSHFolders
;
1936 hr
= _SHRegisterFolders(hRootKey
, hToken
, pUserShellFolderPath
,
1937 pShellFolderPath
, folders
, sizeof(folders
) / sizeof(folders
[0]));
1938 TRACE("returning 0x%08x\n", hr
);
1942 static HRESULT
_SHRegisterCommonShellFolders(void)
1944 static const UINT folders
[] = {
1945 CSIDL_COMMON_STARTMENU
,
1946 CSIDL_COMMON_PROGRAMS
,
1947 CSIDL_COMMON_STARTUP
,
1948 CSIDL_COMMON_DESKTOPDIRECTORY
,
1949 CSIDL_COMMON_FAVORITES
,
1950 CSIDL_COMMON_APPDATA
,
1951 CSIDL_COMMON_TEMPLATES
,
1952 CSIDL_COMMON_DOCUMENTS
,
1957 hr
= _SHRegisterFolders(HKEY_LOCAL_MACHINE
, NULL
, szSHUserFolders
,
1958 szSHFolders
, folders
, sizeof(folders
) / sizeof(folders
[0]));
1959 TRACE("returning 0x%08x\n", hr
);
1963 /******************************************************************************
1964 * _SHAppendToUnixPath [Internal]
1966 * Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
1967 * corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
1968 * and replaces backslashes with slashes.
1971 * szBasePath [IO] The unix base path, which will be appended to (CP_UNXICP).
1972 * pwszSubPath [I] Sub-path or resource id (use MAKEINTRESOURCEW).
1978 static inline BOOL
_SHAppendToUnixPath(char *szBasePath
, LPCWSTR pwszSubPath
) {
1979 WCHAR wszSubPath
[MAX_PATH
];
1980 int cLen
= strlen(szBasePath
);
1983 if (IS_INTRESOURCE(pwszSubPath
)) {
1984 if (!LoadStringW(shell32_hInstance
, LOWORD(pwszSubPath
), wszSubPath
, MAX_PATH
)) {
1985 /* Fall back to hard coded defaults. */
1986 switch (LOWORD(pwszSubPath
)) {
1988 lstrcpyW(wszSubPath
, PersonalW
);
1991 lstrcpyW(wszSubPath
, My_MusicW
);
1993 case IDS_MYPICTURES
:
1994 lstrcpyW(wszSubPath
, My_PicturesW
);
1997 lstrcpyW(wszSubPath
, My_VideoW
);
2000 ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath
));
2005 lstrcpyW(wszSubPath
, pwszSubPath
);
2008 if (szBasePath
[cLen
-1] != '/') szBasePath
[cLen
++] = '/';
2010 if (!WideCharToMultiByte(CP_UNIXCP
, 0, wszSubPath
, -1, szBasePath
+ cLen
,
2011 FILENAME_MAX
- cLen
, NULL
, NULL
))
2016 pBackslash
= szBasePath
+ cLen
;
2017 while ((pBackslash
= strchr(pBackslash
, '\\'))) *pBackslash
= '/';
2022 /******************************************************************************
2023 * _SHCreateSymbolicLinks [Internal]
2025 * Sets up symbol links for various shell folders to point into the users home
2026 * directory. We do an educated guess about what the user would probably want:
2027 * - If there is a 'My Documents' directory in $HOME, the user probably wants
2028 * wine's 'My Documents' to point there. Furthermore, we imply that the user
2029 * is a Windows lover and has no problem with wine creating 'My Pictures',
2030 * 'My Music' and 'My Video' subfolders under '$HOME/My Documents', if those
2031 * do not already exits. We put appropriate symbolic links in place for those,
2033 * - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
2034 * point directly to $HOME. We assume the user to be a unix hacker who does not
2035 * want wine to create anything anywhere besides the .wine directory. So, if
2036 * there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
2037 * shell folder to it. But if not, then we check XDG_MUSIC_DIR - "well known"
2038 * directory, and try to link to that. If that fails, then we symlink to
2039 * $HOME directly. The same holds fo 'My Pictures' and 'My Video'.
2040 * - The Desktop shell folder is symlinked to XDG_DESKTOP_DIR. If that does not
2041 * exist, then we try '$HOME/Desktop'. If that does not exist, then we leave
2043 * ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
2045 static void _SHCreateSymbolicLinks(void)
2047 UINT aidsMyStuff
[] = { IDS_MYPICTURES
, IDS_MYVIDEO
, IDS_MYMUSIC
}, i
;
2048 int acsidlMyStuff
[] = { CSIDL_MYPICTURES
, CSIDL_MYVIDEO
, CSIDL_MYMUSIC
};
2049 static const char * xdg_dirs
[] = { "PICTURES", "VIDEOS", "MUSIC", "DESKTOP" };
2050 WCHAR wszTempPath
[MAX_PATH
];
2051 char szPersonalTarget
[FILENAME_MAX
], *pszPersonal
;
2052 char szMyStuffTarget
[FILENAME_MAX
], *pszMyStuff
;
2053 char szDesktopTarget
[FILENAME_MAX
], *pszDesktop
;
2054 struct stat statFolder
;
2055 const char *pszHome
;
2057 const unsigned int num
= sizeof(xdg_dirs
) / sizeof(xdg_dirs
[0]);
2058 char ** xdg_results
= NULL
;
2059 char * xdg_desktop_dir
;
2061 /* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
2062 hr
= SHGetFolderPathW(NULL
, CSIDL_PERSONAL
|CSIDL_FLAG_CREATE
, NULL
,
2063 SHGFP_TYPE_DEFAULT
, wszTempPath
);
2064 if (FAILED(hr
)) return;
2065 pszPersonal
= wine_get_unix_file_name(wszTempPath
);
2066 if (!pszPersonal
) return;
2068 XDG_UserDirLookup(xdg_dirs
, num
, &xdg_results
);
2070 pszHome
= getenv("HOME");
2071 if (pszHome
&& !stat(pszHome
, &statFolder
) && S_ISDIR(statFolder
.st_mode
)) {
2072 strcpy(szPersonalTarget
, pszHome
);
2073 if (_SHAppendToUnixPath(szPersonalTarget
, MAKEINTRESOURCEW(IDS_PERSONAL
)) &&
2074 !stat(szPersonalTarget
, &statFolder
) && S_ISDIR(statFolder
.st_mode
))
2076 /* '$HOME/My Documents' exists. Create 'My Pictures', 'My Videos' and
2077 * 'My Music' subfolders or fail silently if they already exist. */
2078 for (i
= 0; i
< sizeof(aidsMyStuff
)/sizeof(aidsMyStuff
[0]); i
++) {
2079 strcpy(szMyStuffTarget
, szPersonalTarget
);
2080 if (_SHAppendToUnixPath(szMyStuffTarget
, MAKEINTRESOURCEW(aidsMyStuff
[i
])))
2081 mkdir(szMyStuffTarget
, 0777);
2086 /* '$HOME/My Documents' doesn't exists, but '$HOME' does. */
2087 strcpy(szPersonalTarget
, pszHome
);
2090 /* Replace 'My Documents' directory with a symlink of fail silently if not empty. */
2092 symlink(szPersonalTarget
, pszPersonal
);
2096 /* '$HOME' doesn't exist. Create 'My Pictures', 'My Videos' and 'My Music' subdirs
2097 * in '%USERPROFILE%\\My Documents' or fail silently if they already exist. */
2098 strcpy(szPersonalTarget
, pszPersonal
);
2099 for (i
= 0; i
< sizeof(aidsMyStuff
)/sizeof(aidsMyStuff
[0]); i
++) {
2100 strcpy(szMyStuffTarget
, szPersonalTarget
);
2101 if (_SHAppendToUnixPath(szMyStuffTarget
, MAKEINTRESOURCEW(aidsMyStuff
[i
])))
2102 mkdir(szMyStuffTarget
, 0777);
2106 /* Create symbolic links for 'My Pictures', 'My Video' and 'My Music'. */
2107 for (i
=0; i
< sizeof(aidsMyStuff
)/sizeof(aidsMyStuff
[0]); i
++) {
2108 /* Create the current 'My Whatever' folder and get it's unix path. */
2109 hr
= SHGetFolderPathW(NULL
, acsidlMyStuff
[i
]|CSIDL_FLAG_CREATE
, NULL
,
2110 SHGFP_TYPE_DEFAULT
, wszTempPath
);
2111 if (FAILED(hr
)) continue;
2112 pszMyStuff
= wine_get_unix_file_name(wszTempPath
);
2113 if (!pszMyStuff
) continue;
2115 strcpy(szMyStuffTarget
, szPersonalTarget
);
2116 if (_SHAppendToUnixPath(szMyStuffTarget
, MAKEINTRESOURCEW(aidsMyStuff
[i
])) &&
2117 !stat(szMyStuffTarget
, &statFolder
) && S_ISDIR(statFolder
.st_mode
))
2119 /* If there's a 'My Whatever' directory where 'My Documents' links to, link to it. */
2121 symlink(szMyStuffTarget
, pszMyStuff
);
2126 if (xdg_results
&& xdg_results
[i
])
2128 /* the folder specified by XDG_XXX_DIR exists, link to it. */
2129 symlink(xdg_results
[i
], pszMyStuff
);
2133 /* Else link to where 'My Documents' itself links to. */
2134 symlink(szPersonalTarget
, pszMyStuff
);
2137 HeapFree(GetProcessHeap(), 0, pszMyStuff
);
2140 /* Last but not least, the Desktop folder */
2142 strcpy(szDesktopTarget
, pszHome
);
2144 strcpy(szDesktopTarget
, pszPersonal
);
2145 HeapFree(GetProcessHeap(), 0, pszPersonal
);
2147 xdg_desktop_dir
= xdg_results
? xdg_results
[num
- 1] : NULL
;
2148 if (xdg_desktop_dir
||
2149 (_SHAppendToUnixPath(szDesktopTarget
, DesktopW
) &&
2150 !stat(szDesktopTarget
, &statFolder
) && S_ISDIR(statFolder
.st_mode
)))
2152 hr
= SHGetFolderPathW(NULL
, CSIDL_DESKTOPDIRECTORY
|CSIDL_FLAG_CREATE
, NULL
,
2153 SHGFP_TYPE_DEFAULT
, wszTempPath
);
2154 if (SUCCEEDED(hr
) && (pszDesktop
= wine_get_unix_file_name(wszTempPath
)))
2157 if (xdg_desktop_dir
)
2158 symlink(xdg_desktop_dir
, pszDesktop
);
2160 symlink(szDesktopTarget
, pszDesktop
);
2161 HeapFree(GetProcessHeap(), 0, pszDesktop
);
2165 /* Free resources allocated by XDG_UserDirLookup() */
2168 for (i
= 0; i
< num
; i
++)
2169 HeapFree(GetProcessHeap(), 0, xdg_results
[i
]);
2170 HeapFree(GetProcessHeap(), 0, xdg_results
);
2174 /* Register the default values in the registry, as some apps seem to depend
2175 * on their presence. The set registered was taken from Windows XP.
2177 HRESULT
SHELL_RegisterShellFolders(void)
2181 /* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
2182 * 'My Video', 'My Music' and 'Desktop' in advance, so that the
2183 * _SHRegister*ShellFolders() functions will find everything nice and clean
2184 * and thus will not attempt to create them in the profile directory. */
2185 _SHCreateSymbolicLinks();
2187 hr
= _SHRegisterUserShellFolders(TRUE
);
2189 hr
= _SHRegisterUserShellFolders(FALSE
);
2191 hr
= _SHRegisterCommonShellFolders();
2195 /*************************************************************************
2196 * SHGetSpecialFolderPathA [SHELL32.@]
2198 BOOL WINAPI
SHGetSpecialFolderPathA (
2204 return (SHGetFolderPathA(
2206 nFolder
+ (bCreate
? CSIDL_FLAG_CREATE
: 0),
2209 szPath
)) == S_OK
? TRUE
: FALSE
;
2212 /*************************************************************************
2213 * SHGetSpecialFolderPathW
2215 BOOL WINAPI
SHGetSpecialFolderPathW (
2221 return (SHGetFolderPathW(
2223 nFolder
+ (bCreate
? CSIDL_FLAG_CREATE
: 0),
2226 szPath
)) == S_OK
? TRUE
: FALSE
;
2229 /*************************************************************************
2230 * SHGetSpecialFolderPath (SHELL32.175)
2232 BOOL WINAPI
SHGetSpecialFolderPathAW (
2239 if (SHELL_OsIsUnicode())
2240 return SHGetSpecialFolderPathW (hwndOwner
, szPath
, nFolder
, bCreate
);
2241 return SHGetSpecialFolderPathA (hwndOwner
, szPath
, nFolder
, bCreate
);
2244 /*************************************************************************
2245 * SHGetFolderLocation [SHELL32.@]
2247 * Gets the folder locations from the registry and creates a pidl.
2251 * nFolder [I] CSIDL_xxxxx
2252 * hToken [I] token representing user, or NULL for current user, or -1 for
2254 * dwReserved [I] must be zero
2255 * ppidl [O] PIDL of a special folder
2259 * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
2262 * Creates missing reg keys and directories.
2263 * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
2264 * virtual folders that are handled here.
2266 HRESULT WINAPI
SHGetFolderLocation(
2271 LPITEMIDLIST
*ppidl
)
2273 HRESULT hr
= E_INVALIDARG
;
2275 TRACE("%p 0x%08x %p 0x%08x %p\n",
2276 hwndOwner
, nFolder
, hToken
, dwReserved
, ppidl
);
2279 return E_INVALIDARG
;
2281 return E_INVALIDARG
;
2283 /* The virtual folders' locations are not user-dependent */
2288 *ppidl
= _ILCreateDesktop();
2291 case CSIDL_PERSONAL
:
2292 *ppidl
= _ILCreateMyDocuments();
2295 case CSIDL_INTERNET
:
2296 *ppidl
= _ILCreateIExplore();
2299 case CSIDL_CONTROLS
:
2300 *ppidl
= _ILCreateControlPanel();
2303 case CSIDL_PRINTERS
:
2304 *ppidl
= _ILCreatePrinters();
2307 case CSIDL_BITBUCKET
:
2308 *ppidl
= _ILCreateBitBucket();
2312 *ppidl
= _ILCreateMyComputer();
2316 *ppidl
= _ILCreateNetwork();
2321 WCHAR szPath
[MAX_PATH
];
2323 hr
= SHGetFolderPathW(hwndOwner
, nFolder
, hToken
,
2324 SHGFP_TYPE_CURRENT
, szPath
);
2329 TRACE("Value=%s\n", debugstr_w(szPath
));
2330 hr
= SHILCreateFromPathW(szPath
, ppidl
, &attributes
);
2332 else if (hr
== HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
))
2334 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
2335 * version 6.0 returns E_FAIL for nonexistent paths
2344 TRACE("-- (new pidl %p)\n",*ppidl
);
2348 /*************************************************************************
2349 * SHGetSpecialFolderLocation [SHELL32.@]
2352 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2355 HRESULT WINAPI
SHGetSpecialFolderLocation(
2358 LPITEMIDLIST
* ppidl
)
2360 HRESULT hr
= E_INVALIDARG
;
2362 TRACE("(%p,0x%x,%p)\n", hwndOwner
,nFolder
,ppidl
);
2365 return E_INVALIDARG
;
2367 hr
= SHGetFolderLocation(hwndOwner
, nFolder
, NULL
, 0, ppidl
);