Ignore:
Timestamp:
Sep 5, 2001, 3:54:53 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellpath.c

    r5618 r6650  
     1/* $Id: shellpath.c,v 1.6 2001-09-05 13:46:58 bird Exp $ */
    12/*
    23 * Path Functions
    … …  
    2122
    2223/*
    23         ########## Combining and Constructing paths ##########
     24    ########## Combining and Constructing paths ##########
    2425*/
    2526
    2627/*************************************************************************
    27  * PathAppendAW         [SHELL32.36]
     28 * PathAppendAW     [SHELL32.36]
    2829 */
    2930BOOL WINAPI PathAppendAW(
    30         LPVOID lpszPath1,
    31         LPCVOID lpszPath2)
    32 {
    33         if (SHELL_OsIsUnicode())
    34           return PathAppendW(lpszPath1, lpszPath2);
    35         return PathAppendA(lpszPath1, lpszPath2);
    36 }
    37 
    38 /*************************************************************************
    39  * PathCombineAW        [SHELL32.37]
     31    LPVOID lpszPath1,
     32    LPCVOID lpszPath2)
     33{
     34    if (SHELL_OsIsUnicode())
     35      return PathAppendW(lpszPath1, lpszPath2);
     36    return PathAppendA(lpszPath1, lpszPath2);
     37}
     38
     39/*************************************************************************
     40 * PathCombineAW    [SHELL32.37]
    4041 */
    4142LPVOID WINAPI PathCombineAW(
    42         LPVOID szDest,
    43         LPCVOID lpszDir,
    44         LPCVOID lpszFile)
    45 {
    46         if (SHELL_OsIsUnicode())
    47           return PathCombineW( szDest, lpszDir, lpszFile );
    48         return PathCombineA( szDest, lpszDir, lpszFile );
    49 }
    50 
    51 /*************************************************************************
    52  * PathAddBackslashAW           [SHELL32.32]
     43    LPVOID szDest,
     44    LPCVOID lpszDir,
     45    LPCVOID lpszFile)
     46{
     47    if (SHELL_OsIsUnicode())
     48      return PathCombineW( szDest, lpszDir, lpszFile );
     49    return PathCombineA( szDest, lpszDir, lpszFile );
     50}
     51
     52/*************************************************************************
     53 * PathAddBackslashAW       [SHELL32.32]
    5354 */
    5455LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
    5556{
    56         if(SHELL_OsIsUnicode())
    57           return PathAddBackslashW(lpszPath);
    58         return PathAddBackslashA(lpszPath);
    59 }
    60 
    61 /*************************************************************************
    62  * PathBuildRootAW              [SHELL32.30]
     57    if(SHELL_OsIsUnicode())
     58      return PathAddBackslashW(lpszPath);
     59    return PathAddBackslashA(lpszPath);
     60}
     61
     62/*************************************************************************
     63 * PathBuildRootAW      [SHELL32.30]
    6364 */
    6465LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
    6566{
    66         if(SHELL_OsIsUnicode())
    67           return PathBuildRootW(lpszPath, drive);
    68         return PathBuildRootA(lpszPath, drive);
     67    if(SHELL_OsIsUnicode())
     68      return PathBuildRootW(lpszPath, drive);
     69    return PathBuildRootA(lpszPath, drive);
    6970}
    7071
    7172/*
    72         Extracting Component Parts
     73    Extracting Component Parts
    7374*/
    7475
    7576/*************************************************************************
    76  * PathFindFileNameAW   [SHELL32.34]
     77 * PathFindFileNameAW   [SHELL32.34]
    7778 */
    7879LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
    7980{
    80         if(SHELL_OsIsUnicode())
    81           return PathFindFileNameW(lpszPath);
    82         return PathFindFileNameA(lpszPath);
    83 }
    84 
    85 /*************************************************************************
    86  * PathFindExtensionAW          [SHELL32.31]
    87  */
    88 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath) 
    89 {
    90         if (SHELL_OsIsUnicode())
    91           return PathFindExtensionW(lpszPath);
    92         return PathFindExtensionA(lpszPath);
    93 
    94 }
    95 
    96 /*************************************************************************
    97  * PathGetExtensionA            [internal]
     81    if(SHELL_OsIsUnicode())
     82      return PathFindFileNameW(lpszPath);
     83    return PathFindFileNameA(lpszPath);
     84}
     85
     86/*************************************************************************
     87 * PathFindExtensionAW      [SHELL32.31]
     88 */
     89LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
     90{
     91    if (SHELL_OsIsUnicode())
     92      return PathFindExtensionW(lpszPath);
     93    return PathFindExtensionA(lpszPath);
     94
     95}
     96
     97/*************************************************************************
     98 * PathGetExtensionA        [internal]
    9899 *
    99100 * NOTES
    … …  
    103104static LPSTR PathGetExtensionA(LPCSTR lpszPath)
    104105{
    105         TRACE("(%s)\n",lpszPath);
    106 
    107         lpszPath = PathFindExtensionA(lpszPath);
    108         return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
    109 }
    110 
    111 /*************************************************************************
    112  * PathGetExtensionW            [internal]
     106    TRACE("(%s)\n",lpszPath);
     107
     108    lpszPath = PathFindExtensionA(lpszPath);
     109    return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
     110}
     111
     112/*************************************************************************
     113 * PathGetExtensionW        [internal]
    113114 */
    114115static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
    115116{
    116         TRACE("(%s)\n",debugstr_w(lpszPath));
    117 
    118         lpszPath = PathFindExtensionW(lpszPath);
    119         return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
    120 }
    121 
    122 /*************************************************************************
    123  * PathGetExtensionAW           [SHELL32.158]
    124  */
    125 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath) 
    126 {
    127         if (SHELL_OsIsUnicode())
    128           return PathGetExtensionW(lpszPath);
    129         return PathGetExtensionA(lpszPath);
    130 }
    131 
    132 /*************************************************************************
    133  * PathGetArgsAW        [SHELL32.52]
    134  */
    135 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath) 
    136 {
    137         if (SHELL_OsIsUnicode())
    138           return PathGetArgsW(lpszPath);
    139         return PathGetArgsA(lpszPath);
    140 }
    141 
    142 /*************************************************************************
    143  * PathGetDriveNumber   [SHELL32.57]
    144  */
    145 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath) 
    146 {
    147         if (SHELL_OsIsUnicode())
    148           return PathGetDriveNumberW(lpszPath);
    149         return PathGetDriveNumberA(lpszPath);
     117    TRACE("(%s)\n",debugstr_w(lpszPath));
     118
     119    lpszPath = PathFindExtensionW(lpszPath);
     120    return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
     121}
     122
     123/*************************************************************************
     124 * PathGetExtensionAW       [SHELL32.158]
     125 */
     126LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath)
     127{
     128    if (SHELL_OsIsUnicode())
     129      return PathGetExtensionW(lpszPath);
     130    return PathGetExtensionA(lpszPath);
     131}
     132
     133/*************************************************************************
     134 * PathGetArgsAW    [SHELL32.52]
     135 */
     136LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath)
     137{
     138    if (SHELL_OsIsUnicode())
     139      return PathGetArgsW(lpszPath);
     140    return PathGetArgsA(lpszPath);
     141}
     142
     143/*************************************************************************
     144 * PathGetDriveNumber   [SHELL32.57]
     145 */
     146int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
     147{
     148    if (SHELL_OsIsUnicode())
     149      return PathGetDriveNumberW(lpszPath);
     150    return PathGetDriveNumberA(lpszPath);
    150151}
    151152
    … …  
    153154 * PathRemoveFileSpec [SHELL32.35]
    154155 */
    155 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath) 
    156 {
    157         if (SHELL_OsIsUnicode())
    158           return PathRemoveFileSpecW(lpszPath);
    159         return PathRemoveFileSpecA(lpszPath);
    160 }
    161 
    162 /*************************************************************************
    163  * PathStripPathAW      [SHELL32.38]
    164  */
    165 void WINAPI PathStripPathAW(LPVOID lpszPath) 
    166 {
    167         if (SHELL_OsIsUnicode())
    168           return PathStripPathW(lpszPath);
    169         return PathStripPathA(lpszPath);
    170 }
    171 
    172 /*************************************************************************
    173  * PathStripToRootAW    [SHELL32.50]
    174  */
    175 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath) 
    176 {
    177         if (SHELL_OsIsUnicode())
    178           return PathStripToRootW(lpszPath);
    179         return PathStripToRootA(lpszPath);
    180 }
    181 
    182 /*************************************************************************
    183  * PathRemoveArgsAW     [SHELL32.251]
    184  */
    185 void WINAPI PathRemoveArgsAW(LPVOID lpszPath) 
    186 {
    187         if (SHELL_OsIsUnicode())
    188           PathRemoveArgsW(lpszPath);
    189         PathRemoveArgsA(lpszPath);
    190 }
    191 
    192 /*************************************************************************
    193  * PathRemoveExtensionAW        [SHELL32.250]
    194  */
    195 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath) 
    196 {
    197         if (SHELL_OsIsUnicode())
    198           return PathRemoveExtensionW(lpszPath);
    199         return PathRemoveExtensionA(lpszPath);
     156BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
     157{
     158    if (SHELL_OsIsUnicode())
     159      return PathRemoveFileSpecW(lpszPath);
     160    return PathRemoveFileSpecA(lpszPath);
     161}
     162
     163/*************************************************************************
     164 * PathStripPathAW  [SHELL32.38]
     165 */
     166void WINAPI PathStripPathAW(LPVOID lpszPath)
     167{
     168    if (SHELL_OsIsUnicode())
     169      return PathStripPathW(lpszPath);
     170    return PathStripPathA(lpszPath);
     171}
     172
     173/*************************************************************************
     174 * PathStripToRootAW    [SHELL32.50]
     175 */
     176BOOL WINAPI PathStripToRootAW(LPVOID lpszPath)
     177{
     178    if (SHELL_OsIsUnicode())
     179      return PathStripToRootW(lpszPath);
     180    return PathStripToRootA(lpszPath);
     181}
     182
     183/*************************************************************************
     184 * PathRemoveArgsAW [SHELL32.251]
     185 */
     186void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
     187{
     188    if (SHELL_OsIsUnicode())
     189      PathRemoveArgsW(lpszPath);
     190    PathRemoveArgsA(lpszPath);
     191}
     192
     193/*************************************************************************
     194 * PathRemoveExtensionAW    [SHELL32.250]
     195 */
     196void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
     197{
     198    if (SHELL_OsIsUnicode())
     199      return PathRemoveExtensionW(lpszPath);
     200    return PathRemoveExtensionA(lpszPath);
    200201}
    201202
    202203
    203204/*
    204         Path Manipulations
     205    Path Manipulations
    205206*/
    206207
    … …  
    210211LPSTR WINAPI PathGetShortPathA(LPSTR lpszPath)
    211212{
    212         FIXME("%s stub\n", lpszPath);
    213         return NULL;
     213    FIXME("%s stub\n", lpszPath);
     214    return NULL;
    214215}
    215216
    … …  
    219220LPWSTR WINAPI PathGetShortPathW(LPWSTR lpszPath)
    220221{
    221         FIXME("%s stub\n", debugstr_w(lpszPath));
    222         return NULL;
     222    FIXME("%s stub\n", debugstr_w(lpszPath));
     223    return NULL;
    223224}
    224225
    … …  
    228229LPVOID WINAPI PathGetShortPathAW(LPVOID lpszPath)
    229230{
    230         if(SHELL_OsIsUnicode())
    231           return PathGetShortPathW(lpszPath);
    232         return PathGetShortPathA(lpszPath);
     231    if(SHELL_OsIsUnicode())
     232      return PathGetShortPathW(lpszPath);
     233    return PathGetShortPathA(lpszPath);
    233234}
    234235
    … …  
    238239void WINAPI PathRemoveBlanksAW(LPVOID str)
    239240{
    240         if(SHELL_OsIsUnicode())
    241           PathRemoveBlanksW(str);
    242         PathRemoveBlanksA(str);
     241    if(SHELL_OsIsUnicode())
     242      PathRemoveBlanksW(str);
     243    PathRemoveBlanksA(str);
    243244}
    244245
    … …  
    248249LPVOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
    249250{
    250         if(SHELL_OsIsUnicode())
    251           return PathQuoteSpacesW(lpszPath);
    252         return PathQuoteSpacesA(lpszPath);
     251    if(SHELL_OsIsUnicode())
     252      return PathQuoteSpacesW(lpszPath);
     253    return PathQuoteSpacesA(lpszPath);
    253254}
    254255
    … …  
    256257 * PathUnquoteSpacesAW [SHELL32.56]
    257258 */
    258 VOID WINAPI PathUnquoteSpacesAW(LPVOID str) 
    259 {
    260         if(SHELL_OsIsUnicode())
    261           PathUnquoteSpacesW(str);
    262         else
    263           PathUnquoteSpacesA(str);
    264 }
    265 
    266 /*************************************************************************
    267  * PathParseIconLocationAW      [SHELL32.249]
     259VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
     260{
     261    if(SHELL_OsIsUnicode())
     262      PathUnquoteSpacesW(str);
     263    else
     264      PathUnquoteSpacesA(str);
     265}
     266
     267/*************************************************************************
     268 * PathParseIconLocationAW  [SHELL32.249]
    268269 */
    269270int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
    270271{
    271         if(SHELL_OsIsUnicode())
    272           return PathParseIconLocationW(lpszPath);
    273         return PathParseIconLocationA(lpszPath);
     272    if(SHELL_OsIsUnicode())
     273      return PathParseIconLocationW(lpszPath);
     274    return PathParseIconLocationA(lpszPath);
    274275}
    275276
    276277/*
    277         ########## Path Testing ##########
     278    ########## Path Testing ##########
    278279*/
    279280/*************************************************************************
    280  * PathIsUNCAW          [SHELL32.39]
     281 * PathIsUNCAW      [SHELL32.39]
    281282 */
    282283BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
    283284{
    284         if (SHELL_OsIsUnicode())
    285           return PathIsUNCW( lpszPath );
    286         return PathIsUNCA( lpszPath ); 
    287 }
    288 
    289 /*************************************************************************
    290  *  PathIsRelativeAW    [SHELL32.40]
     285    if (SHELL_OsIsUnicode())
     286      return PathIsUNCW( lpszPath );
     287    return PathIsUNCA( lpszPath );
     288}
     289
     290/*************************************************************************
     291 *  PathIsRelativeAW    [SHELL32.40]
    291292 */
    292293BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
    293294{
    294         if (SHELL_OsIsUnicode())
    295           return PathIsRelativeW( lpszPath );
    296         return PathIsRelativeA( lpszPath ); 
    297 }
    298 
    299 /*************************************************************************
    300  * PathIsRootAW         [SHELL32.29]
    301  */
    302 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath) 
    303 {
    304         if (SHELL_OsIsUnicode())
    305           return PathIsRootW(lpszPath);
    306         return PathIsRootA(lpszPath);
    307 }
    308 
    309 /*************************************************************************
    310  *  PathIsExeA          [internal]
     295    if (SHELL_OsIsUnicode())
     296      return PathIsRelativeW( lpszPath );
     297    return PathIsRelativeA( lpszPath );
     298}
     299
     300/*************************************************************************
     301 * PathIsRootAW     [SHELL32.29]
     302 */
     303BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
     304{
     305    if (SHELL_OsIsUnicode())
     306      return PathIsRootW(lpszPath);
     307    return PathIsRootA(lpszPath);
     308}
     309
     310/*************************************************************************
     311 *  PathIsExeA      [internal]
    311312 */
    312313static BOOL PathIsExeA (LPCSTR lpszPath)
    313314{
    314         LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
    315         int i = 0;
    316         static char * lpszExtensions[6] = {"exe", "com", "pid", "cmd", "bat", NULL };
    317        
    318         TRACE("path=%s\n",lpszPath);
    319 
    320         for(i=0; lpszExtensions[i]; i++)
    321           if (!strcasecmp(lpszExtension,lpszExtensions[i])) return TRUE;
    322          
    323         return FALSE;
    324 }
    325 
    326 /*************************************************************************
    327  *  PathIsExeW          [internal]
     315    LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
     316    int i = 0;
     317    static char * lpszExtensions[6] = {"exe", "com", "pid", "cmd", "bat", NULL };
     318
     319    TRACE("path=%s\n",lpszPath);
     320
     321    for(i=0; lpszExtensions[i]; i++)
     322      if (!strcasecmp(lpszExtension,lpszExtensions[i])) return TRUE;
     323
     324    return FALSE;
     325}
     326
     327/*************************************************************************
     328 *  PathIsExeW      [internal]
    328329 */
    329330static BOOL PathIsExeW (LPCWSTR lpszPath)
    330331{
    331         LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
    332         int i = 0;
    333         static WCHAR lpszExtensions[6][4] =
    334           {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','d','\0'},
    335            {'c','m','d','\0'}, {'b','a','t','\0'}, {'\0'} };
    336        
    337         TRACE("path=%s\n",debugstr_w(lpszPath));
    338 
    339         for(i=0; lpszExtensions[i]; i++)
     332    LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
     333    int i = 0;
     334    static WCHAR lpszExtensions[6][4] =
     335      {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','d','\0'},
     336       {'c','m','d','\0'}, {'b','a','t','\0'}, {'\0'} };
     337
     338    TRACE("path=%s\n",debugstr_w(lpszPath));
     339
     340    for(i=0; lpszExtensions[i]; i++)
    340341#ifdef __WIN32OS2__
    341           if (!lstrcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
     342      if (!lstrcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
    342343#else
    343           if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
    344 #endif   
    345         return FALSE;
    346 }
    347 
    348 /*************************************************************************
    349  *  PathIsExeAW         [SHELL32.43]
     344      if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
     345#endif
     346    return FALSE;
     347}
     348
     349/*************************************************************************
     350 *  PathIsExeAW     [SHELL32.43]
    350351 */
    351352BOOL WINAPI PathIsExeAW (LPCVOID path)
    352353{
    353         if (SHELL_OsIsUnicode())
    354           return PathIsExeW (path);
    355         return PathIsExeA(path);
    356 }
    357 
    358 /*************************************************************************
    359  * PathIsDirectoryAW    [SHELL32.159]
     354    if (SHELL_OsIsUnicode())
     355      return PathIsExeW (path);
     356    return PathIsExeA(path);
     357}
     358
     359/*************************************************************************
     360 * PathIsDirectoryAW    [SHELL32.159]
    360361 */
    361362BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
    362363{
    363         if (SHELL_OsIsUnicode())
    364           return PathIsDirectoryW (lpszPath);
    365         return PathIsDirectoryA (lpszPath);
    366 }
    367 
    368 /*************************************************************************
    369  * PathFileExistsAW     [SHELL32.45]
    370  */ 
     364    if (SHELL_OsIsUnicode())
     365      return PathIsDirectoryW (lpszPath);
     366    return PathIsDirectoryA (lpszPath);
     367}
     368
     369/*************************************************************************
     370 * PathFileExistsAW [SHELL32.45]
     371 */
    371372BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
    372373{
    373         if (SHELL_OsIsUnicode())
    374           return PathFileExistsW (lpszPath);
    375         return PathFileExistsA (lpszPath);
    376 }
    377 
    378 /*************************************************************************
    379  * PathMatchSpecAW      [SHELL32.46]
    380  */
    381 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask) 
    382 {
    383         if (SHELL_OsIsUnicode())
    384           return PathMatchSpecW( name, mask );
    385         return PathMatchSpecA( name, mask );
    386 }
    387 
    388 /*************************************************************************
    389  * PathIsSameRootAW     [SHELL32.650]
     374    if (SHELL_OsIsUnicode())
     375      return PathFileExistsW (lpszPath);
     376    return PathFileExistsA (lpszPath);
     377}
     378
     379/*************************************************************************
     380 * PathMatchSpecAW  [SHELL32.46]
     381 */
     382BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask)
     383{
     384    if (SHELL_OsIsUnicode())
     385      return PathMatchSpecW( name, mask );
     386    return PathMatchSpecA( name, mask );
     387}
     388
     389/*************************************************************************
     390 * PathIsSameRootAW [SHELL32.650]
    390391 */
    391392BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
    392393{
    393         if (SHELL_OsIsUnicode())
    394           return PathIsSameRootW(lpszPath1, lpszPath2);
    395         return PathIsSameRootA(lpszPath1, lpszPath2);
    396 }
    397 
    398 /*************************************************************************
    399  * IsLFNDriveA          [SHELL32.119]
    400  * 
     394    if (SHELL_OsIsUnicode())
     395      return PathIsSameRootW(lpszPath1, lpszPath2);
     396    return PathIsSameRootA(lpszPath1, lpszPath2);
     397}
     398
     399/*************************************************************************
     400 * IsLFNDriveA      [SHELL32.119]
     401 *
    401402 * NOTES
    402403 *     exported by ordinal Name
    403404 */
    404 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath) 
    405 {
    406     DWORD       fnlen;
     405BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
     406{
     407    DWORD   fnlen;
    407408
    408409    if (!GetVolumeInformationA(lpszPath,NULL,0,NULL,&fnlen,NULL,NULL,0))
    409         return FALSE;
     410    return FALSE;
    410411    return fnlen>12;
    411412}
    412413
    413414/*
    414         ########## Creating Something Unique ##########
     415    ########## Creating Something Unique ##########
    415416*/
    416417/*************************************************************************
    417  * PathMakeUniqueNameA  [internal]
     418 * PathMakeUniqueNameA  [internal]
    418419 */
    419420BOOL WINAPI PathMakeUniqueNameA(
    420         LPSTR lpszBuffer,
    421         DWORD dwBuffSize,
    422         LPCSTR lpszShortName,
    423         LPCSTR lpszLongName,
    424         LPCSTR lpszPathName)
    425 {
    426         FIXME("%p %lu %s %s %s stub\n",
    427         lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
    428         debugstr_a(lpszLongName), debugstr_a(lpszPathName));
    429         return TRUE;
    430 }
    431 
    432 /*************************************************************************
    433  * PathMakeUniqueNameW  [internal]
     421    LPSTR lpszBuffer,
     422    DWORD dwBuffSize,
     423    LPCSTR lpszShortName,
     424    LPCSTR lpszLongName,
     425    LPCSTR lpszPathName)
     426{
     427    FIXME("%p %lu %s %s %s stub\n",
     428    lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
     429    debugstr_a(lpszLongName), debugstr_a(lpszPathName));
     430    return TRUE;
     431}
     432
     433/*************************************************************************
     434 * PathMakeUniqueNameW  [internal]
    434435 */
    435436BOOL WINAPI PathMakeUniqueNameW(
    436         LPWSTR lpszBuffer,
    437         DWORD dwBuffSize,
    438         LPCWSTR lpszShortName,
    439         LPCWSTR lpszLongName,
    440         LPCWSTR lpszPathName)
    441 {
    442         FIXME("%p %lu %s %s %s stub\n",
    443         lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
    444         debugstr_w(lpszLongName), debugstr_w(lpszPathName));
    445         return TRUE;
    446 }
    447 
    448 /*************************************************************************
    449  * PathMakeUniqueNameAW [SHELL32.47]
     437    LPWSTR lpszBuffer,
     438    DWORD dwBuffSize,
     439    LPCWSTR lpszShortName,
     440    LPCWSTR lpszLongName,
     441    LPCWSTR lpszPathName)
     442{
     443    FIXME("%p %lu %s %s %s stub\n",
     444    lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
     445    debugstr_w(lpszLongName), debugstr_w(lpszPathName));
     446    return TRUE;
     447}
     448
     449/*************************************************************************
     450 * PathMakeUniqueNameAW [SHELL32.47]
    450451 */
    451452BOOL WINAPI PathMakeUniqueNameAW(
    452         LPVOID lpszBuffer,
    453         DWORD dwBuffSize,
    454         LPCVOID lpszShortName,
    455         LPCVOID lpszLongName,
    456         LPCVOID lpszPathName)
    457 {
    458         if (SHELL_OsIsUnicode())
    459           return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
    460         return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
     453    LPVOID lpszBuffer,
     454    DWORD dwBuffSize,
     455    LPCVOID lpszShortName,
     456    LPCVOID lpszLongName,
     457    LPCVOID lpszPathName)
     458{
     459    if (SHELL_OsIsUnicode())
     460      return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
     461    return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
    461462}
    462463
    463464/*************************************************************************
    464465 * PathYetAnotherMakeUniqueNameA [SHELL32.75]
    465  * 
     466 *
    466467 * NOTES
    467468 *     exported by ordinal
    468469 */
    469470BOOL WINAPI PathYetAnotherMakeUniqueNameA(
    470         LPSTR lpszBuffer,
    471         LPCSTR lpszPathName,
    472         LPCSTR lpszShortName,
    473         LPCSTR lpszLongName)
     471    LPSTR lpszBuffer,
     472    LPCSTR lpszPathName,
     473    LPCSTR lpszShortName,
     474    LPCSTR lpszLongName)
    474475{
    475476    FIXME("(%p,%p, %p ,%p):stub.\n",
    … …  
    481482
    482483BOOL WINAPI PathYetAnotherMakeUniqueNameW(
    483         LPWSTR lpszBuffer,
    484         LPCWSTR lpszPathName,
    485         LPCWSTR lpszShortName,
    486         LPCWSTR lpszLongName)
     484    LPWSTR lpszBuffer,
     485    LPCWSTR lpszPathName,
     486    LPCWSTR lpszShortName,
     487    LPCWSTR lpszLongName)
    487488{
    488489    FIXME("PathYetAnotherMakeUniqueNameW (%p,%p, %p ,%p):stub.\n",
    … …  
    492493
    493494BOOL WINAPI PathYetAnotherMakeUniqueNameAW(
    494         LPSTR lpszBuffer,
    495         LPCSTR lpszPathName,
    496         LPCSTR lpszShortName,
    497         LPCSTR lpszLongName)
    498 {
    499         if (SHELL_OsIsUnicode())
    500           return PathYetAnotherMakeUniqueNameW((LPWSTR)lpszBuffer,(LPCWSTR)lpszPathName, (LPCWSTR)lpszShortName,(LPCWSTR)lpszLongName);
    501         return PathYetAnotherMakeUniqueNameA(lpszBuffer, lpszPathName, lpszShortName,lpszLongName);
     495    LPSTR lpszBuffer,
     496    LPCSTR lpszPathName,
     497    LPCSTR lpszShortName,
     498    LPCSTR lpszLongName)
     499{
     500    if (SHELL_OsIsUnicode())
     501      return PathYetAnotherMakeUniqueNameW((LPWSTR)lpszBuffer,(LPCWSTR)lpszPathName, (LPCWSTR)lpszShortName,(LPCWSTR)lpszLongName);
     502    return PathYetAnotherMakeUniqueNameA(lpszBuffer, lpszPathName, lpszShortName,lpszLongName);
    502503}
    503504#endif
    … …  
    505506
    506507/*
    507         ########## cleaning and resolving paths ##########
    508  */
    509 
    510 /*************************************************************************
    511  * PathFindOnPathAW     [SHELL32]
     508    ########## cleaning and resolving paths ##########
     509 */
     510
     511/*************************************************************************
     512 * PathFindOnPathAW [SHELL32]
    512513 */
    513514BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID sOtherDirs)
    514515{
    515         if (SHELL_OsIsUnicode())
    516           return PathFindOnPathW(sFile, sOtherDirs);
    517         return PathFindOnPathA(sFile, sOtherDirs);
    518 }
    519 
    520 /*************************************************************************
    521  * PathCleanupSpecAW    [SHELL32]
     516    if (SHELL_OsIsUnicode())
     517      return PathFindOnPathW(sFile, sOtherDirs);
     518    return PathFindOnPathA(sFile, sOtherDirs);
     519}
     520
     521/*************************************************************************
     522 * PathCleanupSpecAW    [SHELL32]
    522523 */
    523524DWORD WINAPI PathCleanupSpecAW (LPCVOID x, LPVOID y)
    … …  
    528529
    529530/*************************************************************************
    530  * PathQualifyA         [SHELL32]
    531  */
    532 BOOL WINAPI PathQualifyA(LPCSTR pszPath) 
    533 {
    534         FIXME("%s\n",pszPath);
    535         return 0;
    536 }
    537 
    538 /*************************************************************************
    539  * PathQualifyW         [SHELL32]
    540  */
    541 BOOL WINAPI PathQualifyW(LPCWSTR pszPath) 
    542 {
    543         FIXME("%s\n",debugstr_w(pszPath));
    544         return 0;
    545 }
    546 
    547 /*************************************************************************
    548  * PathQualifyAW        [SHELL32]
    549  */
    550 BOOL WINAPI PathQualifyAW(LPCVOID pszPath) 
    551 {
    552         if (SHELL_OsIsUnicode())
    553           return PathQualifyW(pszPath);
    554         return PathQualifyA(pszPath);
     531 * PathQualifyA     [SHELL32]
     532 */
     533BOOL WINAPI PathQualifyA(LPCSTR pszPath)
     534{
     535    FIXME("%s\n",pszPath);
     536    return 0;
     537}
     538
     539/*************************************************************************
     540 * PathQualifyW     [SHELL32]
     541 */
     542BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
     543{
     544    FIXME("%s\n",debugstr_w(pszPath));
     545    return 0;
     546}
     547
     548/*************************************************************************
     549 * PathQualifyAW    [SHELL32]
     550 */
     551BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
     552{
     553    if (SHELL_OsIsUnicode())
     554      return PathQualifyW(pszPath);
     555    return PathQualifyA(pszPath);
    555556}
    556557
    … …  
    559560 */
    560561BOOL WINAPI PathResolveA(
    561         LPSTR lpszPath,
    562         LPCSTR *alpszPaths,
    563         DWORD dwFlags)
    564 {
    565         FIXME("(%s,%p,0x%08lx),stub!\n",
    566           lpszPath, *alpszPaths, dwFlags);
    567         return 0;
     562    LPSTR lpszPath,
     563    LPCSTR *alpszPaths,
     564    DWORD dwFlags)
     565{
     566    FIXME("(%s,%p,0x%08lx),stub!\n",
     567      lpszPath, *alpszPaths, dwFlags);
     568    return 0;
    568569}
    569570
    … …  
    572573 */
    573574BOOL WINAPI PathResolveW(
    574         LPWSTR lpszPath,
    575         LPCWSTR *alpszPaths,
    576         DWORD dwFlags)
    577 {
    578         FIXME("(%s,%p,0x%08lx),stub!\n",
    579           debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
    580         return 0;
     575    LPWSTR lpszPath,
     576    LPCWSTR *alpszPaths,
     577    DWORD dwFlags)
     578{
     579    FIXME("(%s,%p,0x%08lx),stub!\n",
     580      debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
     581    return 0;
    581582}
    582583
    … …  
    585586 */
    586587BOOL WINAPI PathResolveAW(
    587         LPVOID lpszPath,
    588         LPCVOID *alpszPaths,
    589         DWORD dwFlags)
    590 {
    591         if (SHELL_OsIsUnicode())
    592           return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
    593         return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
    594 }
    595 
    596 /*************************************************************************
    597 *       PathProcessCommandA     [SHELL32.653]
     588    LPVOID lpszPath,
     589    LPCVOID *alpszPaths,
     590    DWORD dwFlags)
     591{
     592    if (SHELL_OsIsUnicode())
     593      return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
     594    return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
     595}
     596
     597/*************************************************************************
     598*   PathProcessCommandA [SHELL32.653]
    598599*/
    599600HRESULT WINAPI PathProcessCommandA (
    600         LPCSTR lpszPath,
    601         LPSTR lpszBuff,
    602         DWORD dwBuffSize,
    603         DWORD dwFlags)
    604 {
    605         FIXME("%s %p 0x%04lx 0x%04lx stub\n",
    606         lpszPath, lpszBuff, dwBuffSize, dwFlags);
    607         strcpy(lpszBuff, lpszPath);
    608         return 0;
    609 }
    610 
    611 /*************************************************************************
    612 *       PathProcessCommandW
     601    LPCSTR lpszPath,
     602    LPSTR lpszBuff,
     603    DWORD dwBuffSize,
     604    DWORD dwFlags)
     605{
     606    FIXME("%s %p 0x%04lx 0x%04lx stub\n",
     607    lpszPath, lpszBuff, dwBuffSize, dwFlags);
     608    strcpy(lpszBuff, lpszPath);
     609    return 0;
     610}
     611
     612/*************************************************************************
     613*   PathProcessCommandW
    613614*/
    614615HRESULT WINAPI PathProcessCommandW (
    615         LPCWSTR lpszPath,
    616         LPWSTR lpszBuff,
    617         DWORD dwBuffSize,
    618         DWORD dwFlags)
    619 {
    620         FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n",
    621         debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
    622         strcpyW(lpszBuff, lpszPath);
    623         return 0;
    624 }
    625 
    626 /*************************************************************************
    627 *       PathProcessCommandAW
     616    LPCWSTR lpszPath,
     617    LPWSTR lpszBuff,
     618    DWORD dwBuffSize,
     619    DWORD dwFlags)
     620{
     621    FIXME("(%s, %p, 0x%04lx, 0x%04lx) stub\n",
     622    debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
     623    strcpyW(lpszBuff, lpszPath);
     624    return 0;
     625}
     626
     627/*************************************************************************
     628*   PathProcessCommandAW
    628629*/
    629630HRESULT WINAPI PathProcessCommandAW (
    630         LPCVOID lpszPath,
    631         LPVOID lpszBuff,
    632         DWORD dwBuffSize,
    633         DWORD dwFlags)
    634 {
    635         if (SHELL_OsIsUnicode())
    636           return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
    637         return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
     631    LPCVOID lpszPath,
     632    LPVOID lpszBuff,
     633    DWORD dwBuffSize,
     634    DWORD dwFlags)
     635{
     636    if (SHELL_OsIsUnicode())
     637      return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
     638    return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
    638639}
    639640
    640641/*
    641         ########## special ##########
     642    ########## special ##########
    642643*/
    643644
    … …  
    645646 * PathSetDlgItemPathAW
    646647 */
    647 BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath) 
    648 {       if (SHELL_OsIsUnicode())
    649           return PathSetDlgItemPathW(hDlg, id, pszPath);
    650         return PathSetDlgItemPathA(hDlg, id, pszPath);
     648BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
     649{   if (SHELL_OsIsUnicode())
     650      return PathSetDlgItemPathW(hDlg, id, pszPath);
     651    return PathSetDlgItemPathA(hDlg, id, pszPath);
    651652}
    652653
    … …  
    654655/*************************************************************************
    655656 * SHGetSpecialFolderPathA [SHELL32.175]
    656  * 
     657 *
    657658 * converts csidl to path
    658659 */
    659  
     660
    660661static const char * const szSHFolders = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders";
    661662static const char * const szSHUserFolders = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
    … …  
    675676} CSIDL_DATA;
    676677
    677 #define CSIDL_MYFLAG_SHFOLDER   1
    678 #define CSIDL_MYFLAG_SETUP      2
    679 #define CSIDL_MYFLAG_CURRVER    4
    680 #define CSIDL_MYFLAG_RELATIVE   8
     678#define CSIDL_MYFLAG_SHFOLDER   1
     679#define CSIDL_MYFLAG_SETUP  2
     680#define CSIDL_MYFLAG_CURRVER    4
     681#define CSIDL_MYFLAG_RELATIVE   8
    681682
    682683#define HKLM HKEY_LOCAL_MACHINE
    … …  
    685686{
    686687    { /* CSIDL_DESKTOP */
    687         9, HKCU,
    688         "Desktop",
    689         "Desktop"
     688    9, HKCU,
     689    "Desktop",
     690    "Desktop"
    690691    },
    691692    { /* CSIDL_INTERNET (??) */
    692         0, 1, /* FIXME */
    693         NULL,
    694         NULL,
     693    0, 1, /* FIXME */
     694    NULL,
     695    NULL,
    695696    },
    696697    { /* CSIDL_PROGRAMS */
    697         9, HKCU,
    698         "Programs",
    699         "Start Menu\\Programs"
     698    9, HKCU,
     699    "Programs",
     700    "Start Menu\\Programs"
    700701    },
    701702    { /* CSIDL_CONTROLS (.CPL files) */
    702         10, HKLM,
    703         "SysDir",
    704         "SYSTEM"
     703    10, HKLM,
     704    "SysDir",
     705    "SYSTEM"
    705706    },
    706707    { /* CSIDL_PRINTERS */
    707         10, HKLM,
    708         "SysDir",
    709         "SYSTEM"
     708    10, HKLM,
     709    "SysDir",
     710    "SYSTEM"
    710711    },
    711712    { /* CSIDL_PERSONAL */
    712         1, HKCU,
    713         "Personal",
    714         "My Documents"
     713    1, HKCU,
     714    "Personal",
     715    "My Documents"
    715716    },
    716717    { /* CSIDL_FAVORITES */
    717         9, HKCU,
    718         "Favorites",
    719         "Favorites"
     718    9, HKCU,
     719    "Favorites",
     720    "Favorites"
    720721    },
    721722    { /* CSIDL_STARTUP */
    722         9, HKCU,
    723         "StartUp",
    724         "Start Menu\\Programs\\StartUp"
     723    9, HKCU,
     724    "StartUp",
     725    "Start Menu\\Programs\\StartUp"
    725726    },
    726727    { /* CSIDL_RECENT */
    727         9, HKCU,
    728         "Recent",
    729         "Recent"
     728    9, HKCU,
     729    "Recent",
     730    "Recent"
    730731    },
    731732    { /* CSIDL_SENDTO */
    732         9, HKCU,
    733         "SendTo",
    734         "SendTo"
     733    9, HKCU,
     734    "SendTo",
     735    "SendTo"
    735736    },
    736737    { /* CSIDL_BITBUCKET (is this c:\recycled ?) */
    737         0, 1, /* FIXME */
    738         NULL,
    739         "recycled"
     738    0, 1, /* FIXME */
     739    NULL,
     740    "recycled"
    740741    },
    741742    { /* CSIDL_STARTMENU */
    742         9, HKCU,
    743         "Start Menu",
    744         "Start Menu"
     743    9, HKCU,
     744    "Start Menu",
     745    "Start Menu"
    745746    },
    746747    { /* not known */
    747         0, 0,
    748         NULL,
    749         NULL,
     748    0, 0,
     749    NULL,
     750    NULL,
    750751    },
    751752    { /* not known */
    752         0, 0,
    753         NULL,
    754         NULL,
     753    0, 0,
     754    NULL,
     755    NULL,
    755756    },
    756757    { /* not known */
    757         0, 0,
    758         NULL,
    759         NULL,
     758    0, 0,
     759    NULL,
     760    NULL,
    760761    },
    761762    { /* not known */
    762         0, 0,
    763         NULL,
    764         NULL,
     763    0, 0,
     764    NULL,
     765    NULL,
    765766    },
    766767    { /* CSIDL_DESKTOPDIRECTORY */
    767         9, HKCU,
    768         "Desktop",
    769         "Desktop"
     768    9, HKCU,
     769    "Desktop",
     770    "Desktop"
    770771    },
    771772    { /* CSIDL_DRIVES */
    772         0, 1, /* FIXME */
    773         NULL,
    774         "My Computer"
     773    0, 1, /* FIXME */
     774    NULL,
     775    "My Computer"
    775776    },
    776777    { /* CSIDL_NETWORK */
    777         0, 1, /* FIXME */
    778         NULL,
    779         "Network Neighborhood"
     778    0, 1, /* FIXME */
     779    NULL,
     780    "Network Neighborhood"
    780781    },
    781782    { /* CSIDL_NETHOOD */
    782         9, HKCU,
    783         "NetHood",
    784         "NetHood"
     783    9, HKCU,
     784    "NetHood",
     785    "NetHood"
    785786    },
    786787    { /* CSIDL_FONTS */
    787         9, HKCU,
    788         "Fonts",
    789         "Fonts"
     788    9, HKCU,
     789    "Fonts",
     790    "Fonts"
    790791    },
    791792    { /* CSIDL_TEMPLATES */
    792         9, HKCU,
    793         "Templates",
    794         "ShellNew"
     793    9, HKCU,
     794    "Templates",
     795    "ShellNew"
    795796    },
    796797    { /* CSIDL_COMMON_STARTMENU */
    797         9, HKLM,
    798         "Common Start Menu",
    799         "Start Menu"
     798    9, HKLM,
     799    "Common Start Menu",
     800    "Start Menu"
    800801    },
    801802    { /* CSIDL_COMMON_PROGRAMS */
    802         9, HKLM,
    803         "Common Programs",
    804         ""
     803    9, HKLM,
     804    "Common Programs",
     805    ""
    805806    },
    806807    { /* CSIDL_COMMON_STARTUP */
    807         9, HKLM,
    808         "Common StartUp",
    809         "All Users\\Start Menu\\Programs\\StartUp"
     808    9, HKLM,
     809    "Common StartUp",
     810    "All Users\\Start Menu\\Programs\\StartUp"
    810811    },
    811812    { /* CSIDL_COMMON_DESKTOPDIRECTORY */
    812         9, HKLM,
    813         "Common Desktop",
    814         "Desktop"
     813    9, HKLM,
     814    "Common Desktop",
     815    "Desktop"
    815816    },
    816817    { /* CSIDL_APPDATA */
    817         9, HKCU,
    818         "AppData",
    819         "Application Data"
     818    9, HKCU,
     819    "AppData",
     820    "Application Data"
    820821    },
    821822    { /* CSIDL_PRINTHOOD */
    822         9, HKCU,
    823         "PrintHood",
    824         "PrintHood"
     823    9, HKCU,
     824    "PrintHood",
     825    "PrintHood"
    825826    },
    826827    { /* not known */
    827         0, 0,
    828         NULL,
    829         NULL,
     828    0, 0,
     829    NULL,
     830    NULL,
    830831    },
    831832    { /* CSIDL_ALTSTARTUP */
    832         0, 1, /* FIXME */
    833         NULL,
    834         NULL
     833    0, 1, /* FIXME */
     834    NULL,
     835    NULL
    835836    },
    836837    { /* CSIDL_COMMON_ALTSTARTUP */
    837         0, 1, /* FIXME */
    838         NULL,
    839         NULL
     838    0, 1, /* FIXME */
     839    NULL,
     840    NULL
    840841    },
    841842    { /* CSIDL_COMMON_FAVORITES */
    842         9, HKCU,
    843         "Favorites",
    844         "Favorites"
     843    9, HKCU,
     844    "Favorites",
     845    "Favorites"
    845846    },
    846847    { /* CSIDL_INTERNET_CACHE */
    847         9, HKCU,
    848         "Cache",
    849         "Temporary Internet Files"
     848    9, HKCU,
     849    "Cache",
     850    "Temporary Internet Files"
    850851    },
    851852    { /* CSIDL_COOKIES */
    852         9, HKCU,
    853         "Cookies",
    854         "Cookies"
     853    9, HKCU,
     854    "Cookies",
     855    "Cookies"
    855856    },
    856857    { /* CSIDL_HISTORY */
    857         9, HKCU,
    858         "History",
    859         "History"
     858    9, HKCU,
     859    "History",
     860    "History"
    860861    },
    861862    { /* CSIDL_COMMON_APPDATA */
    862         9, HKLM,
    863         "Common AppData",
    864         "All Users\\Application Data"
     863    9, HKLM,
     864    "Common AppData",
     865    "All Users\\Application Data"
    865866    },
    866867    { /* CSIDL_WINDOWS */
    867         2, HKLM,
    868         "WinDir",
    869         "Windows"
     868    2, HKLM,
     869    "WinDir",
     870    "Windows"
    870871    },
    871872    { /* CSIDL_SYSTEM */
    872         10, HKLM,
    873         "SysDir",
    874         "SYSTEM"
     873    10, HKLM,
     874    "SysDir",
     875    "SYSTEM"
    875876    },
    876877    { /* CSIDL_PROGRAM_FILES */
    877         4, HKLM,
    878         "ProgramFilesDir",
    879         "Program Files"
     878    4, HKLM,
     879    "ProgramFilesDir",
     880    "Program Files"
    880881    },
    881882    { /* CSIDL_MYPICTURES */
    882         1, HKCU,
    883         "My Pictures",
    884         "My Documents\\My Pictures"
     883    1, HKCU,
     884    "My Pictures",
     885    "My Documents\\My Pictures"
    885886    },
    886887    { /* CSIDL_PROFILE */
    887         10, HKLM,
    888         "WinDir", /* correct ? */
    889         ""
     888    10, HKLM,
     889    "WinDir", /* correct ? */
     890    ""
    890891    },
    891892    { /* CSIDL_SYSTEMX86 */
    892         10, HKLM,
    893         "SysDir",
    894         "SYSTEM"
     893    10, HKLM,
     894    "SysDir",
     895    "SYSTEM"
    895896    },
    896897    { /* CSIDL_PROGRAM_FILESX86 */
    897         4, HKLM,
    898         "ProgramFilesDir",
    899         "Program Files"
     898    4, HKLM,
     899    "ProgramFilesDir",
     900    "Program Files"
    900901    },
    901902    { /* CSIDL_PROGRAM_FILES_COMMON */
    902         4, HKLM,
    903         "CommonFilesDir",
    904         "Program Files\\Common Files" /* ? */
     903    4, HKLM,
     904    "CommonFilesDir",
     905    "Program Files\\Common Files" /* ? */
    905906    },
    906907    { /* CSIDL_PROGRAM_FILES_COMMONX86 */
    907         4, HKLM,
    908         "CommonFilesDir",
    909         "Program Files\\Common Files" /* ? */
     908    4, HKLM,
     909    "CommonFilesDir",
     910    "Program Files\\Common Files" /* ? */
    910911    },
    911912    { /* CSIDL_COMMON_TEMPLATES */
    912         0, 1, /* FIXME */
    913         NULL,
    914         NULL
     913    0, 1, /* FIXME */
     914    NULL,
     915    NULL
    915916    },
    916917    { /* CSIDL_COMMON_DOCUMENTS */
    917         0, 1, /* FIXME */
    918         NULL,
    919         NULL
     918    0, 1, /* FIXME */
     919    NULL,
     920    NULL
    920921    },
    921922    { /* CSIDL_COMMON_ADMINTOOLS */
    922         0, 1, /* FIXME */
    923         NULL,
    924         NULL
     923    0, 1, /* FIXME */
     924    NULL,
     925    NULL
    925926    },
    926927    { /* CSIDL_ADMINTOOLS */
    927         9, HKCU,
    928         "Administrative Tools",
    929         "Start Menu\\Programs\\Administrative Tools"
     928    9, HKCU,
     929    "Administrative Tools",
     930    "Start Menu\\Programs\\Administrative Tools"
    930931    },
    931932    { /* CSIDL_CONNECTIONS */
    932         0, 1, /* FIXME */
    933         NULL,
    934         NULL
     933    0, 1, /* FIXME */
     934    NULL,
     935    NULL
    935936    }
    936937};
    … …  
    941942
    942943BOOL WINAPI SHGetSpecialFolderPathA (
    943         HWND hwndOwner,
    944         LPSTR szPath,
    945         DWORD csidl,
    946         BOOL bCreate)
    947 {
    948         CHAR    szValueName[MAX_PATH], szDefaultPath[MAX_PATH], szBuildPath[MAX_PATH];
    949         HKEY    hRootKey, hKey;
    950         DWORD   dwFlags;
    951         DWORD   dwType, dwDisp, dwPathLen = MAX_PATH;
    952         DWORD   folder = csidl & CSIDL_FOLDER_MASK;
    953         CHAR    *p;
    954 
    955         TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
    956 
    957         if ((folder > CSIDL_CONNECTIONS) || (CSIDL_Data[folder].hRootKey == 0))
    958         {
    959             ERR("folder unknown or not allowed\n");
    960             return FALSE;
    961         }
    962         if (CSIDL_Data[folder].hRootKey == 1)
    963         {
    964             FIXME("folder unknown, please add.\n");
    965             return FALSE;
    966         }
    967 
    968         dwFlags = CSIDL_Data[folder].dwFlags;
    969         hRootKey = CSIDL_Data[folder].hRootKey;
    970         strcpy(szValueName, CSIDL_Data[folder].szValueName);
    971         strcpy(szDefaultPath, CSIDL_Data[folder].szDefaultPath);
    972 
    973         if (dwFlags & CSIDL_MYFLAG_SHFOLDER)
    974         {
    975           /*   user shell folders */
    976           if   (RegCreateKeyExA(hRootKey,szSHUserFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
    977 
    978           if   (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
    979           {
    980             RegCloseKey(hKey);
    981 
    982             /* shell folders */
    983             if (RegCreateKeyExA(hRootKey,szSHFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
    984 
    985             if (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
    986             {
    987 
    988               /* value not existing */
    989               if (dwFlags & CSIDL_MYFLAG_RELATIVE)
    990               {
    991                 GetWindowsDirectoryA(szPath, MAX_PATH);
    992                 PathAddBackslashA(szPath);
    993                 strcat(szPath, szDefaultPath);
    994               }
    995               else
    996               {
    997                 strcpy(szPath, "C:\\"); /* FIXME ??? */
    998                 strcat(szPath, szDefaultPath);
    999               }
    1000               RegSetValueExA(hKey,szValueName,0,REG_SZ,(LPBYTE)szPath,strlen(szPath)+1);
    1001             }
    1002           }
    1003           RegCloseKey(hKey);
     944    HWND hwndOwner,
     945    LPSTR szPath,
     946    DWORD csidl,
     947    BOOL bCreate)
     948{
     949    CHAR    szValueName[MAX_PATH], szDefaultPath[MAX_PATH], szBuildPath[MAX_PATH];
     950    HKEY    hRootKey, hKey;
     951    DWORD   dwFlags;
     952    DWORD   dwType, dwDisp, dwPathLen = MAX_PATH;
     953    DWORD   folder = csidl & CSIDL_FOLDER_MASK;
     954    CHAR    *p;
     955
     956    TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
     957
     958    if ((folder > CSIDL_CONNECTIONS) || (CSIDL_Data[folder].hRootKey == 0))
     959    {
     960        ERR("folder unknown or not allowed\n");
     961        return FALSE;
     962    }
     963    if (CSIDL_Data[folder].hRootKey == 1)
     964    {
     965        FIXME("folder unknown, please add.\n");
     966        return FALSE;
     967    }
     968
     969    dwFlags = CSIDL_Data[folder].dwFlags;
     970    hRootKey = CSIDL_Data[folder].hRootKey;
     971    strcpy(szValueName, CSIDL_Data[folder].szValueName);
     972    strcpy(szDefaultPath, CSIDL_Data[folder].szDefaultPath);
     973
     974    if (dwFlags & CSIDL_MYFLAG_SHFOLDER)
     975    {
     976      /*   user shell folders */
     977      if   (RegCreateKeyExA(hRootKey,szSHUserFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
     978
     979      if   (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
     980      {
     981        RegCloseKey(hKey);
     982
     983        /* shell folders */
     984        if (RegCreateKeyExA(hRootKey,szSHFolders,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
     985
     986        if (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
     987        {
     988
     989          /* value not existing */
     990          if (dwFlags & CSIDL_MYFLAG_RELATIVE)
     991          {
     992            GetWindowsDirectoryA(szPath, MAX_PATH);
     993            PathAddBackslashA(szPath);
     994            strcat(szPath, szDefaultPath);
     995          }
     996          else
     997          {
     998            strcpy(szPath, "C:\\"); /* FIXME ??? */
     999            strcat(szPath, szDefaultPath);
     1000          }
     1001          RegSetValueExA(hKey,szValueName,0,REG_SZ,(LPBYTE)szPath,strlen(szPath)+1);
    10041002        }
    1005         else
    1006         {
    1007           LPCSTR pRegPath;
    1008 
    1009           if (dwFlags & CSIDL_MYFLAG_SETUP)
    1010             pRegPath = szSetup;
    1011           else
    1012           if (dwFlags & CSIDL_MYFLAG_CURRVER)
    1013             pRegPath = szCurrentVersion;
    1014           else
    1015           {
    1016             ERR("folder settings broken, please correct !\n");
    1017             return FALSE;
    1018           }
    1019 
    1020           if   (RegCreateKeyExA(hRootKey,pRegPath,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
    1021 
    1022           if   (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
    1023           {
    1024             /* value not existing */
    1025             if (dwFlags & CSIDL_MYFLAG_RELATIVE)
    1026             {
    1027               GetWindowsDirectoryA(szPath, MAX_PATH);
    1028               PathAddBackslashA(szPath);
    1029               strcat(szPath, szDefaultPath);
    1030             }
    1031             else
    1032             {
    1033               strcpy(szPath, "C:\\");   /* FIXME ??? */
    1034               strcat(szPath, szDefaultPath);
    1035             }
    1036             RegSetValueExA(hKey,szValueName,0,REG_SZ,(LPBYTE)szPath,strlen(szPath)+1);
    1037           }
    1038           RegCloseKey(hKey);
    1039         }
    1040 
    1041         /* expand paths like %USERPROFILE% */
    1042         if (dwType == REG_EXPAND_SZ)
    1043         {
    1044           ExpandEnvironmentStringsA(szPath, szDefaultPath, MAX_PATH);
    1045           strcpy(szPath, szDefaultPath);
    1046         }
    1047 
    1048         /* if we don't care about existing directories we are ready */
    1049         if(csidl & CSIDL_FLAG_DONT_VERIFY) return TRUE;
    1050 
    1051         if (PathFileExistsA(szPath)) return TRUE;
    1052 
    1053         /* not existing but we are not allowed to create it */
    1054         if (!bCreate) return FALSE;
    1055 
    1056         /* create directory/directories */
    1057         strcpy(szBuildPath, szPath);
    1058         p = strchr(szBuildPath, '\\');
    1059         while (p)
    1060         {
    1061             *p = 0;
    1062             if (!PathFileExistsA(szBuildPath))
    1063             {
    1064                 if (!CreateDirectoryA(szBuildPath,NULL))
    1065                 {
    1066                     ERR("Failed to create directory '%s'.\n", szPath);
    1067                     return FALSE;
    1068                 }
    1069             }
    1070             *p = '\\';
    1071             p = strchr(p+1, '\\');
    1072         }
    1073 
    1074         MESSAGE("Created not existing system directory '%s'\n", szPath);
    1075         return TRUE;
     1003      }
     1004      RegCloseKey(hKey);
     1005        }
     1006    else
     1007    {
     1008      LPCSTR pRegPath;
     1009
     1010      if (dwFlags & CSIDL_MYFLAG_SETUP)
     1011        pRegPath = szSetup;
     1012      else
     1013      if (dwFlags & CSIDL_MYFLAG_CURRVER)
     1014        pRegPath = szCurrentVersion;
     1015      else
     1016      {
     1017        ERR("folder settings broken, please correct !\n");
     1018        return FALSE;
     1019      }
     1020
     1021      if   (RegCreateKeyExA(hRootKey,pRegPath,0,NULL,0,KEY_ALL_ACCESS,NULL,&hKey,&dwDisp)) return FALSE;
     1022
     1023      if   (RegQueryValueExA(hKey,szValueName,NULL,&dwType,(LPBYTE)szPath,&dwPathLen))
     1024      {
     1025        /* value not existing */
     1026        if (dwFlags & CSIDL_MYFLAG_RELATIVE)
     1027        {
     1028          GetWindowsDirectoryA(szPath, MAX_PATH);
     1029          PathAddBackslashA(szPath);
     1030          strcat(szPath, szDefaultPath);
     1031        }
     1032        else
     1033        {
     1034          strcpy(szPath, "C:\\");   /* FIXME ??? */
     1035          strcat(szPath, szDefaultPath);
     1036        }
     1037        RegSetValueExA(hKey,szValueName,0,REG_SZ,(LPBYTE)szPath,strlen(szPath)+1);
     1038      }
     1039      RegCloseKey(hKey);
     1040    }
     1041
     1042    /* expand paths like %USERPROFILE% */
     1043    if (dwType == REG_EXPAND_SZ)
     1044    {
     1045      ExpandEnvironmentStringsA(szPath, szDefaultPath, MAX_PATH);
     1046      strcpy(szPath, szDefaultPath);
     1047    }
     1048
     1049    /* if we don't care about existing directories we are ready */
     1050    if(csidl & CSIDL_FLAG_DONT_VERIFY) return TRUE;
     1051
     1052    if (PathFileExistsA(szPath)) return TRUE;
     1053
     1054    /* not existing but we are not allowed to create it */
     1055    if (!bCreate) return FALSE;
     1056
     1057    /* create directory/directories */
     1058    strcpy(szBuildPath, szPath);
     1059    p = strchr(szBuildPath, '\\');
     1060    while (p)
     1061    {
     1062        *p = 0;
     1063        if (!PathFileExistsA(szBuildPath))
     1064        {
     1065        if (!CreateDirectoryA(szBuildPath,NULL))
     1066        {
     1067            ERR("Failed to create directory '%s'.\n", szPath);
     1068            return FALSE;
     1069        }
     1070        }
     1071        *p = '\\';
     1072        p = strchr(p+1, '\\');
     1073    }
     1074
     1075    MESSAGE("Created not existing system directory '%s'\n", szPath);
     1076    return TRUE;
    10761077}
    10771078
    … …  
    10801081 */
    10811082BOOL WINAPI SHGetSpecialFolderPathW (
    1082         HWND hwndOwner,
    1083         LPWSTR szPath,
    1084         DWORD csidl,
    1085         BOOL bCreate)
    1086 {
    1087         char szTemp[MAX_PATH];
    1088        
    1089         if (SHGetSpecialFolderPathA(hwndOwner, szTemp, csidl, bCreate))
    1090         {
     1083    HWND hwndOwner,
     1084    LPWSTR szPath,
     1085    DWORD csidl,
     1086    BOOL bCreate)
     1087{
     1088    char szTemp[MAX_PATH];
     1089
     1090    if (SHGetSpecialFolderPathA(hwndOwner, szTemp, csidl, bCreate))
     1091    {
    10911092            if (!MultiByteToWideChar( CP_ACP, 0, szTemp, -1, szPath, MAX_PATH ))
    10921093                szPath[MAX_PATH-1] = 0;
    10931094        }
    10941095
    1095         TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
    1096 
    1097         return TRUE;
     1096    TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
     1097
     1098    return TRUE;
    10981099}
    10991100
    … …  
    11021103 */
    11031104BOOL WINAPI SHGetSpecialFolderPathAW (
    1104         HWND hwndOwner,
    1105         LPVOID szPath,
    1106         DWORD csidl,
    1107         BOOL bCreate)
    1108 
    1109 {
    1110         if (SHELL_OsIsUnicode())
    1111           return SHGetSpecialFolderPathW (hwndOwner, szPath, csidl, bCreate);
    1112         return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate);
    1113 }
    1114 
    1115 /*************************************************************************
    1116  * SHGetFolderPathA                     [SHFOLDER.@]
     1105    HWND hwndOwner,
     1106    LPVOID szPath,
     1107    DWORD csidl,
     1108    BOOL bCreate)
     1109
     1110{
     1111    if (SHELL_OsIsUnicode())
     1112      return SHGetSpecialFolderPathW (hwndOwner, szPath, csidl, bCreate);
     1113    return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate);
     1114}
     1115
     1116/*************************************************************************
     1117 * SHGetFolderPathA         [SHFOLDER.@]
    11171118 */
    11181119HRESULT WINAPI SHGetFolderPathA(
    1119         HWND hwndOwner,
    1120         int nFolder,
    1121         HANDLE hToken,  /* [in] FIXME: get paths for specific user */
    1122         DWORD dwFlags,  /* [in] FIXME: SHGFP_TYPE_CURRENT|SHGFP_TYPE_DEFAULT */
    1123         LPSTR pszPath)
    1124 {
    1125         return (SHGetSpecialFolderPathA(
    1126                 hwndOwner,
    1127                 pszPath,
    1128                 CSIDL_FOLDER_MASK & nFolder,
    1129                 CSIDL_FLAG_CREATE & nFolder )) ? S_OK : E_FAIL;
    1130 }
    1131 
    1132 /*************************************************************************
    1133  * SHGetFolderPathW                     [SHFOLDER.@]
     1120    HWND hwndOwner,
     1121    int nFolder,
     1122    HANDLE hToken,  /* [in] FIXME: get paths for specific user */
     1123    DWORD dwFlags,  /* [in] FIXME: SHGFP_TYPE_CURRENT|SHGFP_TYPE_DEFAULT */
     1124    LPSTR pszPath)
     1125{
     1126    return (SHGetSpecialFolderPathA(
     1127        hwndOwner,
     1128        pszPath,
     1129        CSIDL_FOLDER_MASK & nFolder,
     1130        CSIDL_FLAG_CREATE & nFolder )) ? S_OK : E_FAIL;
     1131}
     1132
     1133/*************************************************************************
     1134 * SHGetFolderPathW         [SHFOLDER.@]
    11341135 */
    11351136HRESULT WINAPI SHGetFolderPathW(
    1136         HWND hwndOwner,
    1137         int nFolder,
    1138         HANDLE hToken,
    1139         DWORD dwFlags,
    1140         LPWSTR pszPath)
    1141 {
    1142         return (SHGetSpecialFolderPathW(
    1143                 hwndOwner,
    1144                 pszPath,
    1145                 CSIDL_FOLDER_MASK & nFolder,
    1146                 CSIDL_FLAG_CREATE & nFolder )) ? S_OK : E_FAIL;
    1147 }
     1137    HWND hwndOwner,
     1138    int nFolder,
     1139    HANDLE hToken,
     1140    DWORD dwFlags,
     1141    LPWSTR pszPath)
     1142{
     1143    return (SHGetSpecialFolderPathW(
     1144        hwndOwner,
     1145        pszPath,
     1146        CSIDL_FOLDER_MASK & nFolder,
     1147        CSIDL_FLAG_CREATE & nFolder )) ? S_OK : E_FAIL;
     1148}
Note: See TracChangeset for help on using the changeset viewer.