Ignore:
Timestamp:
Sep 15, 2001, 11:26:26 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/shellpath.c

    r6650 r6709  
    1 /* $Id: shellpath.c,v 1.6 2001-09-05 13:46:58 bird Exp $ */
    21/*
    32 * Path Functions
    … …  
    2221
    2322/*
    24     ########## Combining and Constructing paths ##########
     23        ########## Combining and Constructing paths ##########
    2524*/
    2625
    2726/*************************************************************************
    28  * PathAppendAW     [SHELL32.36]
     27 * PathAppendAW         [SHELL32.36]
    2928 */
    3029BOOL WINAPI PathAppendAW(
    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]
     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]
    4140 */
    4241LPVOID WINAPI PathCombineAW(
    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]
     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]
    5453 */
    5554LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
    5655{
    57     if(SHELL_OsIsUnicode())
    58       return PathAddBackslashW(lpszPath);
    59     return PathAddBackslashA(lpszPath);
    60 }
    61 
    62 /*************************************************************************
    63  * PathBuildRootAW      [SHELL32.30]
     56        if(SHELL_OsIsUnicode())
     57          return PathAddBackslashW(lpszPath);
     58        return PathAddBackslashA(lpszPath);
     59}
     60
     61/*************************************************************************
     62 * PathBuildRootAW              [SHELL32.30]
    6463 */
    6564LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
    6665{
    67     if(SHELL_OsIsUnicode())
    68       return PathBuildRootW(lpszPath, drive);
    69     return PathBuildRootA(lpszPath, drive);
     66        if(SHELL_OsIsUnicode())
     67          return PathBuildRootW(lpszPath, drive);
     68        return PathBuildRootA(lpszPath, drive);
    7069}
    7170
    7271/*
    73     Extracting Component Parts
     72        Extracting Component Parts
    7473*/
    7574
    7675/*************************************************************************
    77  * PathFindFileNameAW   [SHELL32.34]
     76 * PathFindFileNameAW   [SHELL32.34]
    7877 */
    7978LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
    8079{
    81     if(SHELL_OsIsUnicode())
    82       return PathFindFileNameW(lpszPath);
    83     return PathFindFileNameA(lpszPath);
    84 }
    85 
    86 /*************************************************************************
    87  * PathFindExtensionAW      [SHELL32.31]
    88  */
    89 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
    90 {
    91     if (SHELL_OsIsUnicode())
    92       return PathFindExtensionW(lpszPath);
    93     return PathFindExtensionA(lpszPath);
    94 
    95 }
    96 
    97 /*************************************************************************
    98  * PathGetExtensionA        [internal]
     80        if(SHELL_OsIsUnicode())
     81          return PathFindFileNameW(lpszPath);
     82        return PathFindFileNameA(lpszPath);
     83}
     84
     85/*************************************************************************
     86 * PathFindExtensionAW          [SHELL32.31]
     87 */
     88LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath) 
     89{
     90        if (SHELL_OsIsUnicode())
     91          return PathFindExtensionW(lpszPath);
     92        return PathFindExtensionA(lpszPath);
     93
     94}
     95
     96/*************************************************************************
     97 * PathGetExtensionA            [internal]
    9998 *
    10099 * NOTES
    … …  
    104103static LPSTR PathGetExtensionA(LPCSTR lpszPath)
    105104{
    106     TRACE("(%s)\n",lpszPath);
    107 
    108     lpszPath = PathFindExtensionA(lpszPath);
    109     return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
    110 }
    111 
    112 /*************************************************************************
    113  * PathGetExtensionW        [internal]
     105        TRACE("(%s)\n",lpszPath);
     106
     107        lpszPath = PathFindExtensionA(lpszPath);
     108        return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
     109}
     110
     111/*************************************************************************
     112 * PathGetExtensionW            [internal]
    114113 */
    115114static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
    116115{
    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  */
    126 LPVOID 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  */
    136 LPVOID 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  */
    146 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
    147 {
    148     if (SHELL_OsIsUnicode())
    149       return PathGetDriveNumberW(lpszPath);
    150     return PathGetDriveNumberA(lpszPath);
     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 */
     125LPVOID 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 */
     135LPVOID 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 */
     145int WINAPI PathGetDriveNumberAW(LPVOID lpszPath) 
     146{
     147        if (SHELL_OsIsUnicode())
     148          return PathGetDriveNumberW(lpszPath);
     149        return PathGetDriveNumberA(lpszPath);
    151150}
    152151
    … …  
    154153 * PathRemoveFileSpec [SHELL32.35]
    155154 */
    156 BOOL 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  */
    166 void 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  */
    176 BOOL 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  */
    186 void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
    187 {
    188     if (SHELL_OsIsUnicode())
    189       PathRemoveArgsW(lpszPath);
    190     PathRemoveArgsA(lpszPath);
    191 }
    192 
    193 /*************************************************************************
    194  * PathRemoveExtensionAW    [SHELL32.250]
    195  */
    196 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
    197 {
    198     if (SHELL_OsIsUnicode())
    199       return PathRemoveExtensionW(lpszPath);
    200     return PathRemoveExtensionA(lpszPath);
     155BOOL 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 */
     165void 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 */
     175BOOL 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 */
     185void WINAPI PathRemoveArgsAW(LPVOID lpszPath) 
     186{
     187        if (SHELL_OsIsUnicode())
     188          PathRemoveArgsW(lpszPath);
     189        PathRemoveArgsA(lpszPath);
     190}
     191
     192/*************************************************************************
     193 * PathRemoveExtensionAW        [SHELL32.250]
     194 */
     195void WINAPI PathRemoveExtensionAW(LPVOID lpszPath) 
     196{
     197        if (SHELL_OsIsUnicode())
     198          return PathRemoveExtensionW(lpszPath);
     199        return PathRemoveExtensionA(lpszPath);
    201200}
    202201
    203202
    204203/*
    205     Path Manipulations
     204        Path Manipulations
    206205*/
    207206
    … …  
    211210LPSTR WINAPI PathGetShortPathA(LPSTR lpszPath)
    212211{
    213     FIXME("%s stub\n", lpszPath);
    214     return NULL;
     212        FIXME("%s stub\n", lpszPath);
     213        return NULL;
    215214}
    216215
    … …  
    220219LPWSTR WINAPI PathGetShortPathW(LPWSTR lpszPath)
    221220{
    222     FIXME("%s stub\n", debugstr_w(lpszPath));
    223     return NULL;
     221        FIXME("%s stub\n", debugstr_w(lpszPath));
     222        return NULL;
    224223}
    225224
    … …  
    229228LPVOID WINAPI PathGetShortPathAW(LPVOID lpszPath)
    230229{
    231     if(SHELL_OsIsUnicode())
    232       return PathGetShortPathW(lpszPath);
    233     return PathGetShortPathA(lpszPath);
     230        if(SHELL_OsIsUnicode())
     231          return PathGetShortPathW(lpszPath);
     232        return PathGetShortPathA(lpszPath);
    234233}
    235234
    … …  
    239238void WINAPI PathRemoveBlanksAW(LPVOID str)
    240239{
    241     if(SHELL_OsIsUnicode())
    242       PathRemoveBlanksW(str);
    243     PathRemoveBlanksA(str);
     240        if(SHELL_OsIsUnicode())
     241          PathRemoveBlanksW(str);
     242        PathRemoveBlanksA(str);
    244243}
    245244
    … …  
    249248LPVOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
    250249{
    251     if(SHELL_OsIsUnicode())
    252       return PathQuoteSpacesW(lpszPath);
    253     return PathQuoteSpacesA(lpszPath);
     250        if(SHELL_OsIsUnicode())
     251          return PathQuoteSpacesW(lpszPath);
     252        return PathQuoteSpacesA(lpszPath);
    254253}
    255254
    … …  
    257256 * PathUnquoteSpacesAW [SHELL32.56]
    258257 */
    259 VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
    260 {
    261     if(SHELL_OsIsUnicode())
    262       PathUnquoteSpacesW(str);
    263     else
    264       PathUnquoteSpacesA(str);
    265 }
    266 
    267 /*************************************************************************
    268  * PathParseIconLocationAW  [SHELL32.249]
     258VOID WINAPI PathUnquoteSpacesAW(LPVOID str) 
     259{
     260        if(SHELL_OsIsUnicode())
     261          PathUnquoteSpacesW(str);
     262        else
     263          PathUnquoteSpacesA(str);
     264}
     265
     266/*************************************************************************
     267 * PathParseIconLocationAW      [SHELL32.249]
    269268 */
    270269int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
    271270{
    272     if(SHELL_OsIsUnicode())
    273       return PathParseIconLocationW(lpszPath);
    274     return PathParseIconLocationA(lpszPath);
     271        if(SHELL_OsIsUnicode())
     272          return PathParseIconLocationW(lpszPath);
     273        return PathParseIconLocationA(lpszPath);
    275274}
    276275
    277276/*
    278     ########## Path Testing ##########
     277        ########## Path Testing ##########
    279278*/
    280279/*************************************************************************
    281  * PathIsUNCAW      [SHELL32.39]
     280 * PathIsUNCAW          [SHELL32.39]
    282281 */
    283282BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
    284283{
    285     if (SHELL_OsIsUnicode())
    286       return PathIsUNCW( lpszPath );
    287     return PathIsUNCA( lpszPath );
    288 }
    289 
    290 /*************************************************************************
    291  *  PathIsRelativeAW    [SHELL32.40]
     284        if (SHELL_OsIsUnicode())
     285          return PathIsUNCW( lpszPath );
     286        return PathIsUNCA( lpszPath ); 
     287}
     288
     289/*************************************************************************
     290 *  PathIsRelativeAW    [SHELL32.40]
    292291 */
    293292BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
    294293{
    295     if (SHELL_OsIsUnicode())
    296       return PathIsRelativeW( lpszPath );
    297     return PathIsRelativeA( lpszPath );
    298 }
    299 
    300 /*************************************************************************
    301  * PathIsRootAW     [SHELL32.29]
    302  */
    303 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
    304 {
    305     if (SHELL_OsIsUnicode())
    306       return PathIsRootW(lpszPath);
    307     return PathIsRootA(lpszPath);
    308 }
    309 
    310 /*************************************************************************
    311  *  PathIsExeA      [internal]
     294        if (SHELL_OsIsUnicode())
     295          return PathIsRelativeW( lpszPath );
     296        return PathIsRelativeA( lpszPath ); 
     297}
     298
     299/*************************************************************************
     300 * PathIsRootAW         [SHELL32.29]
     301 */
     302BOOL WINAPI PathIsRootAW(LPCVOID lpszPath) 
     303{
     304        if (SHELL_OsIsUnicode())
     305          return PathIsRootW(lpszPath);
     306        return PathIsRootA(lpszPath);
     307}
     308
     309/*************************************************************************
     310 *  PathIsExeA          [internal]
    312311 */
    313312static BOOL PathIsExeA (LPCSTR lpszPath)
    314313{
    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]
     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]
    329328 */
    330329static BOOL PathIsExeW (LPCWSTR lpszPath)
    331330{
    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++)
     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++)
    341340#ifdef __WIN32OS2__
    342       if (!lstrcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
     341          if (!lstrcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
    343342#else
    344       if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
    345 #endif
    346     return FALSE;
    347 }
    348 
    349 /*************************************************************************
    350  *  PathIsExeAW     [SHELL32.43]
     343          if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
     344#endif   
     345        return FALSE;
     346}
     347
     348/*************************************************************************
     349 *  PathIsExeAW         [SHELL32.43]
    351350 */
    352351BOOL WINAPI PathIsExeAW (LPCVOID path)
    353352{
    354     if (SHELL_OsIsUnicode())
    355       return PathIsExeW (path);
    356     return PathIsExeA(path);
    357 }
    358 
    359 /*************************************************************************
    360  * PathIsDirectoryAW    [SHELL32.159]
     353        if (SHELL_OsIsUnicode())
     354          return PathIsExeW (path);
     355        return PathIsExeA(path);
     356}
     357
     358/*************************************************************************
     359 * PathIsDirectoryAW    [SHELL32.159]
    361360 */
    362361BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
    363362{
    364     if (SHELL_OsIsUnicode())
    365       return PathIsDirectoryW (lpszPath);
    366     return PathIsDirectoryA (lpszPath);
    367 }
    368 
    369 /*************************************************************************
    370  * PathFileExistsAW [SHELL32.45]
    371  */
     363        if (SHELL_OsIsUnicode())
     364          return PathIsDirectoryW (lpszPath);
     365        return PathIsDirectoryA (lpszPath);
     366}
     367
     368/*************************************************************************
     369 * PathFileExistsAW     [SHELL32.45]
     370 */ 
    372371BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
    373372{
    374     if (SHELL_OsIsUnicode())
    375       return PathFileExistsW (lpszPath);
    376     return PathFileExistsA (lpszPath);
    377 }
    378 
    379 /*************************************************************************
    380  * PathMatchSpecAW  [SHELL32.46]
    381  */
    382 BOOL 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]
     373        if (SHELL_OsIsUnicode())
     374          return PathFileExistsW (lpszPath);
     375        return PathFileExistsA (lpszPath);
     376}
     377
     378/*************************************************************************
     379 * PathMatchSpecAW      [SHELL32.46]
     380 */
     381BOOL 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]
    391390 */
    392391BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
    393392{
    394     if (SHELL_OsIsUnicode())
    395       return PathIsSameRootW(lpszPath1, lpszPath2);
    396     return PathIsSameRootA(lpszPath1, lpszPath2);
    397 }
    398 
    399 /*************************************************************************
    400  * IsLFNDriveA      [SHELL32.119]
    401  *
     393        if (SHELL_OsIsUnicode())
     394          return PathIsSameRootW(lpszPath1, lpszPath2);
     395        return PathIsSameRootA(lpszPath1, lpszPath2);
     396}
     397
     398/*************************************************************************
     399 * IsLFNDriveA          [SHELL32.119]
     400 * 
    402401 * NOTES
    403402 *     exported by ordinal Name
    404403 */
    405 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
    406 {
    407     DWORD   fnlen;
     404BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath) 
     405{
     406    DWORD       fnlen;
    408407
    409408    if (!GetVolumeInformationA(lpszPath,NULL,0,NULL,&fnlen,NULL,NULL,0))
    410     return FALSE;
     409        return FALSE;
    411410    return fnlen>12;
    412411}
    413412
    414413/*
    415     ########## Creating Something Unique ##########
     414        ########## Creating Something Unique ##########
    416415*/
    417416/*************************************************************************
    418  * PathMakeUniqueNameA  [internal]
     417 * PathMakeUniqueNameA  [internal]
    419418 */
    420419BOOL WINAPI PathMakeUniqueNameA(
    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]
     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]
    435434 */
    436435BOOL WINAPI PathMakeUniqueNameW(
    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]
     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]
    451450 */
    452451BOOL WINAPI PathMakeUniqueNameAW(
    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);
     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);
    462461}
    463462
    464463/*************************************************************************
    465464 * PathYetAnotherMakeUniqueNameA [SHELL32.75]
    466  *
     465 * 
    467466 * NOTES
    468467 *     exported by ordinal
    469468 */
    470469BOOL WINAPI PathYetAnotherMakeUniqueNameA(
    471     LPSTR lpszBuffer,
    472     LPCSTR lpszPathName,
    473     LPCSTR lpszShortName,
    474     LPCSTR lpszLongName)
     470        LPSTR lpszBuffer,
     471        LPCSTR lpszPathName,
     472        LPCSTR lpszShortName,
     473        LPCSTR lpszLongName)
    475474{
    476475    FIXME("(%p,%p, %p ,%p):stub.\n",
    … …  
    482481
    483482BOOL WINAPI PathYetAnotherMakeUniqueNameW(
    484     LPWSTR lpszBuffer,
    485     LPCWSTR lpszPathName,
    486     LPCWSTR lpszShortName,
    487     LPCWSTR lpszLongName)
     483        LPWSTR lpszBuffer,
     484        LPCWSTR lpszPathName,
     485        LPCWSTR lpszShortName,
     486        LPCWSTR lpszLongName)
    488487{
    489488    FIXME("PathYetAnotherMakeUniqueNameW (%p,%p, %p ,%p):stub.\n",
    … …  
    493492
    494493BOOL WINAPI PathYetAnotherMakeUniqueNameAW(
    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);
     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);
    503502}
    504503#endif
    … …  
    506505
    507506/*
    508     ########## cleaning and resolving paths ##########
    509  */
    510 
    511 /*************************************************************************
    512  * PathFindOnPathAW [SHELL32]
     507        ########## cleaning and resolving paths ##########
     508 */
     509
     510/*************************************************************************
     511 * PathFindOnPathAW     [SHELL32]
    513512 */
    514513BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID sOtherDirs)
    515514{
    516     if (SHELL_OsIsUnicode())
    517       return PathFindOnPathW(sFile, sOtherDirs);
    518     return PathFindOnPathA(sFile, sOtherDirs);
    519 }
    520 
    521 /*************************************************************************
    522  * PathCleanupSpecAW    [SHELL32]
     515        if (SHELL_OsIsUnicode())
     516          return PathFindOnPathW(sFile, sOtherDirs);
     517        return PathFindOnPathA(sFile, sOtherDirs);
     518}
     519
     520/*************************************************************************
     521 * PathCleanupSpecAW    [SHELL32]
    523522 */
    524523DWORD WINAPI PathCleanupSpecAW (LPCVOID x, LPVOID y)
    … …  
    529528
    530529/*************************************************************************
    531  * PathQualifyA     [SHELL32]
    532  */
    533 BOOL WINAPI PathQualifyA(LPCSTR pszPath)
    534 {
    535     FIXME("%s\n",pszPath);
    536     return 0;
    537 }
    538 
    539 /*************************************************************************
    540  * PathQualifyW     [SHELL32]
    541  */
    542 BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
    543 {
    544     FIXME("%s\n",debugstr_w(pszPath));
    545     return 0;
    546 }
    547 
    548 /*************************************************************************
    549  * PathQualifyAW    [SHELL32]
    550  */
    551 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
    552 {
    553     if (SHELL_OsIsUnicode())
    554       return PathQualifyW(pszPath);
    555     return PathQualifyA(pszPath);
     530 * PathQualifyA         [SHELL32]
     531 */
     532BOOL WINAPI PathQualifyA(LPCSTR pszPath) 
     533{
     534        FIXME("%s\n",pszPath);
     535        return 0;
     536}
     537
     538/*************************************************************************
     539 * PathQualifyW         [SHELL32]
     540 */
     541BOOL WINAPI PathQualifyW(LPCWSTR pszPath) 
     542{
     543        FIXME("%s\n",debugstr_w(pszPath));
     544        return 0;
     545}
     546
     547/*************************************************************************
     548 * PathQualifyAW        [SHELL32]
     549 */
     550BOOL WINAPI PathQualifyAW(LPCVOID pszPath) 
     551{
     552        if (SHELL_OsIsUnicode())
     553          return PathQualifyW(pszPath);
     554        return PathQualifyA(pszPath);
    556555}
    557556
    … …  
    560559 */
    561560BOOL WINAPI PathResolveA(
    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;
     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;
    569568}
    570569
    … …  
    573572 */
    574573BOOL WINAPI PathResolveW(
    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;
     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;
    582581}
    583582
    … …  
    586585 */
    587586BOOL WINAPI PathResolveAW(
    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]
     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]
    599598*/
    600599HRESULT WINAPI PathProcessCommandA (
    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
     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
    614613*/
    615614HRESULT WINAPI PathProcessCommandW (
    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
     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
    629628*/
    630629HRESULT WINAPI PathProcessCommandAW (
    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);
     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);
    639638}
    640639
    641640/*
    642     ########## special ##########
     641        ########## special ##########
    643642*/
    644643
    … …  
    646645 * PathSetDlgItemPathAW
    647646 */
    648 BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
    649 {   if (SHELL_OsIsUnicode())
    650       return PathSetDlgItemPathW(hDlg, id, pszPath);
    651     return PathSetDlgItemPathA(hDlg, id, pszPath);
     647BOOL WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath) 
     648{       if (SHELL_OsIsUnicode())
     649          return PathSetDlgItemPathW(hDlg, id, pszPath);
     650        return PathSetDlgItemPathA(hDlg, id, pszPath);
    652651}
    653652
    … …  
    655654/*************************************************************************
    656655 * SHGetSpecialFolderPathA [SHELL32.175]
    657  *
     656 * 
    658657 * converts csidl to path
    659658 */
    660 
     659 
    661660static const char * const szSHFolders = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders";
    662661static const char * const szSHUserFolders = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
    … …  
    676675} CSIDL_DATA;
    677676
    678 #define CSIDL_MYFLAG_SHFOLDER   1
    679 #define CSIDL_MYFLAG_SETUP  2
    680 #define CSIDL_MYFLAG_CURRVER    4
    681 #define CSIDL_MYFLAG_RELATIVE   8
     677#define CSIDL_MYFLAG_SHFOLDER   1
     678#define CSIDL_MYFLAG_SETUP      2
     679#define CSIDL_MYFLAG_CURRVER    4
     680#define CSIDL_MYFLAG_RELATIVE   8
    682681
    683682#define HKLM HKEY_LOCAL_MACHINE
    … …  
    686685{
    687686    { /* CSIDL_DESKTOP */
    688     9, HKCU,
    689     "Desktop",
    690     "Desktop"
     687        9, HKCU,
     688        "Desktop",
     689        "Desktop"
    691690    },
    692691    { /* CSIDL_INTERNET (??) */
    693     0, 1, /* FIXME */
    694     NULL,
    695     NULL,
     692        0, 1, /* FIXME */
     693        NULL,
     694        NULL,
    696695    },
    697696    { /* CSIDL_PROGRAMS */
    698     9, HKCU,
    699     "Programs",
    700     "Start Menu\\Programs"
     697        9, HKCU,
     698        "Programs",
     699        "Start Menu\\Programs"
    701700    },
    702701    { /* CSIDL_CONTROLS (.CPL files) */
    703     10, HKLM,
    704     "SysDir",
    705     "SYSTEM"
     702        10, HKLM,
     703        "SysDir",
     704        "SYSTEM"
    706705    },
    707706    { /* CSIDL_PRINTERS */
    708     10, HKLM,
    709     "SysDir",
    710     "SYSTEM"
     707        10, HKLM,
     708        "SysDir",
     709        "SYSTEM"
    711710    },
    712711    { /* CSIDL_PERSONAL */
    713     1, HKCU,
    714     "Personal",
    715     "My Documents"
     712        1, HKCU,
     713        "Personal",
     714        "My Documents"
    716715    },
    717716    { /* CSIDL_FAVORITES */
    718     9, HKCU,
    719     "Favorites",
    720     "Favorites"
     717        9, HKCU,
     718        "Favorites",
     719        "Favorites"
    721720    },
    722721    { /* CSIDL_STARTUP */
    723     9, HKCU,
    724     "StartUp",
    725     "Start Menu\\Programs\\StartUp"
     722        9, HKCU,
     723        "StartUp",
     724        "Start Menu\\Programs\\StartUp"
    726725    },
    727726    { /* CSIDL_RECENT */
    728     9, HKCU,
    729     "Recent",
    730     "Recent"
     727        9, HKCU,
     728        "Recent",
     729        "Recent"
    731730    },
    732731    { /* CSIDL_SENDTO */
    733     9, HKCU,
    734     "SendTo",
    735     "SendTo"
     732        9, HKCU,
     733        "SendTo",
     734        "SendTo"
    736735    },
    737736    { /* CSIDL_BITBUCKET (is this c:\recycled ?) */
    738     0, 1, /* FIXME */
    739     NULL,
    740     "recycled"
     737        0, 1, /* FIXME */
     738        NULL,
     739        "recycled"
    741740    },
    742741    { /* CSIDL_STARTMENU */
    743     9, HKCU,
    744     "Start Menu",
    745     "Start Menu"
     742        9, HKCU,
     743        "Start Menu",
     744        "Start Menu"
    746745    },
    747746    { /* not known */
    748     0, 0,
    749     NULL,
    750     NULL,
     747        0, 0,
     748        NULL,
     749        NULL,
    751750    },
    752751    { /* not known */
    753     0, 0,
    754     NULL,
    755     NULL,
     752        0, 0,
     753        NULL,
     754        NULL,
    756755    },
    757756    { /* not known */
    758     0, 0,
    759     NULL,
    760     NULL,
     757        0, 0,
     758        NULL,
     759        NULL,
    761760    },
    762761    { /* not known */
    763     0, 0,
    764     NULL,
    765     NULL,
     762        0, 0,
     763        NULL,
     764        NULL,
    766765    },
    767766    { /* CSIDL_DESKTOPDIRECTORY */
    768     9, HKCU,
    769     "Desktop",
    770     "Desktop"
     767        9, HKCU,
     768        "Desktop",
     769        "Desktop"
    771770    },
    772771    { /* CSIDL_DRIVES */
    773     0, 1, /* FIXME */
    774     NULL,
    775     "My Computer"
     772        0, 1, /* FIXME */
     773        NULL,
     774        "My Computer"
    776775    },
    777776    { /* CSIDL_NETWORK */
    778     0, 1, /* FIXME */
    779     NULL,
    780     "Network Neighborhood"
     777        0, 1, /* FIXME */
     778        NULL,
     779        "Network Neighborhood"
    781780    },
    782781    { /* CSIDL_NETHOOD */
    783     9, HKCU,
    784     "NetHood",
    785     "NetHood"
     782        9, HKCU,
     783        "NetHood",
     784        "NetHood"
    786785    },
    787786    { /* CSIDL_FONTS */
    788     9, HKCU,
    789     "Fonts",
    790     "Fonts"
     787        9, HKCU,
     788        "Fonts",
     789        "Fonts"
    791790    },
    792791    { /* CSIDL_TEMPLATES */
    793     9, HKCU,
    794     "Templates",
    795     "ShellNew"
     792        9, HKCU,
     793        "Templates",
     794        "ShellNew"
    796795    },
    797796    { /* CSIDL_COMMON_STARTMENU */
    798     9, HKLM,
    799     "Common Start Menu",
    800     "Start Menu"
     797        9, HKLM,
     798        "Common Start Menu",
     799        "Start Menu"
    801800    },
    802801    { /* CSIDL_COMMON_PROGRAMS */
    803     9, HKLM,
    804     "Common Programs",
    805     ""
     802        9, HKLM,
     803        "Common Programs",
     804        ""
    806805    },
    807806    { /* CSIDL_COMMON_STARTUP */
    808     9, HKLM,
    809     "Common StartUp",
    810     "All Users\\Start Menu\\Programs\\StartUp"
     807        9, HKLM,
     808        "Common StartUp",
     809        "All Users\\Start Menu\\Programs\\StartUp"
    811810    },
    812811    { /* CSIDL_COMMON_DESKTOPDIRECTORY */
    813     9, HKLM,
    814     "Common Desktop",
    815     "Desktop"
     812        9, HKLM,
     813        "Common Desktop",
     814        "Desktop"
    816815    },
    817816    { /* CSIDL_APPDATA */
    818     9, HKCU,
    819     "AppData",
    820     "Application Data"
     817        9, HKCU,
     818        "AppData",
     819        "Application Data"
    821820    },
    822821    { /* CSIDL_PRINTHOOD */
    823     9, HKCU,
    824     "PrintHood",
    825     "PrintHood"
     822        9, HKCU,
     823        "PrintHood",
     824        "PrintHood"
    826825    },
    827826    { /* not known */
    828     0, 0,
    829     NULL,
    830     NULL,
     827        0, 0,
     828        NULL,
     829        NULL,
    831830    },
    832831    { /* CSIDL_ALTSTARTUP */
    833     0, 1, /* FIXME */
    834     NULL,
    835     NULL
     832        0, 1, /* FIXME */
     833        NULL,
     834        NULL
    836835    },
    837836    { /* CSIDL_COMMON_ALTSTARTUP */
    838     0, 1, /* FIXME */
    839     NULL,
    840     NULL
     837        0, 1, /* FIXME */
     838        NULL,
     839        NULL
    841840    },
    842841    { /* CSIDL_COMMON_FAVORITES */
    843     9, HKCU,
    844     "Favorites",
    845     "Favorites"
     842        9, HKCU,
     843        "Favorites",
     844        "Favorites"
    846845    },
    847846    { /* CSIDL_INTERNET_CACHE */
    848     9, HKCU,
    849     "Cache",
    850     "Temporary Internet Files"
     847        9, HKCU,
     848        "Cache",
     849        "Temporary Internet Files"
    851850    },
    852851    { /* CSIDL_COOKIES */
    853     9, HKCU,
    854     "Cookies",
    855     "Cookies"
     852        9, HKCU,
     853        "Cookies",
     854        "Cookies"
    856855    },
    857856    { /* CSIDL_HISTORY */
    858     9, HKCU,
    859     "History",
    860     "History"
     857        9, HKCU,
     858        "History",
     859        "History"
    861860    },
    862861    { /* CSIDL_COMMON_APPDATA */
    863     9, HKLM,
    864     "Common AppData",
    865     "All Users\\Application Data"
     862        9, HKLM,
     863        "Common AppData",
     864        "All Users\\Application Data"
    866865    },
    867866    { /* CSIDL_WINDOWS */
    868     2, HKLM,
    869     "WinDir",
    870     "Windows"
     867        2, HKLM,
     868        "WinDir",
     869        "Windows"
    871870    },
    872871    { /* CSIDL_SYSTEM */
    873     10, HKLM,
    874     "SysDir",
    875     "SYSTEM"
     872        10, HKLM,
     873        "SysDir",
     874        "SYSTEM"
    876875    },
    877876    { /* CSIDL_PROGRAM_FILES */
    878     4, HKLM,
    879     "ProgramFilesDir",
    880     "Program Files"
     877        4, HKLM,
     878        "ProgramFilesDir",
     879        "Program Files"
    881880    },
    882881    { /* CSIDL_MYPICTURES */
    883     1, HKCU,
    884     "My Pictures",
    885     "My Documents\\My Pictures"
     882        1, HKCU,
     883        "My Pictures",
     884        "My Documents\\My Pictures"
    886885    },
    887886    { /* CSIDL_PROFILE */
    888     10, HKLM,
    889     "WinDir", /* correct ? */
    890     ""
     887        10, HKLM,
     888        "WinDir", /* correct ? */
     889        ""
    891890    },
    892891    { /* CSIDL_SYSTEMX86 */
    893     10, HKLM,
    894     "SysDir",
    895     "SYSTEM"
     892        10, HKLM,
     893        "SysDir",
     894        "SYSTEM"
    896895    },
    897896    { /* CSIDL_PROGRAM_FILESX86 */
    898     4, HKLM,
    899     "ProgramFilesDir",
    900     "Program Files"
     897        4, HKLM,
     898        "ProgramFilesDir",
     899        "Program Files"
    901900    },
    902901    { /* CSIDL_PROGRAM_FILES_COMMON */
    903     4, HKLM,
    904     "CommonFilesDir",
    905     "Program Files\\Common Files" /* ? */
     902        4, HKLM,
     903        "CommonFilesDir",
     904        "Program Files\\Common Files" /* ? */
    906905    },
    907906    { /* CSIDL_PROGRAM_FILES_COMMONX86 */
    908     4, HKLM,
    909     "CommonFilesDir",
    910     "Program Files\\Common Files" /* ? */
     907        4, HKLM,
     908        "CommonFilesDir",
     909        "Program Files\\Common Files" /* ? */
    911910    },
    912911    { /* CSIDL_COMMON_TEMPLATES */
    913     0, 1, /* FIXME */
    914     NULL,
    915     NULL
     912        0, 1, /* FIXME */
     913        NULL,
     914        NULL
    916915    },
    917916    { /* CSIDL_COMMON_DOCUMENTS */
    918     0, 1, /* FIXME */
    919     NULL,
    920     NULL
     917        0, 1, /* FIXME */
     918        NULL,
     919        NULL
    921920    },
    922921    { /* CSIDL_COMMON_ADMINTOOLS */
    923     0, 1, /* FIXME */
    924     NULL,
    925     NULL
     922        0, 1, /* FIXME */
     923        NULL,
     924        NULL
    926925    },
    927926    { /* CSIDL_ADMINTOOLS */
    928     9, HKCU,
    929     "Administrative Tools",
    930     "Start Menu\\Programs\\Administrative Tools"
     927        9, HKCU,
     928        "Administrative Tools",
     929        "Start Menu\\Programs\\Administrative Tools"
    931930    },
    932931    { /* CSIDL_CONNECTIONS */
    933     0, 1, /* FIXME */
    934     NULL,
    935     NULL
     932        0, 1, /* FIXME */
     933        NULL,
     934        NULL
    936935    }
    937936};
    … …  
    942941
    943942BOOL WINAPI SHGetSpecialFolderPathA (
    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);
     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);
    10021004        }
    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;
     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;
    10771076}
    10781077
    … …  
    10811080 */
    10821081BOOL WINAPI SHGetSpecialFolderPathW (
    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     {
     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        {
    10921091            if (!MultiByteToWideChar( CP_ACP, 0, szTemp, -1, szPath, MAX_PATH ))
    10931092                szPath[MAX_PATH-1] = 0;
    10941093        }
    10951094
    1096     TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
    1097 
    1098     return TRUE;
     1095        TRACE("0x%04x,%p,csidl=%lu,0x%04x\n", hwndOwner,szPath,csidl,bCreate);
     1096
     1097        return TRUE;
    10991098}
    11001099
    … …  
    11031102 */
    11041103BOOL WINAPI SHGetSpecialFolderPathAW (
    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.@]
     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.@]
    11181117 */
    11191118HRESULT WINAPI SHGetFolderPathA(
    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.@]
     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.@]
    11351134 */
    11361135HRESULT WINAPI SHGetFolderPathW(
    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 }
     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}
Note: See TracChangeset for help on using the changeset viewer.