projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
reshuffling of dlls
[reactos.git] / reactos / dll / win32 / 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 LONG 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 if(!lpszPath) return -1;
712 if(lpszBuff) strcpy(lpszBuff, lpszPath);
713 return strlen(lpszPath);
714 }
715
716 /*************************************************************************
717 * PathProcessCommandW
718 */
719 LONG WINAPI PathProcessCommandW (
720 LPCWSTR lpszPath,
721 LPWSTR lpszBuff,
722 DWORD dwBuffSize,
723 DWORD dwFlags)
724 {
725 FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n",
726 debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
727 if(!lpszPath) return -1;
728 if(lpszBuff) strcpyW(lpszBuff, lpszPath);
729 return strlenW(lpszPath);
730 }
731
732 /*************************************************************************
733 * PathProcessCommand (SHELL32.653)
734 */
735 LONG WINAPI PathProcessCommandAW (
736 LPCVOID lpszPath,
737 LPVOID lpszBuff,
738 DWORD dwBuffSize,
739 DWORD dwFlags)
740 {
741 if (SHELL_OsIsUnicode())
742 return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
743 return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
744 }
745
746 /*
747 ########## special ##########
748 */
749
750 /*************************************************************************
751 * PathSetDlgItemPath (SHELL32.48)
752 */
753 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
754 {
755 if (SHELL_OsIsUnicode())
756 PathSetDlgItemPathW(hDlg, id, pszPath);
757 else
758 PathSetDlgItemPathA(hDlg, id, pszPath);
759 }
760
761 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'};
762 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'};
763 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
764 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
765 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
766 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'};
767 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
768 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
769 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
770 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
771 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
772 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
773 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
774 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
775 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
776 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
777 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
778 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
779 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
780 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
781 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
782 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
783 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
784 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
785 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
786 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
787 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
788 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
789 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
790 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
791 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
792 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
793 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
794 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
795 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
796 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
797 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
798 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
799 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
800 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
801 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
802 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};
803 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
804 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
805 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'};
806 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'};
807 /* This defaults to L"Documents and Settings" on Windows 2000/XP, but we're
808 * acting more Windows 9x-like for now.
809 */
810 static const WCHAR szDefaultProfileDirW[] = {'p','r','o','f','i','l','e','s','\0'};
811 static const WCHAR AllUsersW[] = {'A','l','l',' ','U','s','e','r','s','\0'};
812
813 typedef enum _CSIDL_Type {
814 CSIDL_Type_User,
815 CSIDL_Type_AllUsers,
816 CSIDL_Type_CurrVer,
817 CSIDL_Type_Disallowed,
818 CSIDL_Type_NonExistent,
819 CSIDL_Type_WindowsPath,
820 CSIDL_Type_SystemPath,
821 } CSIDL_Type;
822
823 typedef struct
824 {
825 CSIDL_Type type;
826 LPCWSTR szValueName;
827 LPCWSTR szDefaultPath; /* fallback string or resource ID */
828 } CSIDL_DATA;
829
830 static const CSIDL_DATA CSIDL_Data[] =
831 {
832 { /* 0x00 - CSIDL_DESKTOP */
833 CSIDL_Type_User,
834 DesktopW,
835 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
836 },
837 { /* 0x01 - CSIDL_INTERNET */
838 CSIDL_Type_Disallowed,
839 NULL,
840 NULL
841 },
842 { /* 0x02 - CSIDL_PROGRAMS */
843 CSIDL_Type_User,
844 ProgramsW,
845 MAKEINTRESOURCEW(IDS_PROGRAMS)
846 },
847 { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
848 CSIDL_Type_SystemPath,
849 NULL,
850 NULL
851 },
852 { /* 0x04 - CSIDL_PRINTERS */
853 CSIDL_Type_SystemPath,
854 NULL,
855 NULL
856 },
857 { /* 0x05 - CSIDL_PERSONAL */
858 CSIDL_Type_User,
859 PersonalW,
860 MAKEINTRESOURCEW(IDS_PERSONAL)
861 },
862 { /* 0x06 - CSIDL_FAVORITES */
863 CSIDL_Type_User,
864 FavoritesW,
865 MAKEINTRESOURCEW(IDS_FAVORITES)
866 },
867 { /* 0x07 - CSIDL_STARTUP */
868 CSIDL_Type_User,
869 StartUpW,
870 MAKEINTRESOURCEW(IDS_STARTUP)
871 },
872 { /* 0x08 - CSIDL_RECENT */
873 CSIDL_Type_User,
874 RecentW,
875 MAKEINTRESOURCEW(IDS_RECENT)
876 },
877 { /* 0x09 - CSIDL_SENDTO */
878 CSIDL_Type_User,
879 SendToW,
880 MAKEINTRESOURCEW(IDS_SENDTO)
881 },
882 { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
883 CSIDL_Type_Disallowed,
884 NULL,
885 NULL,
886 },
887 { /* 0x0b - CSIDL_STARTMENU */
888 CSIDL_Type_User,
889 Start_MenuW,
890 MAKEINTRESOURCEW(IDS_STARTMENU)
891 },
892 { /* 0x0c - CSIDL_MYDOCUMENTS */
893 CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
894 NULL,
895 NULL
896 },
897 { /* 0x0d - CSIDL_MYMUSIC */
898 CSIDL_Type_User,
899 My_MusicW,
900 MAKEINTRESOURCEW(IDS_MYMUSIC)
901 },
902 { /* 0x0e - CSIDL_MYVIDEO */
903 CSIDL_Type_User,
904 My_VideoW,
905 MAKEINTRESOURCEW(IDS_MYVIDEO)
906 },
907 { /* 0x0f - unassigned */
908 CSIDL_Type_Disallowed,
909 NULL,
910 NULL,
911 },
912 { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
913 CSIDL_Type_User,
914 DesktopW,
915 MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
916 },
917 { /* 0x11 - CSIDL_DRIVES */
918 CSIDL_Type_Disallowed,
919 NULL,
920 NULL,
921 },
922 { /* 0x12 - CSIDL_NETWORK */
923 CSIDL_Type_Disallowed,
924 NULL,
925 NULL,
926 },
927 { /* 0x13 - CSIDL_NETHOOD */
928 CSIDL_Type_User,
929 NetHoodW,
930 MAKEINTRESOURCEW(IDS_NETHOOD)
931 },
932 { /* 0x14 - CSIDL_FONTS */
933 CSIDL_Type_WindowsPath,
934 NULL,
935 FontsW
936 },
937 { /* 0x15 - CSIDL_TEMPLATES */
938 CSIDL_Type_User,
939 TemplatesW,
940 MAKEINTRESOURCEW(IDS_TEMPLATES)
941 },
942 { /* 0x16 - CSIDL_COMMON_STARTMENU */
943 CSIDL_Type_AllUsers,
944 Common_Start_MenuW,
945 MAKEINTRESOURCEW(IDS_STARTMENU)
946 },
947 { /* 0x17 - CSIDL_COMMON_PROGRAMS */
948 CSIDL_Type_AllUsers,
949 Common_ProgramsW,
950 MAKEINTRESOURCEW(IDS_PROGRAMS)
951 },
952 { /* 0x18 - CSIDL_COMMON_STARTUP */
953 CSIDL_Type_AllUsers,
954 Common_StartUpW,
955 MAKEINTRESOURCEW(IDS_STARTUP)
956 },
957 { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
958 CSIDL_Type_AllUsers,
959 Common_DesktopW,
960 MAKEINTRESOURCEW(IDS_DESKTOP)
961 },
962 { /* 0x1a - CSIDL_APPDATA */
963 CSIDL_Type_User,
964 AppDataW,
965 MAKEINTRESOURCEW(IDS_APPDATA)
966 },
967 { /* 0x1b - CSIDL_PRINTHOOD */
968 CSIDL_Type_User,
969 PrintHoodW,
970 MAKEINTRESOURCEW(IDS_PRINTHOOD)
971 },
972 { /* 0x1c - CSIDL_LOCAL_APPDATA */
973 CSIDL_Type_User,
974 Local_AppDataW,
975 MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
976 },
977 { /* 0x1d - CSIDL_ALTSTARTUP */
978 CSIDL_Type_NonExistent,
979 NULL,
980 NULL
981 },
982 { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
983 CSIDL_Type_NonExistent,
984 NULL,
985 NULL
986 },
987 { /* 0x1f - CSIDL_COMMON_FAVORITES */
988 CSIDL_Type_AllUsers,
989 FavoritesW,
990 MAKEINTRESOURCEW(IDS_FAVORITES)
991 },
992 { /* 0x20 - CSIDL_INTERNET_CACHE */
993 CSIDL_Type_User,
994 CacheW,
995 MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
996 },
997 { /* 0x21 - CSIDL_COOKIES */
998 CSIDL_Type_User,
999 CookiesW,
1000 MAKEINTRESOURCEW(IDS_COOKIES)
1001 },
1002 { /* 0x22 - CSIDL_HISTORY */
1003 CSIDL_Type_User,
1004 HistoryW,
1005 MAKEINTRESOURCEW(IDS_HISTORY)
1006 },
1007 { /* 0x23 - CSIDL_COMMON_APPDATA */
1008 CSIDL_Type_AllUsers,
1009 Common_AppDataW,
1010 MAKEINTRESOURCEW(IDS_APPDATA)
1011 },
1012 { /* 0x24 - CSIDL_WINDOWS */
1013 CSIDL_Type_WindowsPath,
1014 NULL,
1015 NULL
1016 },
1017 { /* 0x25 - CSIDL_SYSTEM */
1018 CSIDL_Type_SystemPath,
1019 NULL,
1020 NULL
1021 },
1022 { /* 0x26 - CSIDL_PROGRAM_FILES */
1023 CSIDL_Type_CurrVer,
1024 ProgramFilesDirW,
1025 MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
1026 },
1027 { /* 0x27 - CSIDL_MYPICTURES */
1028 CSIDL_Type_User,
1029 My_PicturesW,
1030 MAKEINTRESOURCEW(IDS_MYPICTURES)
1031 },
1032 { /* 0x28 - CSIDL_PROFILE */
1033 CSIDL_Type_User,
1034 NULL,
1035 NULL
1036 },
1037 { /* 0x29 - CSIDL_SYSTEMX86 */
1038 CSIDL_Type_NonExistent,
1039 NULL,
1040 NULL
1041 },
1042 { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
1043 CSIDL_Type_NonExistent,
1044 NULL,
1045 NULL
1046 },
1047 { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
1048 CSIDL_Type_CurrVer,
1049 CommonFilesDirW,
1050 MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
1051 },
1052 { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
1053 CSIDL_Type_NonExistent,
1054 NULL,
1055 NULL
1056 },
1057 { /* 0x2d - CSIDL_COMMON_TEMPLATES */
1058 CSIDL_Type_AllUsers,
1059 Common_TemplatesW,
1060 MAKEINTRESOURCEW(IDS_TEMPLATES)
1061 },
1062 { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
1063 CSIDL_Type_AllUsers,
1064 Common_DocumentsW,
1065 MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
1066 },
1067 { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
1068 CSIDL_Type_AllUsers,
1069 Common_Administrative_ToolsW,
1070 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1071 },
1072 { /* 0x30 - CSIDL_ADMINTOOLS */
1073 CSIDL_Type_User,
1074 Administrative_ToolsW,
1075 MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1076 },
1077 { /* 0x31 - CSIDL_CONNECTIONS */
1078 CSIDL_Type_Disallowed,
1079 NULL,
1080 NULL
1081 },
1082 { /* 0x32 - unassigned */
1083 CSIDL_Type_Disallowed,
1084 NULL,
1085 NULL
1086 },
1087 { /* 0x33 - unassigned */
1088 CSIDL_Type_Disallowed,
1089 NULL,
1090 NULL
1091 },
1092 { /* 0x34 - unassigned */
1093 CSIDL_Type_Disallowed,
1094 NULL,
1095 NULL
1096 },
1097 { /* 0x35 - CSIDL_COMMON_MUSIC */
1098 CSIDL_Type_AllUsers,
1099 CommonMusicW,
1100 MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
1101 },
1102 { /* 0x36 - CSIDL_COMMON_PICTURES */
1103 CSIDL_Type_AllUsers,
1104 CommonPicturesW,
1105 MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
1106 },
1107 { /* 0x37 - CSIDL_COMMON_VIDEO */
1108 CSIDL_Type_AllUsers,
1109 CommonVideoW,
1110 MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
1111 },
1112 { /* 0x38 - CSIDL_RESOURCES */
1113 CSIDL_Type_WindowsPath,
1114 NULL,
1115 ResourcesW
1116 },
1117 { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
1118 CSIDL_Type_NonExistent,
1119 NULL,
1120 NULL
1121 },
1122 { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
1123 CSIDL_Type_NonExistent,
1124 NULL,
1125 NULL
1126 },
1127 { /* 0x3b - CSIDL_CDBURN_AREA */
1128 CSIDL_Type_User,
1129 CD_BurningW,
1130 MAKEINTRESOURCEW(IDS_CDBURN_AREA)
1131 },
1132 { /* 0x3c unassigned */
1133 CSIDL_Type_Disallowed,
1134 NULL,
1135 NULL
1136 },
1137 { /* 0x3d - CSIDL_COMPUTERSNEARME */
1138 CSIDL_Type_Disallowed, /* FIXME */
1139 NULL,
1140 NULL
1141 },
1142 { /* 0x3e - CSIDL_PROFILES */
1143 CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
1144 NULL,
1145 NULL
1146 }
1147 };
1148
1149 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest);
1150
1151 /* Gets the value named value from the registry key
1152 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1153 * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
1154 * is assumed to be MAX_PATH WCHARs in length.
1155 * If it exists, expands the value and writes the expanded value to
1156 * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
1157 * Returns successful error code if the value was retrieved from the registry,
1158 * and a failure otherwise.
1159 */
1160 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
1161 LPCWSTR value, LPWSTR path)
1162 {
1163 HRESULT hr;
1164 WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
1165 LPCWSTR pShellFolderPath, pUserShellFolderPath;
1166 DWORD dwDisp, dwType, dwPathLen = MAX_PATH;
1167 HKEY userShellFolderKey, shellFolderKey;
1168
1169 TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
1170 path);
1171
1172 if (userPrefix)
1173 {
1174 strcpyW(shellFolderPath, userPrefix);
1175 PathAddBackslashW(shellFolderPath);
1176 strcatW(shellFolderPath, szSHFolders);
1177 pShellFolderPath = shellFolderPath;
1178 strcpyW(userShellFolderPath, userPrefix);
1179 PathAddBackslashW(userShellFolderPath);
1180 strcatW(userShellFolderPath, szSHUserFolders);
1181 pUserShellFolderPath = userShellFolderPath;
1182 }
1183 else
1184 {
1185 pUserShellFolderPath = szSHUserFolders;
1186 pShellFolderPath = szSHFolders;
1187 }
1188
1189 if (RegCreateKeyExW(rootKey, pShellFolderPath, 0, NULL, 0, KEY_ALL_ACCESS,
1190 NULL, &shellFolderKey, &dwDisp))
1191 {
1192 TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
1193 return E_FAIL;
1194 }
1195 if (RegCreateKeyExW(rootKey, pUserShellFolderPath, 0, NULL, 0,
1196 KEY_ALL_ACCESS, NULL, &userShellFolderKey, &dwDisp))
1197 {
1198 TRACE("Failed to create %s\n",
1199 debugstr_w(pUserShellFolderPath));
1200 RegCloseKey(shellFolderKey);
1201 return E_FAIL;
1202 }
1203
1204 if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
1205 (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
1206 {
1207 LONG ret;
1208
1209 path[dwPathLen / sizeof(WCHAR)] = '\0';
1210 if (dwType == REG_EXPAND_SZ && path[0] == '%')
1211 {
1212 WCHAR szTemp[MAX_PATH];
1213
1214 _SHExpandEnvironmentStrings(path, szTemp);
1215 lstrcpynW(path, szTemp, MAX_PATH);
1216 }
1217 ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
1218 (strlenW(path) + 1) * sizeof(WCHAR));
1219 if (ret != ERROR_SUCCESS)
1220 hr = HRESULT_FROM_WIN32(ret);
1221 else
1222 hr = S_OK;
1223 }
1224 else
1225 hr = E_FAIL;
1226 RegCloseKey(shellFolderKey);
1227 RegCloseKey(userShellFolderKey);
1228 TRACE("returning 0x%08lx\n", hr);
1229 return hr;
1230 }
1231
1232 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
1233 * pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
1234 * - The entry's szDefaultPath may be either a string value or an integer
1235 * resource identifier. In the latter case, the string value of the resource
1236 * is written.
1237 * - Depending on the entry's type, the path may begin with an (unexpanded)
1238 * environment variable name. The caller is responsible for expanding
1239 * environment strings if so desired.
1240 * The types that are prepended with environment variables are:
1241 * CSIDL_Type_User: %USERPROFILE%
1242 * CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1243 * CSIDL_Type_CurrVer: %SystemDrive%
1244 * (Others might make sense too, but as yet are unneeded.)
1245 */
1246 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1247 {
1248 HRESULT hr;
1249 WCHAR resourcePath[MAX_PATH];
1250 LPCWSTR pDefaultPath = NULL;
1251
1252 TRACE("0x%02x,%p\n", folder, pszPath);
1253
1254 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1255 return E_INVALIDARG;
1256 if (!pszPath)
1257 return E_INVALIDARG;
1258
1259 /* Try special cases first */
1260 hr = E_FAIL;
1261 switch (folder)
1262 {
1263 case CSIDL_PERSONAL:
1264 case CSIDL_MYMUSIC:
1265 case CSIDL_MYPICTURES:
1266 case CSIDL_MYVIDEO:
1267 {
1268 const char *home = getenv("HOME");
1269
1270 /* special case for "My Documents", map to $HOME */
1271 if (home)
1272 {
1273 WCHAR homeW[MAX_PATH];
1274
1275 MultiByteToWideChar(CP_ACP, 0, home, -1, homeW, MAX_PATH);
1276 if (GetFullPathNameW(homeW, MAX_PATH, pszPath, NULL) != 0 &&
1277 PathIsDirectoryW(pszPath))
1278 hr = S_OK;
1279 }
1280 break;
1281 }
1282 case CSIDL_DESKTOP:
1283 case CSIDL_DESKTOPDIRECTORY:
1284 {
1285 const char *home = getenv("HOME");
1286
1287 /* special case for Desktop, map to $HOME/Desktop if it exists */
1288 if (home)
1289 {
1290 WCHAR desktopW[MAX_PATH];
1291
1292 MultiByteToWideChar(CP_ACP, 0, home, -1, desktopW, MAX_PATH);
1293 PathAppendW(desktopW, DesktopW);
1294 if (GetFullPathNameW(desktopW, MAX_PATH, pszPath, NULL) != 0 &&
1295 PathIsDirectoryW(pszPath))
1296 hr = S_OK;
1297 }
1298 break;
1299 }
1300 }
1301 if (SUCCEEDED(hr))
1302 return hr;
1303
1304 /* Either the folder was unhandled, or a suitable default wasn't found,
1305 * so use one of the resource-based defaults
1306 */
1307 if (CSIDL_Data[folder].szDefaultPath &&
1308 IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1309 {
1310 if (LoadStringW(shell32_hInstance,
1311 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1312 {
1313 hr = S_OK;
1314 pDefaultPath = resourcePath;
1315 }
1316 else
1317 {
1318 FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1319 debugstr_w(pszPath));
1320 hr = E_FAIL;
1321 }
1322 }
1323 else
1324 {
1325 hr = S_OK;
1326 pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1327 }
1328 if (SUCCEEDED(hr))
1329 {
1330 switch (CSIDL_Data[folder].type)
1331 {
1332 case CSIDL_Type_User:
1333 strcpyW(pszPath, UserProfileW);
1334 break;
1335 case CSIDL_Type_AllUsers:
1336 strcpyW(pszPath, AllUsersProfileW);
1337 break;
1338 case CSIDL_Type_CurrVer:
1339 strcpyW(pszPath, SystemDriveW);
1340 break;
1341 default:
1342 ; /* no corresponding env. var, do nothing */
1343 }
1344 if (pDefaultPath)
1345 {
1346 PathAddBackslashW(pszPath);
1347 strcatW(pszPath, pDefaultPath);
1348 }
1349 }
1350 TRACE("returning 0x%08lx\n", hr);
1351 return hr;
1352 }
1353
1354 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1355 * The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
1356 * can be overridden in the HKLM\\szCurrentVersion key.
1357 * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1358 * the registry, uses _SHGetDefaultValue to get the value.
1359 */
1360 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1361 LPWSTR pszPath)
1362 {
1363 HRESULT hr;
1364
1365 TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath);
1366
1367 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1368 return E_INVALIDARG;
1369 if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1370 return E_INVALIDARG;
1371 if (!pszPath)
1372 return E_INVALIDARG;
1373
1374 if (dwFlags & SHGFP_TYPE_DEFAULT)
1375 hr = _SHGetDefaultValue(folder, pszPath);
1376 else
1377 {
1378 HKEY hKey;
1379 DWORD dwDisp;
1380
1381 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szCurrentVersion, 0,
1382 NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp))
1383 hr = E_FAIL;
1384 else
1385 {
1386 DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1387
1388 if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1389 &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1390 (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1391 {
1392 hr = _SHGetDefaultValue(folder, pszPath);
1393 dwType = REG_EXPAND_SZ;
1394 RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1395 (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
1396 }
1397 else
1398 {
1399 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1400 hr = S_OK;
1401 }
1402 RegCloseKey(hKey);
1403 }
1404 }
1405 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1406 return hr;
1407 }
1408
1409 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1410 * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
1411 * calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
1412 * - if hToken is -1, looks in HKEY_USERS\.Default
1413 * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1414 * if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
1415 * calls _SHGetDefaultValue for it.
1416 */
1417 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1418 LPWSTR pszPath)
1419 {
1420 HRESULT hr;
1421
1422 TRACE("%p,0x%08lx,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1423
1424 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1425 return E_INVALIDARG;
1426 if (CSIDL_Data[folder].type != CSIDL_Type_User)
1427 return E_INVALIDARG;
1428 if (!pszPath)
1429 return E_INVALIDARG;
1430
1431 /* Only the current user and the default user are supported right now
1432 * I'm afraid.
1433 * FIXME: should be able to call GetTokenInformation on the token,
1434 * then call ConvertSidToStringSidW on it to get the user prefix.
1435 * But Wine's registry doesn't store user info by sid, it stores it
1436 * by user name (and I don't know how to convert from a token to a
1437 * user name).
1438 */
1439 if (hToken != NULL && hToken != (HANDLE)-1)
1440 {
1441 FIXME("unsupported for user other than current or default\n");
1442 return E_FAIL;
1443 }
1444
1445 if (dwFlags & SHGFP_TYPE_DEFAULT)
1446 hr = _SHGetDefaultValue(folder, pszPath);
1447 else
1448 {
1449 LPCWSTR userPrefix = NULL;
1450 HKEY hRootKey;
1451
1452 if (hToken == (HANDLE)-1)
1453 {
1454 hRootKey = HKEY_USERS;
1455 userPrefix = DefaultW;
1456 }
1457 else /* hToken == NULL, other values disallowed above */
1458 hRootKey = HKEY_CURRENT_USER;
1459 hr = _SHGetUserShellFolderPath(hRootKey, userPrefix,
1460 CSIDL_Data[folder].szValueName, pszPath);
1461 if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1462 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1463 CSIDL_Data[folder].szValueName, pszPath);
1464 if (FAILED(hr))
1465 hr = _SHGetDefaultValue(folder, pszPath);
1466 }
1467 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1468 return hr;
1469 }
1470
1471 /* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
1472 * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
1473 * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1474 * If this fails, falls back to _SHGetDefaultValue.
1475 */
1476 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1477 LPWSTR pszPath)
1478 {
1479 HRESULT hr;
1480
1481 TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath);
1482
1483 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1484 return E_INVALIDARG;
1485 if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1486 return E_INVALIDARG;
1487 if (!pszPath)
1488 return E_INVALIDARG;
1489
1490 if (dwFlags & SHGFP_TYPE_DEFAULT)
1491 hr = _SHGetDefaultValue(folder, pszPath);
1492 else
1493 {
1494 hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1495 CSIDL_Data[folder].szValueName, pszPath);
1496 if (FAILED(hr))
1497 hr = _SHGetDefaultValue(folder, pszPath);
1498 }
1499 TRACE("returning 0x%08lx (output path is %s)\n", hr, debugstr_w(pszPath));
1500 return hr;
1501 }
1502
1503 /* From the original Wine source:
1504 *
1505 * Attempts to expand environment variables from szSrc into szDest, which is
1506 * assumed to be MAX_PATH characters in length. Before referring to the
1507 * environment, handles a few variables directly, because the environment
1508 * variables may not be set when this is called (as during Wine's installation
1509 * when default values are being written to the registry).
1510 * The directly handled environment variables, and their source, are:
1511 * - ALLUSERSPROFILE, USERPROFILE: reads from the registry
1512 * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
1513 * path
1514 * If one of the directly handled environment variables is expanded, only
1515 * expands a single variable, and only in the beginning of szSrc.
1516 *
1517 * That's fine for Wine, but it breaks in ReactOS where we have profile paths
1518 * like "c:\documents and settings\Administrator.REACTOS". Anyway, we have the
1519 * environment variables handy so we'll just use them instead of hacking around
1520 */
1521 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest)
1522 {
1523 HRESULT hr = S_OK;
1524 WCHAR szTemp[MAX_PATH];
1525
1526 TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
1527
1528 if (!szSrc || !szDest) return E_INVALIDARG;
1529
1530 /* short-circuit if there's nothing to expand */
1531 if (szSrc[0] != '%')
1532 {
1533 strcpyW(szDest, szSrc);
1534 hr = S_OK;
1535 goto end;
1536 }
1537
1538 *szDest = 0;
1539 strcpyW(szTemp, szSrc);
1540 while (SUCCEEDED(hr) && szTemp[0] == '%')
1541 {
1542 DWORD ret = ExpandEnvironmentStringsW(szSrc, szDest, MAX_PATH);
1543
1544 if (ret > MAX_PATH)
1545 hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
1546 else if (ret == 0)
1547 hr = HRESULT_FROM_WIN32(GetLastError());
1548 else
1549 hr = S_OK;
1550 if (SUCCEEDED(hr) && szDest[0] == '%')
1551 strcpyW(szTemp, szDest);
1552 else
1553 {
1554 /* terminate loop */
1555 szTemp[0] = '\0';
1556 }
1557 }
1558 end:
1559 TRACE("returning 0x%08lx (input was %s, output is %s)\n", hr,
1560 debugstr_w(szSrc), debugstr_w(szDest));
1561 return hr;
1562 }
1563
1564 /*************************************************************************
1565 * SHGetFolderPathW [SHELL32.@]
1566 *
1567 * Convert nFolder to path.
1568 *
1569 * RETURNS
1570 * Success: S_OK
1571 * Failure: standard HRESULT error codes.
1572 *
1573 * NOTES
1574 * Most values can be overridden in either
1575 * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1576 * or in the same location in HKLM.
1577 * The registry usage is explained by the following tech note:
1578 * http://www.microsoft.com/windows2000/techinfo/reskit/en-us/default.asp?url=/windows2000/techinfo/reskit/en-us/regentry/36173.asp
1579 * The "Shell Folders" registry key was used in NT4 and earlier systems.
1580 * Beginning with Windows 2000, the "User Shell Folders" key is used, so
1581 * changes made to it are made to the former key too. This synchronization is
1582 * done on-demand: not until someone requests the value of one of these paths
1583 * (by calling one of the SHGet functions) is the value synchronized.
1584 * Furthermore, as explained here:
1585 * http://www.microsoft.com/windows2000/techinfo/reskit/en-us/default.asp?url=/windows2000/techinfo/reskit/en-us/regentry/36276.asp
1586 * the HKCU paths take precedence over the HKLM paths.
1587 *
1588 */
1589 HRESULT WINAPI SHGetFolderPathW(
1590 HWND hwndOwner, /* [I] owner window */
1591 int nFolder, /* [I] CSIDL identifying the folder */
1592 HANDLE hToken, /* [I] access token */
1593 DWORD dwFlags, /* [I] which path to return */
1594 LPWSTR pszPath) /* [O] converted path */
1595 {
1596 HRESULT hr;
1597 WCHAR szBuildPath[MAX_PATH], szTemp[MAX_PATH];
1598 DWORD folder = nFolder & CSIDL_FOLDER_MASK;
1599 CSIDL_Type type;
1600 int ret;
1601
1602 TRACE("%p,%p,nFolder=0x%04x\n", hwndOwner,pszPath,nFolder);
1603
1604 /* Windows always NULL-terminates the resulting path regardless of success
1605 * or failure, so do so first
1606 */
1607 if (pszPath)
1608 *pszPath = '\0';
1609 if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1610 return E_INVALIDARG;
1611 szTemp[0] = 0;
1612 type = CSIDL_Data[folder].type;
1613 switch (type)
1614 {
1615 case CSIDL_Type_Disallowed:
1616 hr = E_INVALIDARG;
1617 break;
1618 case CSIDL_Type_NonExistent:
1619 hr = S_FALSE;
1620 break;
1621 case CSIDL_Type_WindowsPath:
1622 GetWindowsDirectoryW(szTemp, MAX_PATH);
1623 if (CSIDL_Data[folder].szDefaultPath &&
1624 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1625 *CSIDL_Data[folder].szDefaultPath)
1626 {
1627 PathAddBackslashW(szTemp);
1628 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
1629 }
1630 hr = S_OK;
1631 break;
1632 case CSIDL_Type_SystemPath:
1633 GetSystemDirectoryW(szTemp, MAX_PATH);
1634 if (CSIDL_Data[folder].szDefaultPath &&
1635 !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1636 *CSIDL_Data[folder].szDefaultPath)
1637 {
1638 PathAddBackslashW(szTemp);
1639 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
1640 }
1641 hr = S_OK;
1642 break;
1643 case CSIDL_Type_CurrVer:
1644 hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
1645 break;
1646 case CSIDL_Type_User:
1647 hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
1648 break;
1649 case CSIDL_Type_AllUsers:
1650 hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
1651 break;
1652 default:
1653 FIXME("bogus type %d, please fix\n", type);
1654 hr = E_INVALIDARG;
1655 break;
1656 }
1657
1658 /* Expand environment strings if necessary */
1659 if (*szTemp == '%')
1660 hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
1661 else
1662 strcpyW(szBuildPath, szTemp);
1663 /* Copy the path if it's available before we might return */
1664 if (SUCCEEDED(hr) && pszPath)
1665 strcpyW(pszPath, szBuildPath);
1666
1667 if (FAILED(hr)) goto end;
1668
1669 /* if we don't care about existing directories we are ready */
1670 if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
1671
1672 if (PathFileExistsW(szBuildPath)) goto end;
1673
1674 /* not existing but we are not allowed to create it. The return value
1675 * is verified against shell32 version 6.0.
1676 */
1677 if (!(nFolder & CSIDL_FLAG_CREATE))
1678 {
1679 hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1680 goto end;
1681 }
1682
1683 /* create directory/directories */
1684 ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
1685 if (ret && ret != ERROR_ALREADY_EXISTS)
1686 {
1687 ERR("Failed to create directory '%s'.\n", debugstr_w(szBuildPath));
1688 hr = E_FAIL;
1689 goto end;
1690 }
1691
1692 TRACE("Created missing system directory '%s'\n", debugstr_w(szBuildPath));
1693 end:
1694 TRACE("returning 0x%08lx (final path is %s)\n", hr, debugstr_w(szBuildPath));
1695 return hr;
1696 }
1697
1698 /*************************************************************************
1699 * SHGetFolderPathA [SHELL32.@]
1700 *
1701 * See SHGetFolderPathW.
1702 */
1703 HRESULT WINAPI SHGetFolderPathA(
1704 HWND hwndOwner,
1705 int nFolder,
1706 HANDLE hToken,
1707 DWORD dwFlags,
1708 LPSTR pszPath)
1709 {
1710 WCHAR szTemp[MAX_PATH];
1711 HRESULT hr;
1712
1713 TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
1714
1715 if (pszPath)
1716 *pszPath = '\0';
1717 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
1718 if (SUCCEEDED(hr) && pszPath)
1719 WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
1720 NULL);
1721
1722 return hr;
1723 }
1724
1725 /* For each folder in folders, if its value has not been set in the registry,
1726 * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
1727 * folder's type) to get the unexpanded value first.
1728 * Writes the unexpanded value to User Shell Folders, and queries it with
1729 * SHGetFolderPathW to force the creation of the directory if it doesn't
1730 * already exist. SHGetFolderPathW also returns the expanded value, which
1731 * this then writes to Shell Folders.
1732 */
1733 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
1734 LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
1735 UINT foldersLen)
1736 {
1737 UINT i;
1738 WCHAR path[MAX_PATH];
1739 HRESULT hr = S_OK;
1740 HKEY hUserKey = NULL, hKey = NULL;
1741 DWORD dwDisp, dwType, dwPathLen;
1742 LONG ret;
1743
1744 TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
1745 debugstr_w(szUserShellFolderPath), folders, foldersLen);
1746
1747 ret = RegCreateKeyExW(hRootKey, szUserShellFolderPath, 0, NULL, 0,
1748 KEY_ALL_ACCESS, NULL, &hUserKey, &dwDisp);
1749 if (ret)
1750 hr = HRESULT_FROM_WIN32(ret);
1751 else
1752 {
1753 ret = RegCreateKeyExW(hRootKey, szShellFolderPath, 0, NULL, 0,
1754 KEY_ALL_ACCESS, NULL, &hKey, &dwDisp);
1755 if (ret)
1756 hr = HRESULT_FROM_WIN32(ret);
1757 }
1758 for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
1759 {
1760 dwPathLen = MAX_PATH * sizeof(WCHAR);
1761 if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
1762 &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
1763 dwType != REG_EXPAND_SZ))
1764 {
1765 *path = '\0';
1766 if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
1767 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
1768 path);
1769 else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
1770 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
1771 else
1772 hr = E_FAIL;
1773 if (*path)
1774 {
1775 ret = RegSetValueExW(hUserKey,
1776 CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
1777 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
1778 if (ret)
1779 hr = HRESULT_FROM_WIN32(ret);
1780 else
1781 {
1782 hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
1783 hToken, SHGFP_TYPE_DEFAULT, path);
1784 ret = RegSetValueExW(hKey,
1785 CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
1786 (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
1787 if (ret)
1788 hr = HRESULT_FROM_WIN32(ret);
1789 }
1790 }
1791 }
1792 }
1793 if (hUserKey)
1794 RegCloseKey(hUserKey);
1795 if (hKey)
1796 RegCloseKey(hKey);
1797
1798 TRACE("returning 0x%08lx\n", hr);
1799 return hr;
1800 }
1801
1802 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
1803 {
1804 static const UINT folders[] = {
1805 CSIDL_PROGRAMS,
1806 CSIDL_PERSONAL,
1807 CSIDL_FAVORITES,
1808 CSIDL_APPDATA,
1809 CSIDL_STARTUP,
1810 CSIDL_RECENT,
1811 CSIDL_SENDTO,
1812 CSIDL_STARTMENU,
1813 CSIDL_MYMUSIC,
1814 CSIDL_MYVIDEO,
1815 CSIDL_DESKTOPDIRECTORY,
1816 CSIDL_NETHOOD,
1817 CSIDL_TEMPLATES,
1818 CSIDL_PRINTHOOD,
1819 CSIDL_LOCAL_APPDATA,
1820 CSIDL_INTERNET_CACHE,
1821 CSIDL_COOKIES,
1822 CSIDL_HISTORY,
1823 CSIDL_MYPICTURES
1824 };
1825 WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
1826 LPCWSTR pUserShellFolderPath, pShellFolderPath;
1827 HRESULT hr = S_OK;
1828 HKEY hRootKey;
1829 HANDLE hToken;
1830
1831 TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
1832 if (bDefault)
1833 {
1834 hToken = (HANDLE)-1;
1835 hRootKey = HKEY_USERS;
1836 strcpyW(userShellFolderPath, DefaultW);
1837 PathAddBackslashW(userShellFolderPath);
1838 strcatW(userShellFolderPath, szSHUserFolders);
1839 pUserShellFolderPath = userShellFolderPath;
1840 strcpyW(shellFolderPath, DefaultW);
1841 PathAddBackslashW(shellFolderPath);
1842 strcatW(shellFolderPath, szSHFolders);
1843 pShellFolderPath = shellFolderPath;
1844 }
1845 else
1846 {
1847 hToken = NULL;
1848 hRootKey = HKEY_CURRENT_USER;
1849 pUserShellFolderPath = szSHUserFolders;
1850 pShellFolderPath = szSHFolders;
1851 }
1852
1853 hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
1854 pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
1855 TRACE("returning 0x%08lx\n", hr);
1856 return hr;
1857 }
1858
1859 static HRESULT _SHRegisterCommonShellFolders(void)
1860 {
1861 static const UINT folders[] = {
1862 CSIDL_COMMON_STARTMENU,
1863 CSIDL_COMMON_PROGRAMS,
1864 CSIDL_COMMON_STARTUP,
1865 CSIDL_COMMON_DESKTOPDIRECTORY,
1866 CSIDL_COMMON_FAVORITES,
1867 CSIDL_COMMON_APPDATA,
1868 CSIDL_COMMON_TEMPLATES,
1869 CSIDL_COMMON_DOCUMENTS,
1870 };
1871 HRESULT hr;
1872
1873 TRACE("\n");
1874 hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
1875 szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
1876 TRACE("returning 0x%08lx\n", hr);
1877 return hr;
1878 }
1879
1880 /* Register the default values in the registry, as some apps seem to depend
1881 * on their presence. The set registered was taken from Windows XP.
1882 */
1883 HRESULT SHELL_RegisterShellFolders(void)
1884 {
1885 HRESULT hr = _SHRegisterUserShellFolders(TRUE);
1886
1887 if (SUCCEEDED(hr))
1888 hr = _SHRegisterUserShellFolders(FALSE);
1889 if (SUCCEEDED(hr))
1890 hr = _SHRegisterCommonShellFolders();
1891 return hr;
1892 }
1893
1894 /*************************************************************************
1895 * SHGetSpecialFolderPathA [SHELL32.@]
1896 */
1897 BOOL WINAPI SHGetSpecialFolderPathA (
1898 HWND hwndOwner,
1899 LPSTR szPath,
1900 int nFolder,
1901 BOOL bCreate)
1902 {
1903 return (SHGetFolderPathA(
1904 hwndOwner,
1905 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1906 NULL,
1907 0,
1908 szPath)) == S_OK ? TRUE : FALSE;
1909 }
1910
1911 /*************************************************************************
1912 * SHGetSpecialFolderPathW
1913 */
1914 BOOL WINAPI SHGetSpecialFolderPathW (
1915 HWND hwndOwner,
1916 LPWSTR szPath,
1917 int nFolder,
1918 BOOL bCreate)
1919 {
1920 return (SHGetFolderPathW(
1921 hwndOwner,
1922 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1923 NULL,
1924 0,
1925 szPath)) == S_OK ? TRUE : FALSE;
1926 }
1927
1928 /*************************************************************************
1929 * SHGetSpecialFolderPath (SHELL32.175)
1930 */
1931 BOOL WINAPI SHGetSpecialFolderPathAW (
1932 HWND hwndOwner,
1933 LPVOID szPath,
1934 int nFolder,
1935 BOOL bCreate)
1936
1937 {
1938 if (SHELL_OsIsUnicode())
1939 return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate);
1940 return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate);
1941 }
1942
1943 /*************************************************************************
1944 * SHGetFolderLocation [SHELL32.@]
1945 *
1946 * Gets the folder locations from the registry and creates a pidl.
1947 *
1948 * PARAMS
1949 * hwndOwner [I]
1950 * nFolder [I] CSIDL_xxxxx
1951 * hToken [I] token representing user, or NULL for current user, or -1 for
1952 * default user
1953 * dwReserved [I] must be zero
1954 * ppidl [O] PIDL of a special folder
1955 *
1956 * RETURNS
1957 * Success: S_OK
1958 * Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
1959 *
1960 * NOTES
1961 * Creates missing reg keys and directories.
1962 * Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
1963 * virtual folders that are handled here.
1964 */
1965 HRESULT WINAPI SHGetFolderLocation(
1966 HWND hwndOwner,
1967 int nFolder,
1968 HANDLE hToken,
1969 DWORD dwReserved,
1970 LPITEMIDLIST *ppidl)
1971 {
1972 HRESULT hr = E_INVALIDARG;
1973
1974 TRACE("%p 0x%08x %p 0x%08lx %p\n",
1975 hwndOwner, nFolder, hToken, dwReserved, ppidl);
1976
1977 if (!ppidl)
1978 return E_INVALIDARG;
1979 if (dwReserved)
1980 return E_INVALIDARG;
1981
1982 /* The virtual folders' locations are not user-dependent */
1983 *ppidl = NULL;
1984 switch (nFolder)
1985 {
1986 case CSIDL_DESKTOP:
1987 *ppidl = _ILCreateDesktop();
1988 break;
1989
1990 case CSIDL_INTERNET:
1991 *ppidl = _ILCreateIExplore();
1992 break;
1993
1994 case CSIDL_CONTROLS:
1995 *ppidl = _ILCreateControlPanel();
1996 break;
1997
1998 case CSIDL_PRINTERS:
1999 *ppidl = _ILCreatePrinters();
2000 break;
2001
2002 case CSIDL_FONTS:
2003 FIXME("virtual font folder");
2004 break;
2005
2006 case CSIDL_BITBUCKET:
2007 *ppidl = _ILCreateBitBucket();
2008 break;
2009
2010 case CSIDL_DRIVES:
2011 *ppidl = _ILCreateMyComputer();
2012 break;
2013
2014 case CSIDL_NETWORK:
2015 *ppidl = _ILCreateNetwork();
2016 break;
2017
2018 default:
2019 {
2020 WCHAR szPath[MAX_PATH];
2021
2022 hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
2023 SHGFP_TYPE_CURRENT, szPath);
2024 if (SUCCEEDED(hr))
2025 {
2026 DWORD attributes=0;
2027
2028 TRACE("Value=%s\n", debugstr_w(szPath));
2029 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
2030 }
2031 else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
2032 {
2033 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
2034 * version 6.0 returns E_FAIL for nonexistent paths
2035 */
2036 hr = E_FAIL;
2037 }
2038 }
2039 }
2040 if(*ppidl)
2041 hr = NOERROR;
2042
2043 TRACE("-- (new pidl %p)\n",*ppidl);
2044 return hr;
2045 }
2046
2047 /*************************************************************************
2048 * SHGetSpecialFolderLocation [SHELL32.@]
2049 *
2050 * NOTES
2051 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2052 * directory.
2053 */
2054 HRESULT WINAPI SHGetSpecialFolderLocation(
2055 HWND hwndOwner,
2056 INT nFolder,
2057 LPITEMIDLIST * ppidl)
2058 {
2059 HRESULT hr = E_INVALIDARG;
2060
2061 TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2062
2063 if (!ppidl)
2064 return E_INVALIDARG;
2065
2066 hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2067 return hr;
2068 }
A free Windows-compatible Operating System