fe6aef134d7aa4ccf7eb1bfabf05bd46bd881807
[reactos.git] / reactos / lib / shell32 / shellpath.c
1 /*
2 * Path Functions
3 *
4 * Copyright 1998, 1999, 2000 Juergen Schmied
5 * Copyright 2004 Juan Lang
6 *
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.
11 *
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.
16 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * NOTES:
22 *
23 * Many of these functions are in SHLWAPI.DLL also
24 *
25 */
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <stdarg.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include "wine/debug.h"
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winnls.h"
37 #include "winreg.h"
38 #include "wingdi.h"
39 #include "winuser.h"
40
41 #include "shlobj.h"
42 #include "shresdef.h"
43 #include "shell32_main.h"
44 #include "undocshell.h"
45 #include "pidl.h"
46 #include "wine/unicode.h"
47 #include "shlwapi.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(shell);
50
51 /*
52 ########## Combining and Constructing paths ##########
53 */
54
55 /*************************************************************************
56 * PathAppend [SHELL32.36]
57 */
58 BOOL WINAPI PathAppendAW(
59 LPVOID lpszPath1,
60 LPCVOID lpszPath2)
61 {
62 if (SHELL_OsIsUnicode())
63 return PathAppendW(lpszPath1, lpszPath2);
64 return PathAppendA(lpszPath1, lpszPath2);
65 }
66
67 /*************************************************************************
68 * PathCombine [SHELL32.37]
69 */
70 LPVOID WINAPI PathCombineAW(
71 LPVOID szDest,
72 LPCVOID lpszDir,
73 LPCVOID lpszFile)
74 {
75 if (SHELL_OsIsUnicode())
76 return PathCombineW( szDest, lpszDir, lpszFile );
77 return PathCombineA( szDest, lpszDir, lpszFile );
78 }
79
80 /*************************************************************************
81 * PathAddBackslash [SHELL32.32]
82 */
83 LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
84 {
85 if(SHELL_OsIsUnicode())
86 return PathAddBackslashW(lpszPath);
87 return PathAddBackslashA(lpszPath);
88 }
89
90 /*************************************************************************
91 * PathBuildRoot [SHELL32.30]
92 */
93 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
94 {
95 if(SHELL_OsIsUnicode())
96 return PathBuildRootW(lpszPath, drive);
97 return PathBuildRootA(lpszPath, drive);
98 }
99
100 /*
101 Extracting Component Parts
102 */
103
104 /*************************************************************************
105 * PathFindFileName [SHELL32.34]
106 */
107 LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
108 {
109 if(SHELL_OsIsUnicode())
110 return PathFindFileNameW(lpszPath);
111 return PathFindFileNameA(lpszPath);
112 }
113
114 /*************************************************************************
115 * PathFindExtension [SHELL32.31]
116 */
117 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
118 {
119 if (SHELL_OsIsUnicode())
120 return PathFindExtensionW(lpszPath);
121 return PathFindExtensionA(lpszPath);
122
123 }
124
125 /*************************************************************************
126 * PathGetExtensionA [internal]
127 *
128 * NOTES
129 * exported by ordinal
130 * return value points to the first char after the dot
131 */
132 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
133 {
134 TRACE("(%s)\n",lpszPath);
135
136 lpszPath = PathFindExtensionA(lpszPath);
137 return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
138 }
139
140 /*************************************************************************
141 * PathGetExtensionW [internal]
142 */
143 static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
144 {
145 TRACE("(%s)\n",debugstr_w(lpszPath));
146
147 lpszPath = PathFindExtensionW(lpszPath);
148 return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
149 }
150
151 /*************************************************************************
152 * PathGetExtension [SHELL32.158]
153 */
154 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,DWORD void1, DWORD void2)
155 {
156 if (SHELL_OsIsUnicode())
157 return PathGetExtensionW(lpszPath);
158 return PathGetExtensionA(lpszPath);
159 }
160
161 /*************************************************************************
162 * PathGetArgs [SHELL32.52]
163 */
164 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath)
165 {
166 if (SHELL_OsIsUnicode())
167 return PathGetArgsW(lpszPath);
168 return PathGetArgsA(lpszPath);
169 }
170
171 /*************************************************************************
172 * PathGetDriveNumber [SHELL32.57]
173 */
174 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
175 {
176 if (SHELL_OsIsUnicode())
177 return PathGetDriveNumberW(lpszPath);
178 return PathGetDriveNumberA(lpszPath);
179 }
180
181 /*************************************************************************
182 * PathRemoveFileSpec [SHELL32.35]
183 */
184 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
185 {
186 if (SHELL_OsIsUnicode())
187 return PathRemoveFileSpecW(lpszPath);
188 return PathRemoveFileSpecA(lpszPath);
189 }
190
191 /*************************************************************************
192 * PathStripPath [SHELL32.38]
193 */
194 void WINAPI PathStripPathAW(LPVOID lpszPath)
195 {
196 if (SHELL_OsIsUnicode())
197 PathStripPathW(lpszPath);
198 else
199 PathStripPathA(lpszPath);
200 }
201
202 /*************************************************************************
203 * PathStripToRoot [SHELL32.50]
204 */
205 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath)
206 {
207 if (SHELL_OsIsUnicode())
208 return PathStripToRootW(lpszPath);
209 return PathStripToRootA(lpszPath);
210 }
211
212 /*************************************************************************
213 * PathRemoveArgs [SHELL32.251]
214 */
215 void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
216 {
217 if (SHELL_OsIsUnicode())
218 PathRemoveArgsW(lpszPath);
219 else
220 PathRemoveArgsA(lpszPath);
221 }
222
223 /*************************************************************************
224 * PathRemoveExtension [SHELL32.250]
225 */
226 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
227 {
228 if (SHELL_OsIsUnicode())
229 PathRemoveExtensionW(lpszPath);
230 else
231 PathRemoveExtensionA(lpszPath);
232 }
233
234
235 /*
236 Path Manipulations
237 */
238
239 /*************************************************************************
240 * PathGetShortPathA [internal]
241 */
242 static void PathGetShortPathA(LPSTR pszPath)
243 {
244 CHAR path[MAX_PATH];
245
246 TRACE("%s\n", pszPath);
247
248 if (GetShortPathNameA(pszPath, path, MAX_PATH))
249 {
250 lstrcpyA(pszPath, path);
251 }
252 }
253
254 /*************************************************************************
255 * PathGetShortPathW [internal]
256 */
257 static void PathGetShortPathW(LPWSTR pszPath)
258 {
259 WCHAR path[MAX_PATH];
260
261 TRACE("%s\n", debugstr_w(pszPath));
262
263 if (GetShortPathNameW(pszPath, path, MAX_PATH))
264 {
265 lstrcpyW(pszPath, path);
266 }
267 }
268
269 /*************************************************************************
270 * PathGetShortPath [SHELL32.92]
271 */
272 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
273 {
274 if(SHELL_OsIsUnicode())
275 PathGetShortPathW(pszPath);
276 PathGetShortPathA(pszPath);
277 }
278
279 /*************************************************************************
280 * PathRemoveBlanks [SHELL32.33]
281 */
282 void WINAPI PathRemoveBlanksAW(LPVOID str)
283 {
284 if(SHELL_OsIsUnicode())
285 PathRemoveBlanksW(str);
286 else
287 PathRemoveBlanksA(str);
288 }
289
290 /*************************************************************************
291 * PathQuoteSpaces [SHELL32.55]
292 */
293 VOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
294 {
295 if(SHELL_OsIsUnicode())
296 PathQuoteSpacesW(lpszPath);
297 else
298 PathQuoteSpacesA(lpszPath);
299 }
300
301 /*************************************************************************
302 * PathUnquoteSpaces [SHELL32.56]
303 */
304 VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
305 {
306 if(SHELL_OsIsUnicode())
307 PathUnquoteSpacesW(str);
308 else
309 PathUnquoteSpacesA(str);
310 }
311
312 /*************************************************************************
313 * PathParseIconLocation [SHELL32.249]
314 */
315 int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
316 {
317 if(SHELL_OsIsUnicode())
318 return PathParseIconLocationW(lpszPath);
319 return PathParseIconLocationA(lpszPath);
320 }
321
322 /*
323 ########## Path Testing ##########
324 */
325 /*************************************************************************
326 * PathIsUNC [SHELL32.39]
327 */
328 BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
329 {
330 if (SHELL_OsIsUnicode())
331 return PathIsUNCW( lpszPath );
332 return PathIsUNCA( lpszPath );
333 }
334
335 /*************************************************************************
336 * PathIsRelative [SHELL32.40]
337 */
338 BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
339 {
340 if (SHELL_OsIsUnicode())
341 return PathIsRelativeW( lpszPath );
342 return PathIsRelativeA( lpszPath );
343 }
344
345 /*************************************************************************
346 * PathIsRoot [SHELL32.29]
347 */
348 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
349 {
350 if (SHELL_OsIsUnicode())
351 return PathIsRootW(lpszPath);
352 return PathIsRootA(lpszPath);
353 }
354
355 /*************************************************************************
356 * PathIsExeA [internal]
357 */
358 static BOOL PathIsExeA (LPCSTR lpszPath)
359 {
360 LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
361 int i;
362 static const char * const lpszExtensions[] =
363 {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
364
365 TRACE("path=%s\n",lpszPath);
366
367 for(i=0; lpszExtensions[i]; i++)
368 if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
369
370 return FALSE;
371 }
372
373 /*************************************************************************
374 * PathIsExeW [internal]
375 */
376 static BOOL PathIsExeW (LPCWSTR lpszPath)
377 {
378 LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
379 int i;
380 static const WCHAR lpszExtensions[][4] =
381 {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
382 {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
383 {'s','c','r','\0'}, {'\0'} };
384
385 TRACE("path=%s\n",debugstr_w(lpszPath));
386
387 for(i=0; lpszExtensions[i][0]; i++)
388 if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
389
390 return FALSE;
391 }
392
393 /*************************************************************************
394 * PathIsExe [SHELL32.43]
395 */
396 BOOL WINAPI PathIsExeAW (LPCVOID path)
397 {
398 if (SHELL_OsIsUnicode())
399 return PathIsExeW (path);
400 return PathIsExeA(path);
401 }
402
403 /*************************************************************************
404 * PathIsDirectory [SHELL32.159]
405 */
406 BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
407 {
408 if (SHELL_OsIsUnicode())
409 return PathIsDirectoryW (lpszPath);
410 return PathIsDirectoryA (lpszPath);
411 }
412
413 /*************************************************************************
414 * PathFileExists [SHELL32.45]
415 */
416 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
417 {
418 if (SHELL_OsIsUnicode())
419 return PathFileExistsW (lpszPath);
420 return PathFileExistsA (lpszPath);
421 }
422
423 /*************************************************************************
424 * PathMatchSpec [SHELL32.46]
425 */
426 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask)
427 {
428 if (SHELL_OsIsUnicode())
429 return PathMatchSpecW( name, mask );
430 return PathMatchSpecA( name, mask );
431 }
432
433 /*************************************************************************
434 * PathIsSameRoot [SHELL32.650]
435 */
436 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
437 {
438 if (SHELL_OsIsUnicode())
439 return PathIsSameRootW(lpszPath1, lpszPath2);
440 return PathIsSameRootA(lpszPath1, lpszPath2);
441 }
442
443 /*************************************************************************
444 * IsLFNDriveA [SHELL32.41]
445 */
446 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
447 {
448 DWORD fnlen;
449
450 if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
451 return FALSE;
452 return fnlen > 12;
453 }
454
455 /*************************************************************************
456 * IsLFNDriveW [SHELL32.42]
457 */
458 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
459 {
460 DWORD fnlen;
461
462 if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
463 return FALSE;
464 return fnlen > 12;
465 }
466
467 /*************************************************************************
468 * IsLFNDrive [SHELL32.119]
469 */
470 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
471 {
472 if (SHELL_OsIsUnicode())
473 return IsLFNDriveW(lpszPath);
474 return IsLFNDriveA(lpszPath);
475 }
476
477 /*
478 ########## Creating Something Unique ##########
479 */
480 /*************************************************************************
481 * PathMakeUniqueNameA [internal]
482 */
483 BOOL WINAPI PathMakeUniqueNameA(
484 LPSTR lpszBuffer,
485 DWORD dwBuffSize,
486 LPCSTR lpszShortName,
487 LPCSTR lpszLongName,
488 LPCSTR lpszPathName)
489 {
490 FIXME("%p %lu %s %s %s stub\n",
491 lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
492 debugstr_a(lpszLongName), debugstr_a(lpszPathName));
493 return TRUE;
494 }
495
496 /*************************************************************************
497 * PathMakeUniqueNameW [internal]
498 */
499 BOOL WINAPI PathMakeUniqueNameW(
500 LPWSTR lpszBuffer,
501 DWORD dwBuffSize,
502 LPCWSTR lpszShortName,
503 LPCWSTR lpszLongName,
504 LPCWSTR lpszPathName)
505 {
506 FIXME("%p %lu %s %s %s stub\n",
507 lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
508 debugstr_w(lpszLongName), debugstr_w(lpszPathName));
509 return TRUE;
510 }
511
512 /*************************************************************************
513 * PathMakeUniqueName [SHELL32.47]
514 */
515 BOOL WINAPI PathMakeUniqueNameAW(
516 LPVOID lpszBuffer,
517 DWORD dwBuffSize,
518 LPCVOID lpszShortName,
519 LPCVOID lpszLongName,
520 LPCVOID lpszPathName)
521 {
522 if (SHELL_OsIsUnicode())
523 return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
524 return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
525 }
526
527 /*************************************************************************
528 * PathYetAnotherMakeUniqueName [SHELL32.75]
529 *
530 * NOTES
531 * exported by ordinal
532 */
533 BOOL WINAPI PathYetAnotherMakeUniqueName(
534 LPWSTR lpszBuffer,
535 LPCWSTR lpszPathName,
536 LPCWSTR lpszShortName,
537 LPCWSTR lpszLongName)
538 {
539 FIXME("(%p, %s, %s ,%s):stub.\n",
540 lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
541 return TRUE;
542 }
543
544
545 /*
546 ########## cleaning and resolving paths ##########
547 */
548
549 /*************************************************************************
550 * PathFindOnPath [SHELL32.145]
551 */
552 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID sOtherDirs)
553 {
554 if (SHELL_OsIsUnicode())
555 return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs);
556 return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs);
557 }
558
559 /*************************************************************************
560 * PathCleanupSpec [SHELL32.171]
561 *
562 * lpszFile is changed in place.
563 */
564 int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
565 {
566 int i = 0;
567 DWORD rc = 0;
568 int length = 0;
569
570 if (SHELL_OsIsUnicode())
571 {
572 LPWSTR p = lpszFileW;
573
574 TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
575
576 if (lpszPathW)
577 length = strlenW(lpszPathW);
578
579 while (*p)
580 {
581 int gct = PathGetCharTypeW(*p);
582 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
583 {
584 lpszFileW[i]='-';
585 rc |= PCS_REPLACEDCHAR;
586 }
587 else
588 lpszFileW[i]=*p;
589 i++;
590 p++;
591 if (length + i == MAX_PATH)
592 {
593 rc |= PCS_FATAL | PCS_PATHTOOLONG;
594 break;
595 }
596 }
597 lpszFileW[i]=0;
598 }
599 else
600 {
601 LPSTR lpszFileA = (LPSTR)lpszFileW;
602 LPCSTR lpszPathA = (LPSTR)lpszPathW;
603 LPSTR p = lpszFileA;
604
605 TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
606
607 if (lpszPathA)
608 length = strlen(lpszPathA);
609
610 while (*p)
611 {
612 int gct = PathGetCharTypeA(*p);
613 if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
614 {
615 lpszFileA[i]='-';
616 rc |= PCS_REPLACEDCHAR;
617 }
618 else
619 lpszFileA[i]=*p;
620 i++;
621 p++;
622 if (length + i == MAX_PATH)
623 {
624 rc |= PCS_FATAL | PCS_PATHTOOLONG;
625 break;
626 }
627 }
628 lpszFileA[i]=0;
629 }
630 return rc;
631 }
632
633 /*************************************************************************
634 * PathQualifyA [SHELL32]
635 */
636 BOOL WINAPI PathQualifyA(LPCSTR pszPath)
637 {
638 FIXME("%s\n",pszPath);
639 return 0;
640 }
641
642 /*************************************************************************
643 * PathQualifyW [SHELL32]
644 */
645 BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
646 {
647 FIXME("%s\n",debugstr_w(pszPath));
648 return 0;
649 }
650
651 /*************************************************************************
652 * PathQualify [SHELL32.49]
653 */
654 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
655 {
656 if (SHELL_OsIsUnicode())
657 return PathQualifyW(pszPath);
658 return PathQualifyA(pszPath);
659 }
660
661 /*************************************************************************
662 * PathResolveA [SHELL32.51]
663 */
664 BOOL WINAPI PathResolveA(
665 LPSTR lpszPath,
666 LPCSTR *alpszPaths,
667 DWORD dwFlags)
668 {
669 FIXME("(%s,%p,0x%08lx),stub!\n",
670 lpszPath, *alpszPaths, dwFlags);
671 return 0;
672 }
673
674 /*************************************************************************
675 * PathResolveW [SHELL32]
676 */
677 BOOL WINAPI PathResolveW(
678 LPWSTR lpszPath,
679 LPCWSTR *alpszPaths,
680 DWORD dwFlags)
681 {
682 FIXME("(%s,%p,0x%08lx),stub!\n",
683 debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
684 return 0;
685 }
686
687 /*************************************************************************
688 * PathResolve [SHELL32.51]
689 */
690 BOOL WINAPI PathResolveAW(
691 LPVOID lpszPath,
692 LPCVOID *alpszPaths,
693 DWORD dwFlags)
694 {
695 if (SHELL_OsIsUnicode())
696 return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
697 return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
698 }
699
700 /*************************************************************************
701 * PathProcessCommandA [SHELL32.653]
702 */
703 HRESULT WINAPI PathProcessCommandA (
704 LPCSTR lpszPath,
705 LPSTR lpszBuff,
706 DWORD dwBuffSize,
707 DWORD dwFlags)
708 {
709 FIXME("%s %p 0x%04lx 0x%04lx stub\n",
710 lpszPath, lpszBuff, dwBuffSize, dwFlags);
711 strcpy(lpszBuff, lpszPath);
712 return 0;
713 }
714
715 /*************************************************************************
716 * PathProcessCommandW
717 */
718 HRESULT WINAPI PathProcessCommandW (
719 LPCWSTR lpszPath,
720 LPWSTR lpszBuff,
721 DWORD dwBuffSize,
722 DWORD dwFlags)
723 {
724 FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n",
725 debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
726 strcpyW(lpszBuff, lpszPath);
727 return 0;
728 }
729
730 /*************************************************************************
731 * PathProcessCommand (SHELL32.653)
732 */
733 HRESULT WINAPI PathProcessCommandAW (
734 LPCVOID lpszPath,
735 LPVOID lpszBuff,
736 DWORD dwBuffSize,
737 DWORD dwFlags)
738 {
739 if (SHELL_OsIsUnicode())
740 return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
741 return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
742 }
743
744 /*
745 ########## special ##########
746 */
747
748 /*************************************************************************
749 * PathSetDlgItemPath (SHELL32.48)
750 */
751 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
752 {
753 if (SHELL_OsIsUnicode())
754 PathSetDlgItemPathW(hDlg, id, pszPath);
755 else
756 PathSetDlgItemPathA(hDlg, id, pszPath);
757 }
758
759 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'};
760 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'};
761 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
762 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
763 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
764 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'};
765 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
766 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
767 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
768 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
769 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
770 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
771 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
772 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
773 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
774 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
775 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
776 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
777 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
778 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
779 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
780 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
781 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
782 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
783 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
784 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
785 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
786 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
787 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
788 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
789 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
790 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
791 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
792 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
793 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
794 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
795 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
796 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
797 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
798 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
799 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
800 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};
801 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
802 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
803 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'};
804 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'};
805 /* This defaults to L"Documents and Settings" on Windows 2000/XP, but we're
806 * acting more Windows 9x-like for now.
807 */
808 static const WCHAR szDefaultProfileDirW[] = {'p','r','o','f','i','l','e','s','\0'};
809 static const WCHAR AllUsersW[] = {'A','l','l',' ','U','s','e','r','s','\0'};
810
811 typedef enum _CSIDL_Type {
812 CSIDL_Type_User,
813 CSIDL_Type_AllUsers,
814 CSIDL_Type_CurrVer,
815 CSIDL_Type_Disallowed,
816 CSIDL_Type_NonExistent,
817 CSIDL_Type_WindowsPath,
818 CSIDL_Type_SystemPath,
819 } CSIDL_Type;
820
821 typedef struct
822 {
823 CSIDL_Type type;
824 LPCWSTR szValueName;
825 LPCWSTR szDefaultPath; /* fallback string or resource ID */
826 } CSIDL_DATA;
827
828 static const CSIDL_DATA CSIDL_Data[] =
829 {
830 { /* 0x00 - CSIDL_DESKTOP */
831 CSIDL_Type_User,
832 DesktopW,
833 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
834 },
835 { /* 0x01 - CSIDL_INTERNET */
836 CSIDL_Type_Disallowed,
837 NULL,
838 NULL
839 },
840 { /* 0x02 - CSIDL_PROGRAMS */
841 CSIDL_Type_User,
842 ProgramsW,
843 MAKEINTRESOURCEW(IDS_PROGRAMS)
844 },
845 { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
846 CSIDL_Type_SystemPath,
847 NULL,
848 NULL
849 },
850 { /* 0x04 - CSIDL_PRINTERS */
851 CSIDL_Type_SystemPath,
852 NULL,
853 NULL
854 },
855 { /* 0x05 - CSIDL_PERSONAL */
856 CSIDL_Type_User,
857 PersonalW,
858 MAKEINTRESOURCEW(IDS_PERSONAL)
859 },
860 { /* 0x06 - CSIDL_FAVORITES */
861 CSIDL_Type_User,
862 FavoritesW,
863 MAKEINTRESOURCEW(IDS_FAVORITES)
864 },
865 { /* 0x07 - CSIDL_STARTUP */
866 CSIDL_Type_User,
867 StartUpW,
868 MAKEINTRESOURCEW(IDS_STARTUP)
869 },
870 { /* 0x08 - CSIDL_RECENT */
871 CSIDL_Type_User,
872 RecentW,
873 MAKEINTRESOURCEW(IDS_RECENT)
874 },
875 { /* 0x09 - CSIDL_SENDTO */
876 CSIDL_Type_User,
877 SendToW,
878 MAKEINTRESOURCEW(IDS_SENDTO)
879 },
880 { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
881 CSIDL_Type_Disallowed,
882 NULL,
883 NULL,
884 },
885 { /* 0x0b - CSIDL_STARTMENU */
886 CSIDL_Type_User,
887 Start_MenuW,
888 MAKEINTRESOURCEW(IDS_STARTMENU)
889 },
890 { /* 0x0c - CSIDL_MYDOCUMENTS */
891 CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
892 NULL,
893 NULL
894 },
895 { /* 0x0d - CSIDL_MYMUSIC */
896 CSIDL_Type_User,
897 My_MusicW,
898 MAKEINTRESOURCEW(IDS_MYMUSIC)
899 },
900 { /* 0x0e - CSIDL_MYVIDEO */
901 CSIDL_Type_User,
902 My_VideoW,
903 MAKEINTRESOURCEW(IDS_MYVIDEO)
904 },
905 { /* 0x0f - unassigned */
906 CSIDL_Type_Disallowed,
907 NULL,
908 NULL,
909 },
910 { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
911 CSIDL_Type_User,
912 DesktopW,
913 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
914 },
915 { /* 0x11 - CSIDL_DRIVES */
916 CSIDL_Type_Disallowed,
917 NULL,
918 NULL,
919 },
920 { /* 0x12 - CSIDL_NETWORK */
921 CSIDL_Type_Disallowed,
922 NULL,
923 NULL,
924 },
925 { /* 0x13 - CSIDL_NETHOOD */
926 CSIDL_Type_User,
927 NetHoodW,
928 MAKEINTRESOURCEW(IDS_NETHOOD)
929 },
930 { /* 0x14 - CSIDL_FONTS */
931 CSIDL_Type_WindowsPath,
932 NULL,
933 FontsW
934 },
935 { /* 0x15 - CSIDL_TEMPLATES */
936 CSIDL_Type_User,
937 TemplatesW,
938 MAKEINTRESOURCEW(IDS_TEMPLATES)
939 },
940 { /* 0x16 - CSIDL_COMMON_STARTMENU */
941 CSIDL_Type_AllUsers,
942 Common_Start_MenuW,
943 MAKEINTRESOURCEW(IDS_STARTMENU)
944 },
945 { /* 0x17 - CSIDL_COMMON_PROGRAMS */
946 CSIDL_Type_AllUsers,
947 Common_ProgramsW,
948 MAKEINTRESOURCEW(IDS_PROGRAMS)
949 },
950 { /* 0x18 - CSIDL_COMMON_STARTUP */
951 CSIDL_Type_AllUsers,
952 Common_StartUpW,
953 MAKEINTRESOURCEW(IDS_STARTUP)
954 },
955 { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
956 CSIDL_Type_AllUsers,
957 Common_DesktopW,
958 MAKEINTRESOURCEW(IDS_DESKTOP)
959 },
960 { /* 0x1a - CSIDL_APPDATA */
961 CSIDL_Type_User,
962 AppDataW,
963 MAKEINTRESOURCEW(IDS_APPDATA)
964 },
965 { /* 0x1b - CSIDL_PRINTHOOD */
966 CSIDL_Type_User,
967 PrintHoodW,
968 MAKEINTRESOURCEW(IDS_PRINTHOOD)
969 },
970 { /* 0x1c - CSIDL_LOCAL_APPDATA */
971 CSIDL_Type_User,
972 Local_AppDataW,
973 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
974 },
975 { /* 0x1d - CSIDL_ALTSTARTUP */
976 CSIDL_Type_NonExistent,
977 NULL,
978 NULL
979 },
980 { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
981 CSIDL_Type_NonExistent,
982 NULL,
983 NULL
984 },
985 { /* 0x1f - CSIDL_COMMON_FAVORITES */
986 CSIDL_Type_AllUsers,
987 FavoritesW,
988 MAKEINTRESOURCEW(IDS_FAVORITES)
989 },
990 { /* 0x20 - CSIDL_INTERNET_CACHE */
991 CSIDL_Type_User,
992 CacheW,
993 MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
994 },
995 { /* 0x21 - CSIDL_COOKIES */
996 CSIDL_Type_User,
997 CookiesW,
998 MAKEINTRESOURCEW(IDS_COOKIES)
999 },
1000 { /* 0x22 - CSIDL_HISTORY */
1001 CSIDL_Type_User,
1002 HistoryW,
1003 MAKEINTRESOURCEW(IDS_HISTORY)
1004 },
1005 { /* 0x23 - CSIDL_COMMON_APPDATA */
1006 CSIDL_Type_AllUsers,
1007 Common_AppDataW,
1008 MAKEINTRESOURCEW(IDS_APPDATA)
1009 },
1010 { /* 0x24 - CSIDL_WINDOWS */
1011 CSIDL_Type_WindowsPath,
1012 NULL,
1013 NULL
1014 },
1015 { /* 0x25 - CSIDL_SYSTEM */
1016 CSIDL_Type_SystemPath,
1017 NULL,
1018 NULL
1019 },
1020 { /* 0x26 - CSIDL_PROGRAM_FILES */
1021 CSIDL_Type_CurrVer,
1022 ProgramFilesDirW,
1023 MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
1024 },
1025 { /* 0x27 - CSIDL_MYPICTURES */
1026 CSIDL_Type_User,
1027 My_PicturesW,
1028 MAKEINTRESOURCEW(IDS_MYPICTURES)
1029 },
1030 { /* 0x28 - CSIDL_PROFILE */
1031 CSIDL_Type_User,
1032 NULL,
1033 NULL
1034 },
1035 { /* 0x29 - CSIDL_SYSTEMX86 */
1036 CSIDL_Type_NonExistent,
1037 NULL,
1038 NULL
1039 },
1040 { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
1041 CSIDL_Type_NonExistent,
1042 NULL,
1043 NULL
1044 },
1045 { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
1046 CSIDL_Type_CurrVer,
1047 CommonFilesDirW,
1048 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
1049 },
1050 { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
1051 CSIDL_Type_NonExistent,
1052 NULL,
1053 NULL
1054 },
1055 { /* 0x2d - CSIDL_COMMON_TEMPLATES */
1056 CSIDL_Type_AllUsers,
1057 Common_TemplatesW,
1058 MAKEINTRESOURCEW(IDS_TEMPLATES)
1059 },
1060 { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
1061 CSIDL_Type_AllUsers,
1062 Common_DocumentsW,
1063 MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
1064 },
1065 { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
1066 CSIDL_Type_AllUsers,
1067 Common_Administrative_ToolsW,
1068 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1069 },
1070 { /* 0x30 - CSIDL_ADMINTOOLS */
1071 CSIDL_Type_User,
1072 Administrative_ToolsW,
1073 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1074 },
1075 { /* 0x31 - CSIDL_CONNECTIONS */
1076 CSIDL_Type_Disallowed,
1077 NULL,
1078 NULL
1079 },
1080 { /* 0x32 - unassigned */
1081 CSIDL_Type_Disallowed,
1082 NULL,
1083 NULL
1084 },
1085 { /* 0x33 - unassigned */
1086 CSIDL_Type_Disallowed,
1087 NULL,
1088 NULL
1089 },
1090 { /* 0x34 - unassigned */
1091 CSIDL_Type_Disallowed,
1092 NULL,
1093 NULL
1094 },
1095 { /* 0x35 - CSIDL_COMMON_MUSIC */
1096 CSIDL_Type_AllUsers,
1097 CommonMusicW,
1098 MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
1099 },
1100 { /* 0x36 - CSIDL_COMMON_PICTURES */
1101 CSIDL_Type_AllUsers,
1102 CommonPicturesW,
1103 MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
1104 },
1105 { /* 0x37 - CSIDL_COMMON_VIDEO */
1106 CSIDL_Type_AllUsers,
1107 CommonVideoW,
1108 MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
1109 },
1110 { /* 0x38 - CSIDL_RESOURCES */
1111 CSIDL_Type_WindowsPath,
1112 NULL,
1113 ResourcesW
1114 },
1115 { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
1116 CSIDL_Type_NonExistent,
1117 NULL,
1118 NULL
1119 },
1120 { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
1121 CSIDL_Type_NonExistent,
1122 NULL,
1123 NULL
1124 },
1125 { /* 0x3b - CSIDL_CDBURN_AREA */
1126 CSIDL_Type_User,
1127 CD_BurningW,
1128 MAKEINTRESOURCEW(IDS_CDBURN_AREA)
1129 },
1130 { /* 0x3c unassigned */
1131 CSIDL_Type_Disallowed,
1132 NULL,
1133 NULL
1134 },
1135 { /* 0x3d - CSIDL_COMPUTERSNEARME */
1136 CSIDL_Type_Disallowed, /* FIXME */
1137 NULL,
1138 NULL
1139 },
1140 { /* 0x3e - CSIDL_PROFILES */
1141 CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
1142 NULL,
1143 NULL
1144 }
1145 };
1146
1147 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest);
1148
1149 /* Gets the value named value from the registry key
1150 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1151 * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
1152 * is assumed to be MAX_PATH WCHARs in length.
1153 * If it exists, expands the value and writes the expanded value to
1154 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
1155 * Returns successful error code if the value was retrieved from the registry,
1156 * and a failure otherwise.
1157 */
1158 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
1159 LPCWSTR value, LPWSTR path)
1160 {
1161 HRESULT hr;
1162 WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
1163 LPCWSTR pShellFolderPath, pUserShellFolderPath;
1164 DWORD dwDisp, dwType, dwPathLen = MAX_PATH;
1165 HKEY userShellFolderKey, shellFolderKey;
1166
1167 TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
1168 path);
1169
1170 if (userPrefix)
1171 {
1172 strcpyW(shellFolderPath, userPrefix);
1173 PathAddBackslashW(shellFolderPath);
1174 strcatW(shellFolderPath, szSHFolders);
1175 pShellFolderPath = shellFolderPath;
1176 strcpyW(userShellFolderPath, userPrefix);
1177 PathAddBackslashW(userShellFolderPath);
1178 strcatW(userShellFolderPath, szSHUserFolders);
1179 pUserShellFolderPath = userShellFolderPath;
1180 }
1181 else
1182 {
1183 pUserShellFolderPath = szSHUserFolders;
1184 pShellFolderPath = szSHFolders;
1185 }
1186
1187 if (RegCreateKeyExW(rootKey, pShellFolderPath, 0, NULL, 0, KEY_ALL_ACCESS,
1188 NULL, &shellFolderKey, &dwDisp))
1189 {
1190 TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
1191 return E_FAIL;
1192 }
1193 if (RegCreateKeyExW(rootKey, pUserShellFolderPath, 0, NULL, 0,
1194 KEY_ALL_ACCESS, NULL, &userShellFolderKey, &dwDisp))
1195 {
1196 TRACE("Failed to create %s\n",
1197 debugstr_w(pUserShellFolderPath));
1198 RegCloseKey(shellFolderKey);
1199 return E_FAIL;
1200 }
1201
1202 if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
1203 (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
1204 {
1205 LONG ret;
1206
1207 path[dwPathLen / sizeof(WCHAR)] = '\0';
1208 if (dwType == REG_EXPAND_SZ && path[0] == '%')
1209 {
1210 WCHAR szTemp[MAX_PATH];
1211
1212 _SHExpandEnvironmentStrings(path, szTemp);
1213 lstrcpynW(path, szTemp, MAX_PATH);
1214 }
1215 ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
1216 (strlenW(path) + 1) * sizeof(WCHAR));
1217 if (ret != ERROR_SUCCESS)
1218 hr = HRESULT_FROM_WIN32(ret);
1219 else
1220 hr = S_OK;
1221 }
1222 else
1223 hr = E_FAIL;
1224 RegCloseKey(shellFolderKey);
1225 RegCloseKey(userShellFolderKey);
1226 TRACE("returning 0x%08lx\n", hr);
1227 return hr;
1228 }
1229
1230 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
1231 * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
1232 * - The entry's szDefaultPath may be either a string value or an integer
1233 * resource identifier. In the latter case, the string value of the resource
1234 * is written.
1235 * - Depending on the entry's type, the path may begin with an (unexpanded)
1236 * environment variable name. The caller is responsible for expanding
1237 * environment strings if so desired.
1238 * The types that are prepended with environment variables are:
1239 * CSIDL_Type_User: %USERPROFILE%
1240 * CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1241 * CSIDL_Type_CurrVer: %SystemDrive%
1242 * (Others might make sense too, but as yet are unneeded.)
1243 */
1244 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1245 {
1246 HRESULT hr;
1247 WCHAR resourcePath[MAX_PATH];
1248 LPCWSTR pDefaultPath = NULL;
1249
1250 TRACE("0x%02x,%p\n", folder, pszPath);
1251
1252 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1253 return E_INVALIDARG;
1254 if (!pszPath)
1255 return E_INVALIDARG;
1256
1257 /* Try special cases first */
1258 hr = E_FAIL;
1259 switch (folder)
1260 {
1261 case CSIDL_PERSONAL:
1262 case CSIDL_MYMUSIC:
1263 case CSIDL_MYPICTURES:
1264 case CSIDL_MYVIDEO:
1265 {
1266 const char *home = getenv("HOME");
1267
1268 /* special case for "My Documents", map to $HOME */
1269 if (home)
1270 {
1271 WCHAR homeW[MAX_PATH];
1272
1273 MultiByteToWideChar(CP_ACP, 0, home, -1, homeW, MAX_PATH);
1274 if (GetFullPathNameW(homeW, MAX_PATH, pszPath, NULL) != 0 &&
1275 PathIsDirectoryW(pszPath))
1276 hr = S_OK;
1277 }
1278 break;
1279 }
1280 case CSIDL_DESKTOP:
1281 case CSIDL_DESKTOPDIRECTORY:
1282 {
1283 const char *home = getenv("HOME");
1284
1285 /* special case for Desktop, map to $HOME/Desktop if it exists */
1286 if (home)
1287 {
1288 WCHAR desktopW[MAX_PATH];
1289
1290 MultiByteToWideChar(CP_ACP, 0, home, -1, desktopW, MAX_PATH);
1291 PathAppendW(desktopW, DesktopW);
1292 if (GetFullPathNameW(desktopW, MAX_PATH, pszPath, NULL) != 0 &&
1293 PathIsDirectoryW(pszPath))
1294 hr = S_OK;
1295 }
1296 break;
1297 }
1298 }
1299 if (SUCCEEDED(hr))
1300 return hr;
1301
1302 /* Either the folder was unhandled, or a suitable default wasn't found,
1303 * so use one of the resource-based defaults
1304 */
1305 if (CSIDL_Data[folder].szDefaultPath &&
1306 IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1307 {
1308 if (LoadStringW(shell32_hInstance,
1309 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1310 {
1311 hr = S_OK;
1312 pDefaultPath = resourcePath;
1313 }
1314 else
1315 {
1316 FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1317 debugstr_w(pszPath));
1318 hr = E_FAIL;
1319 }
1320 }
1321 else
1322 {
1323 hr = S_OK;
1324 pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1325 }
1326 if (SUCCEEDED(hr))
1327 {
1328 switch (CSIDL_Data[folder].type)
1329 {
1330 case CSIDL_Type_User:
1331 strcpyW(pszPath, UserProfileW);
1332 break;
1333 case CSIDL_Type_AllUsers:
1334 strcpyW(pszPath, AllUsersProfileW);
1335 break;
1336 case CSIDL_Type_CurrVer:
1337 strcpyW(pszPath, SystemDriveW);
1338 break;
1339 default:
1340 ; /* no corresponding env. var, do nothing */
1341 }
1342 if (pDefaultPath)
1343 {
1344 PathAddBackslashW(pszPath);
1345 strcatW(pszPath, pDefaultPath);
1346 }
1347 }
1348 TRACE("returning 0x%08lx\n", hr);
1349 return hr;
1350 }
1351
1352 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1353 * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
1354 * can be overridden in the HKLM\\szCurrentVersion key.
1355 * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1356 * the registry, uses _SHGetDefaultValue to get the value.
1357 */
1358 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1359 LPWSTR pszPath)
1360 {
1361 HRESULT hr;
1362
1363 TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath);
1364
1365 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1366 return E_INVALIDARG;
1367 if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1368 return E_INVALIDARG;
1369 if (!pszPath)
1370 return E_INVALIDARG;
1371
1372 if (dwFlags & SHGFP_TYPE_DEFAULT)
1373 hr = _SHGetDefaultValue(folder, pszPath);
1374 else
1375 {
1376 HKEY hKey;
1377 DWORD dwDisp;
1378
1379 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szCurrentVersion, 0,
1380 NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp))
1381 hr = E_FAIL;
1382 else
1383 {
1384 DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1385
1386 if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1387 &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1388 (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1389 {
1390 hr = _SHGetDefaultValue(folder, pszPath);
1391 dwType = REG_EXPAND_SZ;
1392 RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1393 (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
1394 }
1395 else
1396 {
1397 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1398 hr = S_OK;
1399 }
1400 RegCloseKey(hKey);
1401 }
1402 }
1403 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1404 return hr;
1405 }
1406
1407 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1408 * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
1409 * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
1410 * - if hToken is -1, looks in HKEY_USERS\.Default
1411 * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1412 * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
1413 * calls _SHGetDefaultValue for it.
1414 */
1415 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1416 LPWSTR pszPath)
1417 {
1418 HRESULT hr;
1419
1420 TRACE("%p,0x%08lx,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1421
1422 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1423 return E_INVALIDARG;
1424 if (CSIDL_Data[folder].type != CSIDL_Type_User)
1425 return E_INVALIDARG;
1426 if (!pszPath)
1427 return E_INVALIDARG;
1428
1429 /* Only the current user and the default user are supported right now
1430 * I'm afraid.
1431 * FIXME: should be able to call GetTokenInformation on the token,
1432 * then call ConvertSidToStringSidW on it to get the user prefix.
1433 * But Wine's registry doesn't store user info by sid, it stores it
1434 * by user name (and I don't know how to convert from a token to a
1435 * user name).
1436 */
1437 if (hToken != NULL && hToken != (HANDLE)-1)
1438 {
1439 FIXME("unsupported for user other than current or default\n");
1440 return E_FAIL;
1441 }
1442
1443 if (dwFlags & SHGFP_TYPE_DEFAULT)
1444 hr = _SHGetDefaultValue(folder, pszPath);
1445 else
1446 {
1447 LPCWSTR userPrefix = NULL;
1448 HKEY hRootKey;
1449
1450 if (hToken == (HANDLE)-1)
1451 {
1452 hRootKey = HKEY_USERS;
1453 userPrefix = DefaultW;
1454 }
1455 else /* hToken == NULL, other values disallowed above */
1456 hRootKey = HKEY_CURRENT_USER;
1457 hr = _SHGetUserShellFolderPath(hRootKey, userPrefix,
1458 CSIDL_Data[folder].szValueName, pszPath);
1459 if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1460 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1461 CSIDL_Data[folder].szValueName, pszPath);
1462 if (FAILED(hr))
1463 hr = _SHGetDefaultValue(folder, pszPath);
1464 }
1465 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1466 return hr;
1467 }
1468
1469 /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
1470 * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
1471 * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1472 * If this fails, falls back to _SHGetDefaultValue.
1473 */
1474 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1475 LPWSTR pszPath)
1476 {
1477 HRESULT hr;
1478
1479 TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath);
1480
1481 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1482 return E_INVALIDARG;
1483 if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1484 return E_INVALIDARG;
1485 if (!pszPath)
1486 return E_INVALIDARG;
1487
1488 if (dwFlags & SHGFP_TYPE_DEFAULT)
1489 hr = _SHGetDefaultValue(folder, pszPath);
1490 else
1491 {
1492 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1493 CSIDL_Data[folder].szValueName, pszPath);
1494 if (FAILED(hr))
1495 hr = _SHGetDefaultValue(folder, pszPath);
1496 }
1497 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1498 return hr;
1499 }
1500
1501 /* From the original Wine source:
1502 *
1503 * Attempts to expand environment variables from szSrc into szDest, which is
1504 * assumed to be MAX_PATH characters in length. Before referring to the
1505 * environment, handles a few variables directly, because the environment
1506 * variables may not be set when this is called (as during Wine's installation
1507 * when default values are being written to the registry).
1508 * The directly handled environment variables, and their source, are:
1509 * - ALLUSERSPROFILE, USERPROFILE: reads from the registry
1510 * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
1511 * path
1512 * If one of the directly handled environment variables is expanded, only
1513 * expands a single variable, and only in the beginning of szSrc.
1514 *
1515 * That's fine for Wine, but it breaks in ReactOS where we have profile paths
1516 * like "c:\documents and settings\Administrator.REACTOS". Anyway, we have the
1517 * environment variables handy so we'll just use them instead of hacking around
1518 */
1519 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest)
1520 {
1521 HRESULT hr = S_OK;
1522 WCHAR szTemp[MAX_PATH];
1523
1524 TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
1525
1526 if (!szSrc || !szDest) return E_INVALIDARG;
1527
1528 /* short-circuit if there's nothing to expand */
1529 if (szSrc[0] != '%')
1530 {
1531 strcpyW(szDest, szSrc);
1532 hr = S_OK;
1533 goto end;
1534 }
1535
1536 *szDest = 0;
1537 strcpyW(szTemp, szSrc);
1538 while (SUCCEEDED(hr) && szTemp[0] == '%')
1539 {
1540 DWORD ret = ExpandEnvironmentStringsW(szSrc, szDest, MAX_PATH);
1541
1542 if (ret > MAX_PATH)
1543 hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
1544 else if (ret == 0)
1545 hr = HRESULT_FROM_WIN32(GetLastError());
1546 else
1547 hr = S_OK;
1548 if (SUCCEEDED(hr) && szDest[0] == '%')
1549 strcpyW(szTemp, szDest);
1550 else
1551 {
1552 /* terminate loop */
1553 szTemp[0] = '\0';
1554 }
1555 }
1556 end:
1557 TRACE("returning 0x%08lx (input was %s, output is %s)\n", hr,
1558 debugstr_w(szSrc), debugstr_w(szDest));
1559 return hr;
1560 }
1561
1562 /*************************************************************************
1563 * SHGetFolderPathW [SHELL32.@]
1564 *
1565 * Convert nFolder to path.
1566 *
1567 * RETURNS
1568 * Success: S_OK
1569 * Failure: standard HRESULT error codes.
1570 *
1571 * NOTES
1572 * Most values can be overridden in either
1573 * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1574 * or in the same location in HKLM.
1575 * The registry usage is explained by the following tech note:
1576 * http://www.microsoft.com/windows2000/techinfo/reskit/en-us/default.asp?url=/windows2000/techinfo/reskit/en-us/regentry/36173.asp
1577 * The "Shell Folders" registry key was used in NT4 and earlier systems.
1578 * Beginning with Windows 2000, the "User Shell Folders" key is used, so
1579 * changes made to it are made to the former key too. This synchronization is
1580 * done on-demand: not until someone requests the value of one of these paths
1581 * (by calling one of the SHGet functions) is the value synchronized.
1582 * Furthermore, as explained here:
1583 * http://www.microsoft.com/windows2000/techinfo/reskit/en-us/default.asp?url=/windows2000/techinfo/reskit/en-us/regentry/36276.asp
1584 * the HKCU paths take precedence over the HKLM paths.
1585 *
1586 */
1587 HRESULT WINAPI SHGetFolderPathW(
1588 HWND hwndOwner, /* [I] owner window */
1589 int nFolder, /* [I] CSIDL identifying the folder */
1590 HANDLE hToken, /* [I] access token */
1591 DWORD dwFlags, /* [I] which path to return */
1592 LPWSTR pszPath) /* [O] converted path */
1593 {
1594 HRESULT hr;
1595 WCHAR szBuildPath[MAX_PATH], szTemp[MAX_PATH];
1596 DWORD folder = nFolder & CSIDL_FOLDER_MASK;
1597 CSIDL_Type type;
1598 int ret;
1599
1600 TRACE("%p,%p,nFolder=0x%04x\n", hwndOwner,pszPath,nFolder);
1601
1602 /* Windows always NULL-terminates the resulting path regardless of success
1603 * or failure, so do so first
1604 */
1605 if (pszPath)
1606 *pszPath = '\0';
1607 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1608 return E_INVALIDARG;
1609 szTemp[0] = 0;
1610 type = CSIDL_Data[folder].type;
1611 switch (type)
1612 {
1613 case CSIDL_Type_Disallowed:
1614 hr = E_INVALIDARG;
1615 break;
1616 case CSIDL_Type_NonExistent:
1617 hr = S_FALSE;
1618 break;
1619 case CSIDL_Type_WindowsPath:
1620 GetWindowsDirectoryW(szTemp, MAX_PATH);
1621 if (CSIDL_Data[folder].szDefaultPath &&
1622 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1623 *CSIDL_Data[folder].szDefaultPath)
1624 {
1625 PathAddBackslashW(szTemp);
1626 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
1627 }
1628 hr = S_OK;
1629 break;
1630 case CSIDL_Type_SystemPath:
1631 GetSystemDirectoryW(szTemp, MAX_PATH);
1632 if (CSIDL_Data[folder].szDefaultPath &&
1633 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1634 *CSIDL_Data[folder].szDefaultPath)
1635 {
1636 PathAddBackslashW(szTemp);
1637 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
1638 }
1639 hr = S_OK;
1640 break;
1641 case CSIDL_Type_CurrVer:
1642 hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
1643 break;
1644 case CSIDL_Type_User:
1645 hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
1646 break;
1647 case CSIDL_Type_AllUsers:
1648 hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
1649 break;
1650 default:
1651 FIXME("bogus type %d, please fix\n", type);
1652 hr = E_INVALIDARG;
1653 break;
1654 }
1655
1656 /* Expand environment strings if necessary */
1657 if (*szTemp == '%')
1658 hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
1659 else
1660 strcpyW(szBuildPath, szTemp);
1661 /* Copy the path if it's available before we might return */
1662 if (SUCCEEDED(hr) && pszPath)
1663 strcpyW(pszPath, szBuildPath);
1664
1665 if (FAILED(hr)) goto end;
1666
1667 /* if we don't care about existing directories we are ready */
1668 if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
1669
1670 if (PathFileExistsW(szBuildPath)) goto end;
1671
1672 /* not existing but we are not allowed to create it. The return value
1673 * is verified against shell32 version 6.0.
1674 */
1675 if (!(nFolder & CSIDL_FLAG_CREATE))
1676 {
1677 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1678 goto end;
1679 }
1680
1681 /* create directory/directories */
1682 ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
1683 if (ret && ret != ERROR_ALREADY_EXISTS)
1684 {
1685 ERR("Failed to create directory '%s'.\n", debugstr_w(szBuildPath));
1686 hr = E_FAIL;
1687 goto end;
1688 }
1689
1690 TRACE("Created missing system directory '%s'\n", debugstr_w(szBuildPath));
1691 end:
1692 TRACE("returning 0x%08lx (final path is %s)\n", hr, debugstr_w(szBuildPath));
1693 return hr;
1694 }
1695
1696 /*************************************************************************
1697 * SHGetFolderPathA [SHELL32.@]
1698 *
1699 * See SHGetFolderPathW.
1700 */
1701 HRESULT WINAPI SHGetFolderPathA(
1702 HWND hwndOwner,
1703 int nFolder,
1704 HANDLE hToken,
1705 DWORD dwFlags,
1706 LPSTR pszPath)
1707 {
1708 WCHAR szTemp[MAX_PATH];
1709 HRESULT hr;
1710
1711 TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
1712
1713 if (pszPath)
1714 *pszPath = '\0';
1715 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
1716 if (SUCCEEDED(hr) && pszPath)
1717 WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
1718 NULL);
1719
1720 return hr;
1721 }
1722
1723 /* For each folder in folders, if its value has not been set in the registry,
1724 * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
1725 * folder's type) to get the unexpanded value first.
1726 * Writes the unexpanded value to User Shell Folders, and queries it with
1727 * SHGetFolderPathW to force the creation of the directory if it doesn't
1728 * already exist. SHGetFolderPathW also returns the expanded value, which
1729 * this then writes to Shell Folders.
1730 */
1731 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
1732 LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
1733 UINT foldersLen)
1734 {
1735 UINT i;
1736 WCHAR path[MAX_PATH];
1737 HRESULT hr = S_OK;
1738 HKEY hUserKey = NULL, hKey = NULL;
1739 DWORD dwDisp, dwType, dwPathLen;
1740 LONG ret;
1741
1742 TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
1743 debugstr_w(szUserShellFolderPath), folders, foldersLen);
1744
1745 ret = RegCreateKeyExW(hRootKey, szUserShellFolderPath, 0, NULL, 0,
1746 KEY_ALL_ACCESS, NULL, &hUserKey, &dwDisp);
1747 if (ret)
1748 hr = HRESULT_FROM_WIN32(ret);
1749 else
1750 {
1751 ret = RegCreateKeyExW(hRootKey, szShellFolderPath, 0, NULL, 0,
1752 KEY_ALL_ACCESS, NULL, &hKey, &dwDisp);
1753 if (ret)
1754 hr = HRESULT_FROM_WIN32(ret);
1755 }
1756 for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
1757 {
1758 dwPathLen = MAX_PATH * sizeof(WCHAR);
1759 if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
1760 &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
1761 dwType != REG_EXPAND_SZ))
1762 {
1763 *path = '\0';
1764 if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
1765 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
1766 path);
1767 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
1768 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
1769 else
1770 hr = E_FAIL;
1771 if (*path)
1772 {
1773 ret = RegSetValueExW(hUserKey,
1774 CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
1775 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
1776 if (ret)
1777 hr = HRESULT_FROM_WIN32(ret);
1778 else
1779 {
1780 hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
1781 hToken, SHGFP_TYPE_DEFAULT, path);
1782 ret = RegSetValueExW(hKey,
1783 CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
1784 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
1785 if (ret)
1786 hr = HRESULT_FROM_WIN32(ret);
1787 }
1788 }
1789 }
1790 }
1791 if (hUserKey)
1792 RegCloseKey(hUserKey);
1793 if (hKey)
1794 RegCloseKey(hKey);
1795
1796 TRACE("returning 0x%08lx\n", hr);
1797 return hr;
1798 }
1799
1800 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
1801 {
1802 static const UINT folders[] = {
1803 CSIDL_PROGRAMS,
1804 CSIDL_PERSONAL,
1805 CSIDL_FAVORITES,
1806 CSIDL_APPDATA,
1807 CSIDL_STARTUP,
1808 CSIDL_RECENT,
1809 CSIDL_SENDTO,
1810 CSIDL_STARTMENU,
1811 CSIDL_MYMUSIC,
1812 CSIDL_MYVIDEO,
1813 CSIDL_DESKTOPDIRECTORY,
1814 CSIDL_NETHOOD,
1815 CSIDL_TEMPLATES,
1816 CSIDL_PRINTHOOD,
1817 CSIDL_COOKIES,
1818 CSIDL_HISTORY,
1819 CSIDL_MYPICTURES
1820 };
1821 WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
1822 LPCWSTR pUserShellFolderPath, pShellFolderPath;
1823 HRESULT hr = S_OK;
1824 HKEY hRootKey;
1825 HANDLE hToken;
1826
1827 TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
1828 if (bDefault)
1829 {
1830 hToken = (HANDLE)-1;
1831 hRootKey = HKEY_USERS;
1832 strcpyW(userShellFolderPath, DefaultW);
1833 PathAddBackslashW(userShellFolderPath);
1834 strcatW(userShellFolderPath, szSHUserFolders);
1835 pUserShellFolderPath = userShellFolderPath;
1836 strcpyW(shellFolderPath, DefaultW);
1837 PathAddBackslashW(shellFolderPath);
1838 strcatW(shellFolderPath, szSHFolders);
1839 pShellFolderPath = shellFolderPath;
1840 }
1841 else
1842 {
1843 hToken = NULL;
1844 hRootKey = HKEY_CURRENT_USER;
1845 pUserShellFolderPath = szSHUserFolders;
1846 pShellFolderPath = szSHFolders;
1847 }
1848
1849 hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
1850 pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
1851 TRACE("returning 0x%08lx\n", hr);
1852 return hr;
1853 }
1854
1855 static HRESULT _SHRegisterCommonShellFolders(void)
1856 {
1857 static const UINT folders[] = {
1858 CSIDL_COMMON_STARTMENU,
1859 CSIDL_COMMON_PROGRAMS,
1860 CSIDL_COMMON_STARTUP,
1861 CSIDL_COMMON_DESKTOPDIRECTORY,
1862 CSIDL_COMMON_FAVORITES,
1863 CSIDL_COMMON_APPDATA,
1864 CSIDL_COMMON_TEMPLATES,
1865 CSIDL_COMMON_DOCUMENTS,
1866 };
1867 HRESULT hr;
1868
1869 TRACE("\n");
1870 hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
1871 szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
1872 TRACE("returning 0x%08lx\n", hr);
1873 return hr;
1874 }
1875
1876 /* Register the default values in the registry, as some apps seem to depend
1877 * on their presence. The set registered was taken from Windows XP.
1878 */
1879 HRESULT SHELL_RegisterShellFolders(void)
1880 {
1881 HRESULT hr = _SHRegisterUserShellFolders(TRUE);
1882
1883 if (SUCCEEDED(hr))
1884 hr = _SHRegisterUserShellFolders(FALSE);
1885 if (SUCCEEDED(hr))
1886 hr = _SHRegisterCommonShellFolders();
1887 return hr;
1888 }
1889
1890 /*************************************************************************
1891 * SHGetSpecialFolderPathA [SHELL32.@]
1892 */
1893 BOOL WINAPI SHGetSpecialFolderPathA (
1894 HWND hwndOwner,
1895 LPSTR szPath,
1896 int nFolder,
1897 BOOL bCreate)
1898 {
1899 return (SHGetFolderPathA(
1900 hwndOwner,
1901 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1902 NULL,
1903 0,
1904 szPath)) == S_OK ? TRUE : FALSE;
1905 }
1906
1907 /*************************************************************************
1908 * SHGetSpecialFolderPathW
1909 */
1910 BOOL WINAPI SHGetSpecialFolderPathW (
1911 HWND hwndOwner,
1912 LPWSTR szPath,
1913 int nFolder,
1914 BOOL bCreate)
1915 {
1916 return (SHGetFolderPathW(
1917 hwndOwner,
1918 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1919 NULL,
1920 0,
1921 szPath)) == S_OK ? TRUE : FALSE;
1922 }
1923
1924 /*************************************************************************
1925 * SHGetSpecialFolderPath (SHELL32.175)
1926 */
1927 BOOL WINAPI SHGetSpecialFolderPathAW (
1928 HWND hwndOwner,
1929 LPVOID szPath,
1930 int nFolder,
1931 BOOL bCreate)
1932
1933 {
1934 if (SHELL_OsIsUnicode())
1935 return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate);
1936 return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate);
1937 }
1938
1939 /*************************************************************************
1940 * SHGetFolderLocation [SHELL32.@]
1941 *
1942 * Gets the folder locations from the registry and creates a pidl.
1943 *
1944 * PARAMS
1945 * hwndOwner [I]
1946 * nFolder [I] CSIDL_xxxxx
1947 * hToken [I] token representing user, or NULL for current user, or -1 for
1948 * default user
1949 * dwReserved [I] must be zero
1950 * ppidl [O] PIDL of a special folder
1951 *
1952 * RETURNS
1953 * Success: S_OK
1954 * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
1955 *
1956 * NOTES
1957 * Creates missing reg keys and directories.
1958 * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
1959 * virtual folders that are handled here.
1960 */
1961 HRESULT WINAPI SHGetFolderLocation(
1962 HWND hwndOwner,
1963 int nFolder,
1964 HANDLE hToken,
1965 DWORD dwReserved,
1966 LPITEMIDLIST *ppidl)
1967 {
1968 HRESULT hr = E_INVALIDARG;
1969
1970 TRACE("%p 0x%08x %p 0x%08lx %p\n",
1971 hwndOwner, nFolder, hToken, dwReserved, ppidl);
1972
1973 if (!ppidl)
1974 return E_INVALIDARG;
1975 if (dwReserved)
1976 return E_INVALIDARG;
1977
1978 /* The virtual folders' locations are not user-dependent */
1979 *ppidl = NULL;
1980 switch (nFolder)
1981 {
1982 case CSIDL_DESKTOP:
1983 *ppidl = _ILCreateDesktop();
1984 break;
1985
1986 case CSIDL_INTERNET:
1987 *ppidl = _ILCreateIExplore();
1988 break;
1989
1990 case CSIDL_CONTROLS:
1991 *ppidl = _ILCreateControlPanel();
1992 break;
1993
1994 case CSIDL_PRINTERS:
1995 *ppidl = _ILCreatePrinters();
1996 break;
1997
1998 case CSIDL_FONTS:
1999 FIXME("virtual font folder");
2000 break;
2001
2002 case CSIDL_BITBUCKET:
2003 *ppidl = _ILCreateBitBucket();
2004 break;
2005
2006 case CSIDL_DRIVES:
2007 *ppidl = _ILCreateMyComputer();
2008 break;
2009
2010 case CSIDL_NETWORK:
2011 *ppidl = _ILCreateNetwork();
2012 break;
2013
2014 default:
2015 {
2016 WCHAR szPath[MAX_PATH];
2017
2018 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
2019 SHGFP_TYPE_CURRENT, szPath);
2020 if (SUCCEEDED(hr))
2021 {
2022 DWORD attributes=0;
2023
2024 TRACE("Value=%s\n", debugstr_w(szPath));
2025 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
2026 }
2027 else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
2028 {
2029 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
2030 * version 6.0 returns E_FAIL for nonexistent paths
2031 */
2032 hr = E_FAIL;
2033 }
2034 }
2035 }
2036 if(*ppidl)
2037 hr = NOERROR;
2038
2039 TRACE("-- (new pidl %p)\n",*ppidl);
2040 return hr;
2041 }
2042
2043 /*************************************************************************
2044 * SHGetSpecialFolderLocation [SHELL32.@]
2045 *
2046 * NOTES
2047 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2048 * directory.
2049 */
2050 HRESULT WINAPI SHGetSpecialFolderLocation(
2051 HWND hwndOwner,
2052 INT nFolder,
2053 LPITEMIDLIST * ppidl)
2054 {
2055 HRESULT hr = E_INVALIDARG;
2056
2057 TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2058
2059 if (!ppidl)
2060 return E_INVALIDARG;
2061
2062 hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2063 return hr;
2064 }