git.oblomov.eu Git - wine/blob - dlls/shell32/shellpath.c

   1 /*
   2  * Path Functions
   3  *
   4  * Copyright 1998, 1999, 2000 Juergen Schmied
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES:
  21  *
  22  * Many of these functions are in SHLWAPI.DLL also
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include "wine/debug.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winnls.h"
  36 #include "winreg.h"
  37 #include "wingdi.h"
  38 #include "winuser.h"
  39
  40 #include "shlobj.h"
  41 #include "shell32_main.h"
  42 #include "undocshell.h"
  43 #include "pidl.h"
  44 #include "wine/unicode.h"
  45 #include "shlwapi.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  48
  49 /*
  50         ########## Combining and Constructing paths ##########
  51 */
  52
  53 /*************************************************************************
  54  * PathAppend           [SHELL32.36]
  55  */
  56 BOOL WINAPI PathAppendAW(
  57         LPVOID lpszPath1,
  58         LPCVOID lpszPath2)
  59 {
  60         if (SHELL_OsIsUnicode())
  61           return PathAppendW(lpszPath1, lpszPath2);
  62         return PathAppendA(lpszPath1, lpszPath2);
  63 }
  64
  65 /*************************************************************************
  66  * PathCombine   [SHELL32.37]
  67  */
  68 LPVOID WINAPI PathCombineAW(
  69         LPVOID szDest,
  70         LPCVOID lpszDir,
  71         LPCVOID lpszFile)
  72 {
  73         if (SHELL_OsIsUnicode())
  74           return PathCombineW( szDest, lpszDir, lpszFile );
  75         return PathCombineA( szDest, lpszDir, lpszFile );
  76 }
  77
  78 /*************************************************************************
  79  * PathAddBackslash             [SHELL32.32]
  80  */
  81 LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
  82 {
  83         if(SHELL_OsIsUnicode())
  84           return PathAddBackslashW(lpszPath);
  85         return PathAddBackslashA(lpszPath);
  86 }
  87
  88 /*************************************************************************
  89  * PathBuildRoot                [SHELL32.30]
  90  */
  91 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
  92 {
  93         if(SHELL_OsIsUnicode())
  94           return PathBuildRootW(lpszPath, drive);
  95         return PathBuildRootA(lpszPath, drive);
  96 }
  97
  98 /*
  99         Extracting Component Parts
 100 */
 101
 102 /*************************************************************************
 103  * PathFindFileName     [SHELL32.34]
 104  */
 105 LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
 106 {
 107         if(SHELL_OsIsUnicode())
 108           return PathFindFileNameW(lpszPath);
 109         return PathFindFileNameA(lpszPath);
 110 }
 111
 112 /*************************************************************************
 113  * PathFindExtension            [SHELL32.31]
 114  */
 115 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
 116 {
 117         if (SHELL_OsIsUnicode())
 118           return PathFindExtensionW(lpszPath);
 119         return PathFindExtensionA(lpszPath);
 120
 121 }
 122
 123 /*************************************************************************
 124  * PathGetExtensionA            [internal]
 125  *
 126  * NOTES
 127  *  exported by ordinal
 128  *  return value points to the first char after the dot
 129  */
 130 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
 131 {
 132         TRACE("(%s)\n",lpszPath);
 133
 134         lpszPath = PathFindExtensionA(lpszPath);
 135         return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
 136 }
 137
 138 /*************************************************************************
 139  * PathGetExtensionW            [internal]
 140  */
 141 static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
 142 {
 143         TRACE("(%s)\n",debugstr_w(lpszPath));
 144
 145         lpszPath = PathFindExtensionW(lpszPath);
 146         return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
 147 }
 148
 149 /*************************************************************************
 150  * PathGetExtension             [SHELL32.158]
 151  */
 152 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,DWORD void1, DWORD void2)
 153 {
 154         if (SHELL_OsIsUnicode())
 155           return PathGetExtensionW(lpszPath);
 156         return PathGetExtensionA(lpszPath);
 157 }
 158
 159 /*************************************************************************
 160  * PathGetArgs  [SHELL32.52]
 161  */
 162 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath)
 163 {
 164         if (SHELL_OsIsUnicode())
 165           return PathGetArgsW(lpszPath);
 166         return PathGetArgsA(lpszPath);
 167 }
 168
 169 /*************************************************************************
 170  * PathGetDriveNumber   [SHELL32.57]
 171  */
 172 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
 173 {
 174         if (SHELL_OsIsUnicode())
 175           return PathGetDriveNumberW(lpszPath);
 176         return PathGetDriveNumberA(lpszPath);
 177 }
 178
 179 /*************************************************************************
 180  * PathRemoveFileSpec [SHELL32.35]
 181  */
 182 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
 183 {
 184         if (SHELL_OsIsUnicode())
 185           return PathRemoveFileSpecW(lpszPath);
 186         return PathRemoveFileSpecA(lpszPath);
 187 }
 188
 189 /*************************************************************************
 190  * PathStripPath        [SHELL32.38]
 191  */
 192 void WINAPI PathStripPathAW(LPVOID lpszPath)
 193 {
 194         if (SHELL_OsIsUnicode())
 195             PathStripPathW(lpszPath);
 196         else
 197             PathStripPathA(lpszPath);
 198 }
 199
 200 /*************************************************************************
 201  * PathStripToRoot      [SHELL32.50]
 202  */
 203 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath)
 204 {
 205         if (SHELL_OsIsUnicode())
 206           return PathStripToRootW(lpszPath);
 207         return PathStripToRootA(lpszPath);
 208 }
 209
 210 /*************************************************************************
 211  * PathRemoveArgs       [SHELL32.251]
 212  */
 213 void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
 214 {
 215         if (SHELL_OsIsUnicode())
 216             PathRemoveArgsW(lpszPath);
 217         else
 218             PathRemoveArgsA(lpszPath);
 219 }
 220
 221 /*************************************************************************
 222  * PathRemoveExtension  [SHELL32.250]
 223  */
 224 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
 225 {
 226         if (SHELL_OsIsUnicode())
 227             PathRemoveExtensionW(lpszPath);
 228         else
 229             PathRemoveExtensionA(lpszPath);
 230 }
 231
 232
 233 /*
 234         Path Manipulations
 235 */
 236
 237 /*************************************************************************
 238  * PathGetShortPathA [internal]
 239  */
 240 static void PathGetShortPathA(LPSTR pszPath)
 241 {
 242         CHAR path[MAX_PATH];
 243
 244         TRACE("%s\n", pszPath);
 245
 246         if (GetShortPathNameA(pszPath, path, MAX_PATH))
 247         {
 248           lstrcpyA(pszPath, path);
 249         }
 250 }
 251
 252 /*************************************************************************
 253  * PathGetShortPathW [internal]
 254  */
 255 static void PathGetShortPathW(LPWSTR pszPath)
 256 {
 257         WCHAR path[MAX_PATH];
 258
 259         TRACE("%s\n", debugstr_w(pszPath));
 260
 261         if (GetShortPathNameW(pszPath, path, MAX_PATH))
 262         {
 263           lstrcpyW(pszPath, path);
 264         }
 265 }
 266
 267 /*************************************************************************
 268  * PathGetShortPath [SHELL32.92]
 269  */
 270 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
 271 {
 272         if(SHELL_OsIsUnicode())
 273           PathGetShortPathW(pszPath);
 274         PathGetShortPathA(pszPath);
 275 }
 276
 277 /*************************************************************************
 278  * PathRemoveBlanks [SHELL32.33]
 279  */
 280 void WINAPI PathRemoveBlanksAW(LPVOID str)
 281 {
 282         if(SHELL_OsIsUnicode())
 283             PathRemoveBlanksW(str);
 284         else
 285             PathRemoveBlanksA(str);
 286 }
 287
 288 /*************************************************************************
 289  * PathQuoteSpaces [SHELL32.55]
 290  */
 291 VOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
 292 {
 293         if(SHELL_OsIsUnicode())
 294             PathQuoteSpacesW(lpszPath);
 295         else
 296             PathQuoteSpacesA(lpszPath);
 297 }
 298
 299 /*************************************************************************
 300  * PathUnquoteSpaces [SHELL32.56]
 301  */
 302 VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
 303 {
 304         if(SHELL_OsIsUnicode())
 305           PathUnquoteSpacesW(str);
 306         else
 307           PathUnquoteSpacesA(str);
 308 }
 309
 310 /*************************************************************************
 311  * PathParseIconLocation        [SHELL32.249]
 312  */
 313 int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
 314 {
 315         if(SHELL_OsIsUnicode())
 316           return PathParseIconLocationW(lpszPath);
 317         return PathParseIconLocationA(lpszPath);
 318 }
 319
 320 /*
 321         ########## Path Testing ##########
 322 */
 323 /*************************************************************************
 324  * PathIsUNC            [SHELL32.39]
 325  */
 326 BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
 327 {
 328         if (SHELL_OsIsUnicode())
 329           return PathIsUNCW( lpszPath );
 330         return PathIsUNCA( lpszPath );
 331 }
 332
 333 /*************************************************************************
 334  *  PathIsRelative      [SHELL32.40]
 335  */
 336 BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
 337 {
 338         if (SHELL_OsIsUnicode())
 339           return PathIsRelativeW( lpszPath );
 340         return PathIsRelativeA( lpszPath );
 341 }
 342
 343 /*************************************************************************
 344  * PathIsRoot           [SHELL32.29]
 345  */
 346 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
 347 {
 348         if (SHELL_OsIsUnicode())
 349           return PathIsRootW(lpszPath);
 350         return PathIsRootA(lpszPath);
 351 }
 352
 353 /*************************************************************************
 354  *  PathIsExeA          [internal]
 355  */
 356 static BOOL PathIsExeA (LPCSTR lpszPath)
 357 {
 358         LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
 359         int i;
 360         static const char * const lpszExtensions[] =
 361             {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
 362
 363         TRACE("path=%s\n",lpszPath);
 364
 365         for(i=0; lpszExtensions[i]; i++)
 366           if (!strcasecmp(lpszExtension,lpszExtensions[i])) return TRUE;
 367
 368         return FALSE;
 369 }
 370
 371 /*************************************************************************
 372  *  PathIsExeW          [internal]
 373  */
 374 static BOOL PathIsExeW (LPCWSTR lpszPath)
 375 {
 376         LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
 377         int i;
 378         static const WCHAR lpszExtensions[][4] =
 379             {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
 380              {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
 381              {'s','c','r','\0'}, {'\0'} };
 382
 383         TRACE("path=%s\n",debugstr_w(lpszPath));
 384
 385         for(i=0; lpszExtensions[i][0]; i++)
 386           if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 387
 388         return FALSE;
 389 }
 390
 391 /*************************************************************************
 392  *  PathIsExe           [SHELL32.43]
 393  */
 394 BOOL WINAPI PathIsExeAW (LPCVOID path)
 395 {
 396         if (SHELL_OsIsUnicode())
 397           return PathIsExeW (path);
 398         return PathIsExeA(path);
 399 }
 400
 401 /*************************************************************************
 402  * PathIsDirectory      [SHELL32.159]
 403  */
 404 BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
 405 {
 406         if (SHELL_OsIsUnicode())
 407           return PathIsDirectoryW (lpszPath);
 408         return PathIsDirectoryA (lpszPath);
 409 }
 410
 411 /*************************************************************************
 412  * PathFileExists       [SHELL32.45]
 413  */
 414 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
 415 {
 416         if (SHELL_OsIsUnicode())
 417           return PathFileExistsW (lpszPath);
 418         return PathFileExistsA (lpszPath);
 419 }
 420
 421 /*************************************************************************
 422  * PathMatchSpec        [SHELL32.46]
 423  */
 424 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask)
 425 {
 426         if (SHELL_OsIsUnicode())
 427           return PathMatchSpecW( name, mask );
 428         return PathMatchSpecA( name, mask );
 429 }
 430
 431 /*************************************************************************
 432  * PathIsSameRoot       [SHELL32.650]
 433  */
 434 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
 435 {
 436         if (SHELL_OsIsUnicode())
 437           return PathIsSameRootW(lpszPath1, lpszPath2);
 438         return PathIsSameRootA(lpszPath1, lpszPath2);
 439 }
 440
 441 /*************************************************************************
 442  * IsLFNDriveA          [SHELL32.41]
 443  */
 444 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
 445 {
 446     DWORD       fnlen;
 447
 448     if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 449         return FALSE;
 450     return fnlen > 12;
 451 }
 452
 453 /*************************************************************************
 454  * IsLFNDriveW          [SHELL32.42]
 455  */
 456 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
 457 {
 458     DWORD       fnlen;
 459
 460     if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 461         return FALSE;
 462     return fnlen > 12;
 463 }
 464
 465 /*************************************************************************
 466  * IsLFNDrive           [SHELL32.119]
 467  */
 468 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
 469 {
 470         if (SHELL_OsIsUnicode())
 471           return IsLFNDriveW(lpszPath);
 472         return IsLFNDriveA(lpszPath);
 473 }
 474
 475 /*
 476         ########## Creating Something Unique ##########
 477 */
 478 /*************************************************************************
 479  * PathMakeUniqueNameA  [internal]
 480  */
 481 BOOL WINAPI PathMakeUniqueNameA(
 482         LPSTR lpszBuffer,
 483         DWORD dwBuffSize,
 484         LPCSTR lpszShortName,
 485         LPCSTR lpszLongName,
 486         LPCSTR lpszPathName)
 487 {
 488         FIXME("%p %lu %s %s %s stub\n",
 489          lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
 490          debugstr_a(lpszLongName), debugstr_a(lpszPathName));
 491         return TRUE;
 492 }
 493
 494 /*************************************************************************
 495  * PathMakeUniqueNameW  [internal]
 496  */
 497 BOOL WINAPI PathMakeUniqueNameW(
 498         LPWSTR lpszBuffer,
 499         DWORD dwBuffSize,
 500         LPCWSTR lpszShortName,
 501         LPCWSTR lpszLongName,
 502         LPCWSTR lpszPathName)
 503 {
 504         FIXME("%p %lu %s %s %s stub\n",
 505          lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
 506          debugstr_w(lpszLongName), debugstr_w(lpszPathName));
 507         return TRUE;
 508 }
 509
 510 /*************************************************************************
 511  * PathMakeUniqueName   [SHELL32.47]
 512  */
 513 BOOL WINAPI PathMakeUniqueNameAW(
 514         LPVOID lpszBuffer,
 515         DWORD dwBuffSize,
 516         LPCVOID lpszShortName,
 517         LPCVOID lpszLongName,
 518         LPCVOID lpszPathName)
 519 {
 520         if (SHELL_OsIsUnicode())
 521           return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 522         return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 523 }
 524
 525 /*************************************************************************
 526  * PathYetAnotherMakeUniqueName [SHELL32.75]
 527  *
 528  * NOTES
 529  *     exported by ordinal
 530  */
 531 BOOL WINAPI PathYetAnotherMakeUniqueName(
 532         LPWSTR lpszBuffer,
 533         LPCWSTR lpszPathName,
 534         LPCWSTR lpszShortName,
 535         LPCWSTR lpszLongName)
 536 {
 537     FIXME("(%p, %s, %s ,%s):stub.\n",
 538           lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
 539     return TRUE;
 540 }
 541
 542
 543 /*
 544         ########## cleaning and resolving paths ##########
 545  */
 546
 547 /*************************************************************************
 548  * PathFindOnPath       [SHELL32.145]
 549  */
 550 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID sOtherDirs)
 551 {
 552         if (SHELL_OsIsUnicode())
 553           return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs);
 554         return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs);
 555 }
 556
 557 /*************************************************************************
 558  * PathCleanupSpec      [SHELL32.171]
 559  */
 560 DWORD WINAPI PathCleanupSpecAW (LPCVOID x, LPVOID y)
 561 {
 562     FIXME("(%p, %p) stub\n",x,y);
 563     return TRUE;
 564 }
 565
 566 /*************************************************************************
 567  * PathQualifyA         [SHELL32]
 568  */
 569 BOOL WINAPI PathQualifyA(LPCSTR pszPath)
 570 {
 571         FIXME("%s\n",pszPath);
 572         return 0;
 573 }
 574
 575 /*************************************************************************
 576  * PathQualifyW         [SHELL32]
 577  */
 578 BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
 579 {
 580         FIXME("%s\n",debugstr_w(pszPath));
 581         return 0;
 582 }
 583
 584 /*************************************************************************
 585  * PathQualify  [SHELL32.49]
 586  */
 587 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
 588 {
 589         if (SHELL_OsIsUnicode())
 590           return PathQualifyW(pszPath);
 591         return PathQualifyA(pszPath);
 592 }
 593
 594 /*************************************************************************
 595  * PathResolveA [SHELL32.51]
 596  */
 597 BOOL WINAPI PathResolveA(
 598         LPSTR lpszPath,
 599         LPCSTR *alpszPaths,
 600         DWORD dwFlags)
 601 {
 602         FIXME("(%s,%p,0x%08lx),stub!\n",
 603           lpszPath, *alpszPaths, dwFlags);
 604         return 0;
 605 }
 606
 607 /*************************************************************************
 608  * PathResolveW [SHELL32]
 609  */
 610 BOOL WINAPI PathResolveW(
 611         LPWSTR lpszPath,
 612         LPCWSTR *alpszPaths,
 613         DWORD dwFlags)
 614 {
 615         FIXME("(%s,%p,0x%08lx),stub!\n",
 616           debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
 617         return 0;
 618 }
 619
 620 /*************************************************************************
 621  * PathResolve [SHELL32.51]
 622  */
 623 BOOL WINAPI PathResolveAW(
 624         LPVOID lpszPath,
 625         LPCVOID *alpszPaths,
 626         DWORD dwFlags)
 627 {
 628         if (SHELL_OsIsUnicode())
 629           return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
 630         return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
 631 }
 632
 633 /*************************************************************************
 634 *       PathProcessCommandA     [SHELL32.653]
 635 */
 636 HRESULT WINAPI PathProcessCommandA (
 637         LPCSTR lpszPath,
 638         LPSTR lpszBuff,
 639         DWORD dwBuffSize,
 640         DWORD dwFlags)
 641 {
 642         FIXME("%s %p 0x%04lx 0x%04lx stub\n",
 643         lpszPath, lpszBuff, dwBuffSize, dwFlags);
 644         strcpy(lpszBuff, lpszPath);
 645         return 0;
 646 }
 647
 648 /*************************************************************************
 649 *       PathProcessCommandW
 650 */
 651 HRESULT WINAPI PathProcessCommandW (
 652         LPCWSTR lpszPath,
 653         LPWSTR lpszBuff,
 654         DWORD dwBuffSize,
 655         DWORD dwFlags)
 656 {
 657         FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n",
 658         debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
 659         strcpyW(lpszBuff, lpszPath);
 660         return 0;
 661 }
 662
 663 /*************************************************************************
 664 *       PathProcessCommand (SHELL32.653)
 665 */
 666 HRESULT WINAPI PathProcessCommandAW (
 667         LPCVOID lpszPath,
 668         LPVOID lpszBuff,
 669         DWORD dwBuffSize,
 670         DWORD dwFlags)
 671 {
 672         if (SHELL_OsIsUnicode())
 673           return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 674         return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 675 }
 676
 677 /*
 678         ########## special ##########
 679 */
 680
 681 /*************************************************************************
 682  * PathSetDlgItemPath (SHELL32.48)
 683  */
 684 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
 685 {
 686         if (SHELL_OsIsUnicode())
 687             PathSetDlgItemPathW(hDlg, id, pszPath);
 688         else
 689             PathSetDlgItemPathA(hDlg, id, pszPath);
 690 }
 691
 692 /*************************************************************************
 693  * SHGetFolderPathW                     [SHELL32.@]
 694  *
 695  * converts csidl to path
 696  */
 697
 698 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'};
 699 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'};
 700 static const WCHAR szSetup[] = {'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','e','t','u','p','\0'};
 701 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'};
 702
 703
 704
 705 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'};
 706 static const WCHAR All_Users__Application_DataW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 707                                                      'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'};
 708 static const WCHAR All_Users__DocumentsW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 709                                               'D','o','c','u','m','e','n','t','s','\0'};
 710 static const WCHAR All_Users__Documents__My_MusicW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 711                                                         'D','o','c','u','m','e','n','t','s','\\',
 712                                                         'M','y',' ','M','u','s','i','c','\0'};
 713 static const WCHAR All_Users__Documents__My_PicturesW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 714                                                            'D','o','c','u','m','e','n','t','s','\\',
 715                                                            'M','y',' ','P','i','c','t','u','r','e','s','\0'};
 716 static const WCHAR All_Users__Documents__My_VideoW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 717                                                         'D','o','c','u','m','e','n','t','s','\\',
 718                                                         'M','y',' ','V','i','d','e','o','\0'};
 719 static const WCHAR All_Users__Start_Menu__Programs__Administrative_ToolsW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 720                                 'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\',
 721                                 'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
 722 static const WCHAR All_Users__Start_Menu__Programs__StartUpW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 723                                                                'S','t','a','r','t',' ','M','e','n','u','\\',
 724                                                                'P','r','o','g','r','a','m','s','\\',
 725                                                                'S','t','a','r','t','U','p','\0'};
 726 static const WCHAR All_Users__TemplatesW[] = {'A','l','l',' ','U','s','e','r','s','\\',
 727                                               'T','e','m','p','l','a','t','e','s','\0'};
 728 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
 729 static const WCHAR Application_DataW[] = {'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'};
 730 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
 731 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
 732 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'};
 733 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
 734 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
 735 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
 736 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
 737 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
 738 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
 739 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
 740 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
 741 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
 742 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
 743 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
 744 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
 745 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
 746 static const WCHAR Empty_StringW[] = {'\0'};
 747 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
 748 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
 749 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
 750 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
 751 static const WCHAR Local_Settings__Application_DataW[] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\',
 752                                                          'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'};
 753 static const WCHAR Local_Settings__Application_Data__Microsoft__CD_BurningW[] = {
 754     'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\',
 755     'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\\',
 756     'M','i','c','r','o','s','o','f','t','\\','C','D',' ','B','u','r','n','i','n','g','\0'};
 757 static const WCHAR My_DocumentsW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\0'};
 758 static const WCHAR My_Documents__My_MusicW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\',
 759                                                 'M','y',' ','M','u','s','i','c','\0'};
 760 static const WCHAR My_Documents__My_PicturesW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\',
 761                                                   'M','y',' ','P','i','c','t','u','r','e','s','\0'};
 762 static const WCHAR My_Documents__My_VideoW[] = {'M','y',' ','D','o','c','u','m','e','n','t','s','\\',
 763                                                'M','y',' ','V','i','d','e','o','\0'};
 764 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
 765 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
 766 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
 767 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
 768 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
 769 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
 770 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
 771 static const WCHAR Program_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\0'};
 772 static const WCHAR Program_Files__Common_FilesW[] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\\',
 773                                                      'C','o','m','m','o','n',' ','F','i','l','e','s','\0'};
 774 static const WCHAR ProgramsW[] = {'P','r','o','g','r','m','s','\0'};
 775 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
 776 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
 777 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
 778 static const WCHAR ShellNewW[] = {'S','h','e','l','l','N','e','w','\0'};
 779 static const WCHAR Start_Menu__ProgramsW[] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\0'};
 780 static const WCHAR SysDirW[] = {'S','y','s','D','i','r','\0'};
 781 static const WCHAR SYSTEMW[] = {'S','Y','S','T','E','M','\0'};
 782 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
 783 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
 784 static const WCHAR Start_Menu__Programs__Administrative_ToolsW[] = {
 785                                 'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\',
 786                                 'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
 787 static const WCHAR Start_Menu__Programs__StartUpW[] = {'S','t','a','r','t',' ','M','e','n','u','\\',
 788                                                      'P','r','o','g','r','a','m','s','\\',
 789                                                      'S','t','a','r','t','U','p','\0'};
 790 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
 791 static const WCHAR Temporary_Internet_FilesW[] = {'T','e','m','p','o','r','a','r','y',' ','I','n','t','e','r','n','e','t',' ','F','i','l','e','s','\0'};
 792 static const WCHAR WinDirW[] = {'W','i','n','D','i','r','\0'};
 793 static const WCHAR WindowsW[] = {'W','i','n','d','o','w','s','\0'};
 794
 795
 796
 797
 798 typedef struct
 799 {
 800     DWORD dwFlags;
 801     HKEY hRootKey;
 802     LPCWSTR szValueName;
 803     LPCWSTR szDefaultPath; /* fallback string; sub dir of windows directory */
 804 } CSIDL_DATA;
 805
 806 #define CSIDL_MYFLAG_SHFOLDER   1
 807 #define CSIDL_MYFLAG_SETUP      2
 808 #define CSIDL_MYFLAG_CURRVER    4
 809 #define CSIDL_MYFLAG_RELATIVE   8
 810
 811 #define HKLM HKEY_LOCAL_MACHINE
 812 #define HKCU HKEY_CURRENT_USER
 813 #define HKEY_DISALLOWED    (HKEY)0
 814 #define HKEY_UNIMPLEMENTED (HKEY)1
 815 #define HKEY_WINDOWSPATH   (HKEY)2
 816 #define HKEY_NONEXISTENT   (HKEY)3
 817 static const CSIDL_DATA CSIDL_Data[] =
 818 {
 819     { /* CSIDL_DESKTOP */
 820         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 821         HKCU,
 822         DesktopW,
 823         DesktopW
 824     },
 825     { /* CSIDL_INTERNET */
 826         0,
 827         HKEY_DISALLOWED,
 828         NULL,
 829         NULL
 830     },
 831     { /* CSIDL_PROGRAMS */
 832         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 833         HKCU,
 834         ProgramsW,
 835         Start_Menu__ProgramsW
 836     },
 837     { /* CSIDL_CONTROLS (.CPL files) */
 838         CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE,
 839         HKLM,
 840         SysDirW,
 841         SYSTEMW
 842     },
 843     { /* CSIDL_PRINTERS */
 844         CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE,
 845         HKLM,
 846         SysDirW,
 847         SYSTEMW
 848     },
 849     { /* CSIDL_PERSONAL */
 850         CSIDL_MYFLAG_SHFOLDER,
 851         HKCU,
 852         PersonalW,
 853         My_DocumentsW
 854     },
 855     { /* CSIDL_FAVORITES */
 856         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 857         HKCU,
 858         FavoritesW,
 859         FavoritesW
 860     },
 861     { /* CSIDL_STARTUP */
 862         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 863         HKCU,
 864         StartUpW,
 865         Start_Menu__Programs__StartUpW
 866     },
 867     { /* CSIDL_RECENT */
 868         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 869         HKCU,
 870         RecentW,
 871         RecentW
 872     },
 873     { /* CSIDL_SENDTO */
 874         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 875         HKCU,
 876         SendToW,
 877         SendToW
 878     },
 879     { /* CSIDL_BITBUCKET - Recycle Bin */
 880         0,
 881         HKEY_DISALLOWED,
 882         NULL,
 883         NULL,
 884     },
 885     { /* CSIDL_STARTMENU */
 886         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 887         HKCU,
 888         Start_MenuW,
 889         Start_MenuW
 890     },
 891     { /* CSIDL_MYDOCUMENTS */
 892         0,
 893         HKEY_UNIMPLEMENTED, /* FIXME */
 894         NULL,
 895         NULL
 896     },
 897     { /* CSIDL_MYMUSIC */
 898         CSIDL_MYFLAG_SHFOLDER,
 899         HKCU,
 900         My_MusicW,
 901         My_Documents__My_MusicW
 902     },
 903     { /* CSIDL_MYVIDEO */
 904         CSIDL_MYFLAG_SHFOLDER,
 905         HKCU,
 906         My_VideoW,
 907         My_Documents__My_VideoW
 908     },
 909     { /* unassigned */
 910         0,
 911         HKEY_DISALLOWED,
 912         NULL,
 913         NULL,
 914     },
 915     { /* CSIDL_DESKTOPDIRECTORY */
 916         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 917         HKCU,
 918         DesktopW,
 919         DesktopW
 920     },
 921     { /* CSIDL_DRIVES */
 922         0,
 923         HKEY_DISALLOWED,
 924         NULL,
 925         NULL,
 926     },
 927     { /* CSIDL_NETWORK */
 928         0,
 929         HKEY_DISALLOWED,
 930         NULL,
 931         NULL,
 932     },
 933     { /* CSIDL_NETHOOD */
 934         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 935         HKCU,
 936         NetHoodW,
 937         NetHoodW
 938     },
 939     { /* CSIDL_FONTS */
 940         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 941         HKCU,
 942         FontsW,
 943         FontsW
 944     },
 945     { /* CSIDL_TEMPLATES */
 946         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 947         HKCU,
 948         TemplatesW,
 949         ShellNewW
 950     },
 951     { /* CSIDL_COMMON_STARTMENU */
 952         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 953         HKLM,
 954         Common_Start_MenuW,
 955         Start_MenuW
 956     },
 957     { /* CSIDL_COMMON_PROGRAMS */
 958         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 959         HKLM,
 960         Common_ProgramsW,
 961         Empty_StringW
 962     },
 963     { /* CSIDL_COMMON_STARTUP */
 964         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 965         HKLM,
 966         Common_StartUpW,
 967         All_Users__Start_Menu__Programs__StartUpW
 968     },
 969     { /* CSIDL_COMMON_DESKTOPDIRECTORY */
 970         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 971         HKLM,
 972         Common_DesktopW,
 973         DesktopW
 974     },
 975     { /* CSIDL_APPDATA */
 976         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 977         HKCU,
 978         AppDataW,
 979         Application_DataW
 980     },
 981     { /* CSIDL_PRINTHOOD */
 982         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
 983         HKCU,
 984         PrintHoodW,
 985         PrintHoodW
 986     },
 987     { /* CSIDL_LOCAL_APPDATA (win2k only/undocumented) */
 988         CSIDL_MYFLAG_SHFOLDER,
 989         HKCU,
 990         Local_AppDataW,
 991         Local_Settings__Application_DataW,
 992     },
 993     { /* CSIDL_ALTSTARTUP */
 994         0,
 995         HKEY_NONEXISTENT,
 996         NULL,
 997         NULL
 998     },
 999     { /* CSIDL_COMMON_ALTSTARTUP */
1000         0,
1001         HKEY_NONEXISTENT,
1002         NULL,
1003         NULL
1004     },
1005     { /* CSIDL_COMMON_FAVORITES */
1006         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1007         HKCU,
1008         FavoritesW,
1009         FavoritesW
1010     },
1011     { /* CSIDL_INTERNET_CACHE (32) */
1012         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1013         HKCU,
1014         CacheW,
1015         Temporary_Internet_FilesW
1016     },
1017     { /* CSIDL_COOKIES (33) */
1018         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1019         HKCU,
1020         CookiesW,
1021         CookiesW
1022     },
1023     { /* CSIDL_HISTORY (34) */
1024         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1025         HKCU,
1026         HistoryW,
1027         HistoryW
1028     },
1029     { /* CSIDL_COMMON_APPDATA */
1030         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1031         HKLM,
1032         Common_AppDataW,
1033         All_Users__Application_DataW
1034     },
1035     { /* CSIDL_WINDOWS */
1036         CSIDL_MYFLAG_SETUP,
1037         HKLM,
1038         WinDirW,
1039         WindowsW
1040     },
1041     { /* CSIDL_SYSTEM */
1042         CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE,
1043         HKLM,
1044         SysDirW,
1045         SYSTEMW
1046     },
1047     { /* CSIDL_PROGRAM_FILES */
1048         CSIDL_MYFLAG_CURRVER,
1049         HKLM,
1050         ProgramFilesDirW,
1051         Program_FilesW
1052     },
1053     { /* CSIDL_MYPICTURES */
1054         CSIDL_MYFLAG_SHFOLDER,
1055         HKCU,
1056         My_PicturesW,
1057         My_Documents__My_PicturesW
1058     },
1059     { /* CSIDL_PROFILE */
1060         CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE,
1061         HKLM,
1062         WinDirW, /* correct ? */
1063         Empty_StringW
1064     },
1065     { /* CSIDL_SYSTEMX86 */
1066         CSIDL_MYFLAG_SETUP | CSIDL_MYFLAG_RELATIVE,
1067         HKLM,
1068         SysDirW,
1069         SYSTEMW
1070     },
1071     { /* CSIDL_PROGRAM_FILESX86 */
1072         CSIDL_MYFLAG_CURRVER,
1073         HKLM,
1074         ProgramFilesDirW,
1075         Program_FilesW
1076     },
1077     { /* CSIDL_PROGRAM_FILES_COMMON */
1078         CSIDL_MYFLAG_CURRVER,
1079         HKLM,
1080         CommonFilesDirW,
1081         Program_Files__Common_FilesW /* ? */
1082     },
1083     { /* CSIDL_PROGRAM_FILES_COMMONX86 */
1084         CSIDL_MYFLAG_CURRVER,
1085         HKLM,
1086         CommonFilesDirW,
1087         Program_Files__Common_FilesW /* ? */
1088     },
1089     { /* CSIDL_COMMON_TEMPLATES */
1090         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1091         HKLM,
1092         Common_TemplatesW,
1093         /*"Documents and Settings\\"*/ All_Users__TemplatesW
1094     },
1095     { /* CSIDL_COMMON_DOCUMENTS */
1096         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1097         HKLM,
1098         Common_DocumentsW,
1099         /*"Documents and Settings\\"*/ All_Users__DocumentsW
1100     },
1101     { /* CSIDL_COMMON_ADMINTOOLS */
1102         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1103         HKLM,
1104         Common_Administrative_ToolsW,
1105         /*"Documents and Settings\\"*/ All_Users__Start_Menu__Programs__Administrative_ToolsW
1106     },
1107     { /* CSIDL_ADMINTOOLS */
1108         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1109         HKCU,
1110         Administrative_ToolsW,
1111         Start_Menu__Programs__Administrative_ToolsW
1112     },
1113     { /* CSIDL_CONNECTIONS */
1114         0,
1115         HKEY_DISALLOWED,
1116         NULL,
1117         NULL
1118     },
1119     { /* unassigned 32 */
1120         0,
1121         HKEY_DISALLOWED,
1122         NULL,
1123         NULL
1124     },
1125     { /* unassigned 33 */
1126         0,
1127         HKEY_DISALLOWED,
1128         NULL,
1129         NULL
1130     },
1131     { /* unassigned 34 */
1132         0,
1133         HKEY_DISALLOWED,
1134         NULL,
1135         NULL
1136     },
1137     { /* CSIDL_COMMON_MUSIC */
1138         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1139         HKLM,
1140         CommonMusicW,
1141         /*"Documents and Settings\\"*/ All_Users__Documents__My_MusicW
1142     },
1143     { /* CSIDL_COMMON_PICTURES */
1144         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1145         HKLM,
1146         CommonPicturesW,
1147         /*"Documents and Settings\\"*/ All_Users__Documents__My_PicturesW
1148     },
1149     { /* CSIDL_COMMON_VIDEO */
1150         CSIDL_MYFLAG_SHFOLDER | CSIDL_MYFLAG_RELATIVE,
1151         HKLM,
1152         CommonVideoW,
1153         /*"Documents and Settings\\"*/ All_Users__Documents__My_VideoW
1154     },
1155     { /* CSIDL_RESOURCES */
1156         0,
1157         HKEY_WINDOWSPATH,
1158         NULL,
1159         ResourcesW
1160     },
1161     { /* CSIDL_RESOURCES_LOCALIZED */
1162         0,
1163         HKEY_DISALLOWED, /* FIXME */
1164         NULL,
1165         NULL
1166     },
1167     { /* CSIDL_COMMON_OEM_LINKS */
1168         0,
1169         HKEY_DISALLOWED, /* FIXME */
1170         NULL,
1171         NULL
1172     },
1173     { /* CSIDL_CDBURN_AREA */
1174         CSIDL_MYFLAG_SHFOLDER,
1175         HKCU,
1176         CD_BurningW,
1177         Local_Settings__Application_Data__Microsoft__CD_BurningW
1178     },
1179     { /* unassigned 3C */
1180         0,
1181         HKEY_DISALLOWED,
1182         NULL,
1183         NULL
1184     },
1185     { /* CSIDL_COMPUTERSNEARME */
1186         0,
1187         HKEY_DISALLOWED, /* FIXME */
1188         NULL,
1189         NULL
1190     },
1191     { /* CSIDL_PROFILES */
1192         0,
1193         HKEY_DISALLOWED, /* FIXME */
1194         NULL,
1195         NULL
1196     }
1197 };
1198 #undef HKCU
1199 #undef HKLM
1200
1201 /**********************************************************************/
1202
1203 HRESULT WINAPI SHGetFolderPathW(
1204         HWND hwndOwner,
1205         int csidl,
1206         HANDLE hToken,  /* [in] FIXME: get paths for specific user */
1207         DWORD dwFlags,  /* [in] FIXME: SHGFP_TYPE_CURRENT|SHGFP_TYPE_DEFAULT */
1208         LPWSTR pszPath)
1209 {
1210         WCHAR   szBuildPath[MAX_PATH];
1211         HKEY    hRootKey, hKey;
1212         DWORD   dwCsidlFlags;
1213         DWORD   dwType, dwDisp, dwPathLen = MAX_PATH;
1214         DWORD   folder = csidl & CSIDL_FOLDER_MASK;
1215         WCHAR   *p;
1216
1217         TRACE("%p,%p,csidl=0x%04x\n", hwndOwner,pszPath,csidl);
1218
1219         if (!pszPath)
1220             return E_INVALIDARG;
1221
1222         *pszPath = '\0';
1223         if ((folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0])) ||
1224             (CSIDL_Data[folder].hRootKey == HKEY_DISALLOWED))
1225             return E_INVALIDARG;
1226         if (CSIDL_Data[folder].hRootKey == HKEY_UNIMPLEMENTED)
1227         {
1228             FIXME("folder 0x%04lx unknown, please add.\n", folder);
1229             return E_FAIL;
1230         }
1231         if (CSIDL_Data[folder].hRootKey == HKEY_NONEXISTENT)
1232             return S_FALSE;
1233
1234         /* Special case for some values that don't exist in registry */
1235         if (CSIDL_Data[folder].hRootKey == HKEY_WINDOWSPATH)
1236         {
1237             GetWindowsDirectoryW(pszPath, MAX_PATH);
1238             PathAddBackslashW(pszPath);
1239             strcatW(pszPath, CSIDL_Data[folder].szDefaultPath);
1240             return S_OK;
1241         }
1242
1243         dwCsidlFlags = CSIDL_Data[folder].dwFlags;
1244         hRootKey = CSIDL_Data[folder].hRootKey;
1245
1246         if (dwCsidlFlags & CSIDL_MYFLAG_SHFOLDER)
1247         {
1248           /*   user shell folders */
1249           if   (RegCreateKeyExW(hRootKey,szSHUserFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL;
1250
1251           if   (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen))
1252           {
1253             RegCloseKey(hKey);
1254
1255             /* shell folders */
1256             if (RegCreateKeyExW(hRootKey,szSHFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL;
1257
1258             if (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen))
1259             {
1260
1261               /* value not existing */
1262               if (dwCsidlFlags & CSIDL_MYFLAG_RELATIVE)
1263               {
1264                 GetWindowsDirectoryW(pszPath, MAX_PATH);
1265                 PathAddBackslashW(pszPath);
1266                 strcatW(pszPath, CSIDL_Data[folder].szDefaultPath);
1267               }
1268               else
1269               {
1270                 GetSystemDirectoryW(pszPath, MAX_PATH);
1271                 strcpyW(pszPath + 3, CSIDL_Data[folder].szDefaultPath);
1272               }
1273               dwType=REG_SZ;
1274               RegSetValueExW(hKey,CSIDL_Data[folder].szValueName,0,REG_SZ,(LPBYTE)pszPath,
1275                          (strlenW(pszPath)+1)*sizeof(WCHAR));
1276             }
1277           }
1278           RegCloseKey(hKey);
1279         }
1280         else
1281         {
1282           LPCWSTR pRegPath;
1283
1284           if (dwCsidlFlags & CSIDL_MYFLAG_SETUP)
1285             pRegPath = szSetup;
1286           else if (dwCsidlFlags & CSIDL_MYFLAG_CURRVER)
1287             pRegPath = szCurrentVersion;
1288           else
1289           {
1290             ERR("folder settings broken, please correct !\n");
1291             return E_FAIL;
1292           }
1293
1294           if   (RegCreateKeyExW(hRootKey,pRegPath,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return E_FAIL;
1295
1296           if   (RegQueryValueExW(hKey,CSIDL_Data[folder].szValueName,NULL,&dwType,(LPBYTE)pszPath,&dwPathLen))
1297           {
1298             /* value not existing */
1299             if (dwCsidlFlags & CSIDL_MYFLAG_RELATIVE)
1300             {
1301               GetWindowsDirectoryW(pszPath, MAX_PATH);
1302               PathAddBackslashW(pszPath);
1303               strcatW(pszPath, CSIDL_Data[folder].szDefaultPath);
1304             }
1305             else
1306             {
1307               GetSystemDirectoryW(pszPath, MAX_PATH);
1308               strcpyW(pszPath + 3, CSIDL_Data[folder].szDefaultPath);
1309             }
1310             dwType=REG_SZ;
1311             RegSetValueExW(hKey,CSIDL_Data[folder].szValueName,0,REG_SZ,(LPBYTE)pszPath,
1312                        (strlenW(pszPath)+1)*sizeof(WCHAR));
1313           }
1314           RegCloseKey(hKey);
1315         }
1316
1317         /* expand paths like %USERPROFILE% */
1318         if (dwType == REG_EXPAND_SZ)
1319         {
1320           ExpandEnvironmentStringsW(pszPath, szBuildPath, MAX_PATH);
1321           strcpyW(pszPath, szBuildPath);
1322         }
1323
1324         /* if we don't care about existing directories we are ready */
1325         if(csidl & CSIDL_FLAG_DONT_VERIFY) return S_OK;
1326
1327         if (PathFileExistsW(pszPath)) return S_OK;
1328
1329         /* not existing but we are not allowed to create it */
1330         if (!(csidl & CSIDL_FLAG_CREATE)) return E_FAIL;
1331
1332         /* create directory/directories */
1333         strcpyW(szBuildPath, pszPath);
1334         p = strchrW(szBuildPath, '\\');
1335         while (p)
1336         {
1337             *p = 0;
1338             if (!PathFileExistsW(szBuildPath))
1339             {
1340                 if (!CreateDirectoryW(szBuildPath,NULL))
1341                 {
1342                     ERR("Failed to create directory '%s'.\n", debugstr_w(pszPath));
1343                     return E_FAIL;
1344                 }
1345             }
1346             *p = '\\';
1347             p = strchrW(p+1, '\\');
1348         }
1349         /* last component must be created too. */
1350         if (!PathFileExistsW(szBuildPath))
1351         {
1352             if (!CreateDirectoryW(szBuildPath,NULL))
1353             {
1354                 ERR("Failed to create directory '%s'.\n", debugstr_w(pszPath));
1355                 return E_FAIL;
1356             }
1357         }
1358
1359         TRACE("Created missing system directory '%s'\n", debugstr_w(pszPath));
1360         return S_OK;
1361 }
1362
1363 /*************************************************************************
1364  * SHGetFolderPathA                     [SHELL32.@]
1365  */
1366 HRESULT WINAPI SHGetFolderPathA(
1367         HWND hwndOwner,
1368         int csidl,
1369         HANDLE hToken,
1370         DWORD dwFlags,
1371         LPSTR pszPath)
1372 {
1373     WCHAR szTemp[MAX_PATH];
1374     HRESULT hr;
1375
1376     if (!pszPath)
1377         return E_INVALIDARG;
1378
1379     *pszPath = '\0';
1380     hr = SHGetFolderPathW(hwndOwner, csidl, hToken, dwFlags, szTemp);
1381     if (SUCCEEDED(hr))
1382         WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
1383          NULL);
1384
1385     TRACE("%p,%p,csidl=0x%04x\n",hwndOwner,pszPath,csidl);
1386
1387     return hr;
1388 }
1389
1390 /*************************************************************************
1391  * SHGetSpecialFolderPathA [SHELL32.@]
1392  */
1393 BOOL WINAPI SHGetSpecialFolderPathA (
1394         HWND hwndOwner,
1395         LPSTR szPath,
1396         int csidl,
1397         BOOL bCreate)
1398 {
1399         return (SHGetFolderPathA(
1400                 hwndOwner,
1401                 csidl + (bCreate ? CSIDL_FLAG_CREATE : 0),
1402                 NULL,
1403                 0,
1404                 szPath)) == S_OK ? TRUE : FALSE;
1405 }
1406
1407 /*************************************************************************
1408  * SHGetSpecialFolderPathW
1409  */
1410 BOOL WINAPI SHGetSpecialFolderPathW (
1411         HWND hwndOwner,
1412         LPWSTR szPath,
1413         int csidl,
1414         BOOL bCreate)
1415 {
1416         return (SHGetFolderPathW(
1417                 hwndOwner,
1418                 csidl + (bCreate ? CSIDL_FLAG_CREATE : 0),
1419                 NULL,
1420                 0,
1421                 szPath)) == S_OK ? TRUE : FALSE;
1422 }
1423
1424 /*************************************************************************
1425  * SHGetSpecialFolderPath (SHELL32.175)
1426  */
1427 BOOL WINAPI SHGetSpecialFolderPathAW (
1428         HWND hwndOwner,
1429         LPVOID szPath,
1430         int csidl,
1431         BOOL bCreate)
1432
1433 {
1434         if (SHELL_OsIsUnicode())
1435           return SHGetSpecialFolderPathW (hwndOwner, szPath, csidl, bCreate);
1436         return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate);
1437 }
1438
1439 /*************************************************************************
1440  * SHGetSpecialFolderLocation           [SHELL32.@]
1441  *
1442  * gets the folder locations from the registry and creates a pidl
1443  * creates missing reg keys and directories
1444  *
1445  * PARAMS
1446  *   hwndOwner [I]
1447  *   nFolder   [I] CSIDL_xxxxx
1448  *   ppidl     [O] PIDL of a special folder
1449  *
1450  * NOTES
1451  *   In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
1452  *   directory. If the directory is missing it returns a x80070002.
1453  *   In most cases, this forwards to SHGetSpecialFolderPath, but
1454  *   CSIDLs with virtual folders (not real paths) must be handled
1455  *   here.
1456  */
1457 HRESULT WINAPI SHGetSpecialFolderLocation(
1458         HWND hwndOwner,
1459         INT nFolder,
1460         LPITEMIDLIST * ppidl)
1461 {
1462     HRESULT hr = E_INVALIDARG;
1463
1464     TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
1465
1466     if (!ppidl)
1467         return E_INVALIDARG;
1468
1469     *ppidl = NULL;
1470     switch (nFolder)
1471     {
1472         case CSIDL_DESKTOP:
1473             *ppidl = _ILCreateDesktop();
1474             break;
1475
1476         case CSIDL_INTERNET:
1477             *ppidl = _ILCreateIExplore();
1478             break;
1479
1480         case CSIDL_CONTROLS:
1481             *ppidl = _ILCreateControlPanel();
1482             break;
1483
1484         case CSIDL_PRINTERS:
1485             *ppidl = _ILCreatePrinters();
1486             break;
1487
1488         case CSIDL_BITBUCKET:
1489             *ppidl = _ILCreateBitBucket();
1490             break;
1491
1492         case CSIDL_DRIVES:
1493             *ppidl = _ILCreateMyComputer();
1494             break;
1495
1496         case CSIDL_NETWORK:
1497             *ppidl = _ILCreateNetwork();
1498             break;
1499
1500         case CSIDL_ALTSTARTUP:
1501         case CSIDL_COMMON_ALTSTARTUP:
1502             hr = E_FAIL;
1503             break;
1504
1505         case CSIDL_COMPUTERSNEARME:
1506             hr = E_FAIL;
1507             break;
1508
1509         default:
1510         {
1511             WCHAR szPath[MAX_PATH];
1512
1513             if (SHGetSpecialFolderPathW(hwndOwner, szPath, nFolder, TRUE))
1514             {
1515                 DWORD attributes=0;
1516
1517                 TRACE("Value=%s\n", debugstr_w(szPath));
1518                 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
1519             }
1520         }
1521     }
1522     if(*ppidl)
1523         hr = NOERROR;
1524
1525     TRACE("-- (new pidl %p)\n",*ppidl);
1526     return hr;
1527 }
1528
1529 /*************************************************************************
1530  * SHGetFolderLocation [SHELL32.@]
1531  *
1532  * NOTES
1533  *  the pidl can be a simple one. since we can't get the path out of the pidl
1534  *  we have to take all data from the pidl
1535  *  Mostly we forward to SHGetSpecialFolderLocation, but a few special cases
1536  *  we handle here.
1537  */
1538 HRESULT WINAPI SHGetFolderLocation(
1539         HWND hwnd,
1540         int csidl,
1541         HANDLE hToken,
1542         DWORD dwFlags,
1543         LPITEMIDLIST *ppidl)
1544 {
1545     HRESULT hr;
1546
1547     TRACE_(shell)("%p 0x%08x %p 0x%08lx %p\n",
1548      hwnd, csidl, hToken, dwFlags, ppidl);
1549
1550     if (!ppidl)
1551         return E_INVALIDARG;
1552
1553     switch (csidl)
1554     {
1555         case CSIDL_ALTSTARTUP:
1556         case CSIDL_COMMON_ALTSTARTUP:
1557             *ppidl = NULL;
1558             hr = S_FALSE;
1559             break;
1560         default:
1561             hr = SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
1562     }
1563     return hr;
1564 }