Ignore:
Timestamp:
Jun 24, 1999, 9:27:49 PM (26 years ago)
Author:
phaller
Message:

Add: even more SHELL32 APIs ... and some corrections

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/ordinal.cpp

    r177 r183  
    1 /* $Id: ordinal.cpp,v 1.2 1999-06-24 09:02:07 phaller Exp $ */
     1/* $Id: ordinal.cpp,v 1.3 1999-06-24 19:27:49 phaller Exp $ */
    22
    33/*
    … …  
    1717#include <shellapi.h>
    1818#include <winreg.h>
    19 #include "shell32.h"
    2019
    2120#include <stdarg.h>
    … …  
    2423#include <stdlib.h>
    2524#include <string.h>
     25#include <wchar.h>
     26#include <wcstr.h>
    2627
    2728#include <misc.h>
    2829#include <nameid.h>
    2930#include <unicode.h>
     31#include <winnls.h>
     32
     33#include "shell32.h"
    3034
    3135
    … …  
    3640
    3741/*************************************************************************
    38  *           SHELL32_2              [SHELL32.2]
    39  */
    40 DWORD WIN32API SHELL32_2(HWND hwnd,
    41                             DWORD x2,
    42                             DWORD x3,
    43                             DWORD x4,
    44                             DWORD x5,
    45                             DWORD x6)
    46 {
    47   dprintf(("SHELL32: .2 (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08lx,0x%08lx) not implemented.\n",
    48            hwnd,
    49            x2,
    50            x3,
    51            x4,
    52            x5,
    53            x6));
    54   return 0;
    55 }
    56 
    57 
    58 /*************************************************************************
    5942 *           SHELL32_16             [SHELL32.16]
    6043 * find_lastitem_in_itemidlist()
    6144 */
    62 LPSHITEMID WIN32API SHELL32_16(LPITEMIDLIST iil)
     45LPSHITEMID WIN32API ILFindLastID(LPITEMIDLIST iil)
    6346{
    6447  LPSHITEMID lastsii,
    6548             sii;
    6649
    67   dprintf(("SHELL32: .16 (%08xh)\n",
     50  dprintf(("SHELL32: ILFindLastID (%08xh)\n",
    6851           iil));
    6952
    … …  
    8568
    8669/*************************************************************************
    87  *           SHELL32_29             [SHELL32.29]
    88  * is_rootdir(const char*path)
    89  */
    90 BOOL WIN32API SHELL32_29(LPCSTR x)
    91 {
    92   dprintf(("SHELL32: .29 (%s)\n",
     70 *           SHELL32_71             [SHELL32.71]
     71 * returns internal shell values in the passed pointers
     72 */
     73BOOL WIN32API Shell_GetImageList(LPDWORD x,
     74                                 LPDWORD y)
     75{
     76  dprintf(("SHELL32: Shell_GetImageList (%08xh, %08xh) not implemented.\n",
     77           x,
     78           y));
     79
     80  return TRUE;
     81}
     82
     83
     84/*************************************************************************
     85 *           SHELL32_72             [SHELL32.72]
     86 * dunno. something with icons
     87 */
     88void WIN32API Shell_GetCachedImageIndex(LPSTR x,
     89                                        DWORD y,
     90                                        DWORD z)
     91{
     92  dprintf (("SHELL32: Shell_GetCachedImageIndex (%08xh, %08xh, %08xh) not implemented.\n",
     93            x,
     94            y,
     95            z));
     96}
     97
     98
     99/*************************************************************************
     100 *           SHELL32_89             [SHELL32.89]
     101 */
     102DWORD WIN32API SHCloneSpecialIDList(DWORD x1,
     103                                    DWORD x2,
     104                                    DWORD x3)
     105{
     106  dprintf(("SHELL32: SHCloneSpecialIDList (%08xh, %08xh, %08xh) not implemented.\n",
     107           x1,
     108           x2,
     109           x3));
     110
     111  return 0;
     112}
     113
     114
     115/*************************************************************************
     116 *              SHELL32_119 [SHELL32.119]
     117 * unknown
     118 */
     119BOOL WIN32API IsLFNDrive(LPVOID x)
     120{
     121  dprintf(("SHELL32: IsLFNDrive (%08xh) not implemented.\n",
    93122           x));
    94123
    95 
    96   if (!lstrcmpA(x+1,":\\"))      /* "X:\" */
    97     return 1;
    98 
    99   if (!lstrcmpA(x,"\\"))     /* "\" */
    100     return 1;
    101 
    102   if (x[0]=='\\' && x[1]=='\\')
    103   {     /* UNC "\\<xx>\" */
    104     int foundbackslash = 0;
    105 
    106     x=x+2;
    107     while (*x)
    108     {
    109       if (*x++=='\\')
    110         foundbackslash++;
    111     }
    112 
    113     if (foundbackslash<=1)  /* max 1 \ more ... */
    114       return 1;
    115   }
    116   return 0;
    117 }
    118 
    119 
    120 /*************************************************************************
    121  *           SHELL32_30             [SHELL32.30]
    122  * get_rootdir(char*path,int drive)
    123  */
    124 LPSTR WIN32API SHELL32_30(LPSTR root,
    125                              BYTE drive)
    126 {
    127   dprintf(("SHELL32: .30 (%s, %u)\n",
    128            root,
    129            drive));
    130 
    131 
    132   strcpy(root,
    133          "A:\\");
    134   root[0]+=drive;
    135 
    136   return root;
    137 }
    138 
    139 
    140 /*************************************************************************
    141  *                  SHELL32_31      [SHELL32.31]
    142  * returns pointer to last . in last pathcomponent or at \0.
    143  */
    144 LPSTR WIN32API SHELL32_31(LPSTR path)
    145 {
    146   LPSTR   lastpoint = NULL;
    147 
    148   dprintf(("SHELL32: .31 (%s)\n",
    149            path));
    150 
    151 
    152   while (*path)
    153   {
    154     if (*path=='\\'||*path==' ')
    155       lastpoint=NULL;
    156 
    157     if (*path=='.')
    158       lastpoint=path;
    159 
    160     path++;
    161   }
    162 
    163   return lastpoint ? lastpoint : path;
    164 }
    165 
    166 
    167 /*************************************************************************
    168  *              SHELL32_32  [SHELL32.32]
    169  * append \ if there is none
    170  */
    171 LPSTR WIN32API SHELL32_32(LPSTR path)
    172 {
    173   int len;
    174 
    175   dprintf(("SHELL32: .31 (%s)\n",
    176            path));
    177 
    178 
    179   len = lstrlenA(path);
    180 
    181   if (len && path[len-1]!='\\')
    182   {
    183     path[len+0]='\\';
    184     path[len+1]='\0';
    185     return path+len+1;
    186   }
    187   else
    188     return path+len;
    189 }
    190 
    191 
    192 /*************************************************************************
    193  *              SHELL32_33      [SHELL32.33]
    194  * remove spaces from beginning and end of passed string
    195  */
    196 LPSTR WIN32API SHELL32_33(LPSTR str)
    197 {
    198   LPSTR x = str;
    199 
    200   dprintf(("SHELL32: .33 (%s)\n",
    201            str));
    202 
    203 
    204   while (*x==' ')
    205     x++;
    206 
    207   if (x!=str)
    208     lstrcpyA(str,
    209                x);
    210 
    211   if (!*str)
    212     return str;
    213 
    214   x=str+strlen(str)-1;
    215 
    216   while (*x==' ')
    217     x--;
    218 
    219   if (*x==' ')
    220     *x='\0';
    221 
    222   return x;
    223 }
    224 
    225 
    226 /*************************************************************************
    227  *              SHELL32_34  [SHELL32.34]
    228  * basename(char *fn);
    229  */
    230 LPSTR WIN32API SHELL32_34(LPSTR fn)
    231 {
    232   LPSTR basefn;
    233 
    234   dprintf(("SHELL32: .34 (%s)\n",
    235            fn));
    236 
    237 
    238   basefn = fn;
    239   while (fn[0])
    240   {
    241     if (( (fn[0]=='\\') ||
    242           (fn[0]==':')) && fn[1] && fn[1]!='\\')
    243       basefn = fn+1;
    244 
    245     fn++;
    246   }
    247 
    248   return basefn;
    249 }
    250 
    251 /*************************************************************************
    252  *           SHELL32_35             [SHELL32.35]
    253  * bool getpath(char *pathname); truncates passed argument to a valid path
    254  * returns if the string was modified or not.
    255  * "\foo\xx\foo"-> "\foo\xx"
    256  * "\"      -> "\"
    257  * "a:\foo" -> "a:\"
    258  */
    259 DWORD WIN32API SHELL32_35(LPSTR fn)
    260 {
    261   LPSTR x,cutplace;
    262 
    263   dprintf(("SHELL32: .35 (%s)\n",
    264            fn));
    265 
    266 
    267     if (!fn[0])
    268         return 0;
    269     x=fn;
    270     cutplace = fn;
    271     while (*x) {
    272         if (*x=='\\') {
    273             cutplace=x++;
    274             continue;
    275         }
    276         if (*x==':') {
    277             x++;
    278             if (*x=='\\')
    279                 cutplace=++x;
    280             continue; /* already x++ed */
    281         }
    282         x++;
    283     }
    284     if (!*cutplace)
    285         return 0;
    286     if (cutplace==fn) {
    287         if (fn[0]=='\\') {
    288             if (!fn[1])
    289                 return 0;
    290             fn[0]='\0';
    291             return 1;
    292         }
    293     }
    294     *cutplace='\0';
    295     return 1;
    296 }
    297 
    298 /*************************************************************************
    299  *              SHELL32_37  [SHELL32.37]
    300  * concat_paths(char*target,const char*add);
    301  * concats "target\\add" and writes them to target
    302  */
    303 LPSTR WIN32API SHELL32_37(LPSTR target,
    304                              LPSTR x1,
    305                              LPSTR x2)
    306 {
    307   char  buf[260];
    308 
    309   dprintf(("SHELL32: .37 (%s, %s, %s)\n",
    310            target,
    311            x1,
    312            x2));
    313 
    314 
    315   if (!x2 || !x2[0])
    316   {
    317     lstrcpyA(target,x1);
    318 
    319     return target;
    320   }
    321 
    322   lstrcpyA(buf,x1);
    323   SHELL32_32(buf); /* append \ if not there */
    324   lstrcatA(buf,x2);
    325   lstrcpyA(target,buf);
    326 
    327   return target;
    328 }
    329 
    330 /*************************************************************************
    331  *              SHELL32_36  [SHELL32.36]
    332  * concat_paths(char*target,const char*add);
    333  * concats "target\\add" and writes them to target
    334  */
    335 LPSTR WIN32API SHELL32_36(LPSTR x1,
    336                              LPSTR x2)
    337 {
    338   dprintf(("SHELL32: .36 (%s, %s)\n",
    339            x1,
    340            x2));
    341 
    342 
    343   while (x2[0]=='\\')
    344     x2++;
    345 
    346   return SHELL32_37(x1,
    347                        x1,
    348                        x2);
    349 }
    350 
    351 /*************************************************************************
    352  *              SHELL32_39  [SHELL32.39]
    353  * isUNC(const char*path);
    354  */
    355 BOOL WIN32API SHELL32_39(LPCSTR path)
    356 {
    357   dprintf (("SHELL32: .39 (%s)\n",
    358             path));
    359 
    360 
    361   if ((path[0]=='\\') &&
    362       (path[1]=='\\'))
    363     return TRUE;
    364 
    365   return FALSE;
    366 }
    367 
    368 
    369 /*************************************************************************
    370  *              SHELL32_45  [SHELL32.45]
    371  * file_exists(char *fn);
    372  */
    373 BOOL WIN32API SHELL32_45(LPSTR fn)
    374 {
    375   dprintf(("SHELL32: .45 (%s)\n",
    376            fn));
    377 
    378 
    379   if (GetFileAttributesA(fn)==-1)
    380     return FALSE;
    381   else
    382     return TRUE;
    383 }
    384 
    385 /*************************************************************************
    386  *              SHELL32_52  [SHELL32.52]
    387  * look for next arg in string. handle "quoted" strings
    388  * returns pointer to argument *AFTER* the space. Or to the \0.
    389  */
    390 LPSTR WIN32API SHELL32_52(LPSTR cmdline)
    391 {
    392   BOOL  qflag = FALSE;
    393 
    394   dprintf (("SHELL32: .52 (%s)\n",
    395             cmdline));
    396 
    397 
    398   while (*cmdline)
    399   {
    400     if ((*cmdline==' ') && !qflag)
    401       return cmdline+1;
    402 
    403     if (*cmdline=='"')
    404       qflag=!qflag;
    405 
    406     cmdline++;
    407   }
    408   return cmdline;
    409 }
    410 
    411 
    412 /*************************************************************************
    413  *              SHELL32_56      [SHELL32.56]
    414  * unquote string (remove ")
    415  */
    416 VOID WIN32API SHELL32_56(LPSTR str)
    417 {
    418   DWORD      len = lstrlenA(str);
    419 
    420   dprintf (("SHELL32: .56 (%s)\n",
    421             str));
    422 
    423 
    424   if (*str!='"')
    425     return;
    426 
    427   if (str[len-1]!='"')
    428     return;
    429 
    430   str[len-1]='\0';
    431   lstrcpyA(str,
    432              str+1);
    433   return;
    434 }
    435 
    436 
    437 /*************************************************************************
    438  *           SHELL32_58             [SHELL32.58]
    439  */
    440 DWORD WIN32API SHELL32_58(LPCSTR src,
    441                              DWORD x2,
    442                              LPSTR target,
    443                              DWORD pathlen)
    444 {
    445   dprintf (("SHELL32: .58 (%s, %08xh, %08xh, %08xh) not implemented\n",
    446             src,
    447             x2,
    448             target,
    449             pathlen));
    450 
    451   return 0;
    452 }
    453 
    454 
    455 /*************************************************************************
    456  *           SHELL32_62             [SHELL32.62]
    457  */
    458 DWORD WIN32API SHELL32_62(DWORD x,
    459                              DWORD y,
    460                              DWORD z,
    461                              DWORD a)
    462 {
    463   dprintf(("SHELL32: .62 (%08xh, %08xh, %08xh, %08xh) not implemented.\n",
    464            x,
    465            y,
    466            z,
    467            a));
    468 
    469   return 0xffffffff;
    470 }
    471 
    472 
    473 /*************************************************************************
    474  *                      SHELL32_63                     [SHELL32.63]
    475  */
    476 DWORD WIN32API SHELL32_63(HWND   howner,
    477                              LPSTR  targetbuf,
    478                              DWORD  len,
    479                              DWORD  x,
    480                              LPCSTR suffix,
    481                              LPCSTR y,
    482                              LPCSTR cmd)
    483 {
    484   dprintf (("SHELL32: .63 (%08xh, %08x, %08xh, %08xh, %08xh, %08xh, %s) not implemented.\n",
    485             howner,
    486             targetbuf,
    487             len,
    488             x,
    489             suffix,
    490             y,
    491             cmd));
    492 
    493   /* puts up a Open Dialog and requests input into targetbuf */
    494   /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
    495   lstrcpyA(targetbuf,"x:\\s3.exe");
    496   return 1;
    497 }
    498 
    499 
    500 /*************************************************************************
    501  *                      SHELL32_68                     [SHELL32.68]
    502  */
    503 DWORD WIN32API SHELL32_68(DWORD x,
    504                              DWORD y,
    505                              DWORD z)
    506 {
    507   dprintf(("SHELL32: .68 (%08xh, %08xh, %08xh) not implemented.\n",
     124  return TRUE;
     125}
     126
     127
     128/*************************************************************************
     129 *           SHELL32_77             [SHELL32.77]
     130 */
     131DWORD WIN32API SHMapPIDLToSystemImageListIndex(DWORD x,
     132                                               DWORD y,
     133                                               DWORD z)
     134{
     135  dprintf(("SHELL32: SHMapPIDLToSystemImageListIndex (%08xh, %08xh, %08xh) not implemented.\n",
    508136           x,
    509137           y,
    … …  
    515143
    516144/*************************************************************************
    517  *           SHELL32_71             [SHELL32.71]
    518  * returns internal shell values in the passed pointers
    519  */
    520 BOOL WIN32API SHELL32_71(LPDWORD x,
    521                             LPDWORD y)
    522 {
    523   dprintf(("SHELL32: .71 (%08xh, %08xh) not implemented.\n",
    524            x,
    525            y));
    526 
    527   return TRUE;
    528 }
    529 
    530 
    531 /*************************************************************************
    532  *           SHELL32_72             [SHELL32.72]
    533  * dunno. something with icons
    534  */
    535 void WIN32API SHELL32_72(LPSTR x,
    536                             DWORD y,
    537                             DWORD z)
    538 {
    539   dprintf (("SHELL32: .27 (%08xh, %08xh, %08xh) not implemented.\n",
    540             x,
    541             y,
    542             z));
    543 }
    544 
    545 
    546 /*************************************************************************
    547  *           SHELL32_89             [SHELL32.89]
    548  */
    549 DWORD WIN32API SHELL32_89(DWORD x1,
    550                              DWORD x2,
    551                              DWORD x3)
    552 {
    553   dprintf(("SHELL32: .89 (%08xh, %08xh, %08xh) not implemented.\n",
    554            x1,
    555            x2,
    556            x3));
    557 
    558   return 0;
    559 }
    560 
    561 
    562 /*************************************************************************
    563  *              SHELL32_119 [SHELL32.119]
    564  * unknown
    565  */
    566 void WIN32API SHELL32_119(LPVOID x)
    567 {
    568   dprintf(("SHELL32: .119 (%08xh) not implemented.\n",
    569            x));
    570 }
    571 
    572 
    573 /*************************************************************************
    574  *              SHELL32_175 [SHELL32.175]
    575  * unknown
    576  */
    577 void WIN32API SHELL32_175(DWORD x1,
    578                              DWORD x2,
    579                              DWORD x3,
    580                              DWORD x4)
    581 {
    582   dprintf (("SHELL32: .175 (%08x, %08xh, %08xh, %08xh not implemented.\n",
    583             x1,
    584             x2,
    585             x3,
    586             x4));
    587 }
    588 
    589 
    590 /*************************************************************************
    591  *              SHELL32_181 [SHELL32.181]
    592  * unknown
    593  */
    594 void WIN32API SHELL32_181(DWORD x,
    595                              DWORD y)
    596 {
    597   dprintf(("SHELL32: .181 (%08xh, %08xh) not implemented.\n",
    598            x,
    599            y));
    600 }
    601 
    602 
    603 /*************************************************************************
    604  *              SHELL32_75  [SHELL32.75]
    605  * unknown
    606  */
    607 BOOL WIN32API SHELL32_75(LPDWORD x,
    608                             LPDWORD y)
    609 {
    610   dprintf(("SHELL32: .75 (%08xh, %08xh) not implemented.\n",
    611            x,
    612            y));
    613 
    614   return TRUE;
    615 }
    616 
    617 
    618 /*************************************************************************
    619  *           SHELL32_77             [SHELL32.77]
    620  */
    621 DWORD WIN32API SHELL32_77(DWORD x,
    622                              DWORD y,
    623                              DWORD z)
    624 {
    625   dprintf(("SHELL32: .77 (%08xh, %08xh, %08xh) not implemented.\n",
    626            x,
    627            y,
    628            z));
    629 
    630   return 0;
    631 }
    632 
    633 
    634 /*************************************************************************
    635  *           SHELL32_79             [SHELL32.79]
    636  * create_directory_and_notify(...)
    637  */
    638 DWORD WIN32API SHELL32_79(LPCSTR dir,
    639                              LPVOID xvoid)
    640 {
    641   dprintf(("SHELL32: .79 (%s, %08xh)\n",
    642            dir,
    643            xvoid));
    644 
    645   if (!CreateDirectoryA(dir,
    646                           (PSECURITY_ATTRIBUTES)xvoid))
    647     return FALSE;
    648 
    649     /* @@@PH: SHChangeNotify(8,1,dir,0); */
    650   return TRUE;
    651 }
    652 
    653 
    654 /*************************************************************************
    655  *           SHELL32_100            [SHELL32.100]
    656  * walks through policy table, queries <app> key, <type> value, returns
    657  * queried (DWORD) value.
    658  * {0x00001,Explorer,NoRun}
    659  * {0x00002,Explorer,NoClose}
    660  * {0x00004,Explorer,NoSaveSettings}
    661  * {0x00008,Explorer,NoFileMenu}
    662  * {0x00010,Explorer,NoSetFolders}
    663  * {0x00020,Explorer,NoSetTaskbar}
    664  * {0x00040,Explorer,NoDesktop}
    665  * {0x00080,Explorer,NoFind}
    666  * {0x00100,Explorer,NoDrives}
    667  * {0x00200,Explorer,NoDriveAutoRun}
    668  * {0x00400,Explorer,NoDriveTypeAutoRun}
    669  * {0x00800,Explorer,NoNetHood}
    670  * {0x01000,Explorer,NoStartBanner}
    671  * {0x02000,Explorer,RestrictRun}
    672  * {0x04000,Explorer,NoPrinterTabs}
    673  * {0x08000,Explorer,NoDeletePrinter}
    674  * {0x10000,Explorer,NoAddPrinter}
    675  * {0x20000,Explorer,NoStartMenuSubFolders}
    676  * {0x40000,Explorer,MyDocsOnNet}
    677  * {0x80000,WinOldApp,NoRealMode}
    678  */
    679 DWORD WIN32API SHELL32_100(DWORD pol)
    680 {
    681  HKEY xhkey;
    682 
    683   dprintf (("SHELL32: .100 (%08xh) not implemented.\n",
    684             pol));
    685 
    686   if (RegOpenKeyA((HKEY)HKEY_CURRENT_USER,
    687                     "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
    688                     &xhkey))
    689     return 0;
    690 
    691   /* FIXME: do nothing for now, just return 0 (== "allowed") */
    692   RegCloseKey(xhkey);
    693 
    694   return 0;
    695 }
    696 
    697 
    698 /*************************************************************************
    699145 *           SHELL32_152            [SHELL32.152]
    700146 * itemlist_length
    701147 */
    702 DWORD WIN32API SHELL32_152(LPITEMIDLIST iil)
     148DWORD WIN32API ILGetSize(LPITEMIDLIST iil)
    703149{
    704150  LPSHITEMID    si;
    705151  DWORD     len;
    706152
    707   dprintf(("SHELL32: .152 (%08xh)\n",
     153  dprintf(("SHELL32: ILGetSize (%08xh)\n",
    708154           iil));
    709155
    … …  
    722168
    723169
    724 /*************************************************************************
    725  *                      SHELL32_158                    [SHELL32.158]
    726  */
    727 LPSTR WIN32API SHELL32_158(LPSTR path,
    728                               DWORD y,
    729                               DWORD z)
    730 {
    731   dprintf(("SHELL32: .158 (%s, %08xh, %08xh)\n",
    732            path,
    733            y,
    734            z));
    735 
    736   path = SHELL32_31(path);
    737 
    738   return *path ? (path+1) : path;
    739 }
    740 
    741 
    742 /*************************************************************************
    743  *           SHELL32_165            [SHELL32.165]
    744  * create_path_and_notify(...)
    745  */
    746 DWORD WIN32API SHELL32_165(DWORD x,
    747                               LPCSTR path)
    748 {
    749   dprintf (("SHELL32 .165 (%08x, %08xh) not implemented.\n",
    750             x,
    751             path));
    752 
    753   if (SHELL32_79(path,
    754                     (LPVOID)x))
    755     return 0;
    756 
    757   return 0;
    758 }
    759 
    760 
    761 /*************************************************************************
    762  *           SHELL32_195            [SHELL32.195]
    763  * free_ptr() - frees memory using IMalloc
    764  */
    765 DWORD WIN32API SHELL32_195(LPVOID x)
    766 {
    767   dprintf (("SHELL32: .195 (%08xh) (LocalFree)\n",
    768             x));
    769 
    770   return (DWORD)LocalFree((HLOCAL)x);
    771 }
    772 
    773 
    774 /*************************************************************************
    775  *           SHELL32_196            [SHELL32.196]
    776  * void *task_alloc(DWORD len), uses SHMalloc allocator
    777  */
    778 LPVOID WIN32API SHELL32_196(DWORD len)
    779 {
    780   dprintf(("SHELL32: .196 (%08xh) (LocalAlloc)\n",
    781            len));
    782 
    783   return (LPVOID)LocalAlloc(len,
    784                               LMEM_ZEROINIT); /* FIXME */
    785 }
    786 
    787170
    788171/*************************************************************************
    … …  
    790173 * copy_itemidlist()
    791174 */
    792 LPITEMIDLIST WIN32API SHELL32_18(LPITEMIDLIST iil)
     175LPITEMIDLIST WIN32API ILClone(LPITEMIDLIST iil)
    793176{
    794177  DWORD     len;
    795178  LPITEMIDLIST  newiil;
    796179
    797   dprintf(("SHELL32: .18 (%08xh)\n",
     180  dprintf(("SHELL32: ILClone(%08xh)\n",
    798181           iil));
    799182
    800183
    801   len = SHELL32_152(iil);
    802   newiil = (LPITEMIDLIST)SHELL32_196(len);
     184  len = ILGetSize(iil);
     185  newiil = (LPITEMIDLIST)SHAlloc(len);
    803186  memcpy(newiil,
    804187         iil,
    … …  
    813196 * merge_itemidlist()
    814197 */
    815 LPITEMIDLIST WIN32API SHELL32_25(LPITEMIDLIST iil1,
    816                                     LPITEMIDLIST iil2)
     198LPITEMIDLIST WIN32API ILCombine(LPITEMIDLIST iil1,
     199                                LPITEMIDLIST iil2)
    817200{
    818201  DWORD     len1,len2;
    819202  LPITEMIDLIST  newiil;
    820203
    821   dprintf(("SHELL32: .25 (%08xh, %08xh)\n",
     204  dprintf(("SHELL32: ILCombine(%08xh, %08xh)\n",
    822205           iil1,
    823206           iil2));
    824207
    825208
    826   len1   = SHELL32_152(iil1)-2;
    827   len2   = SHELL32_152(iil2);
    828   newiil = (LPITEMIDLIST)SHELL32_196(len1+len2);
     209  len1   = ILGetSize(iil1)-2;
     210  len2   = ILGetSize(iil2);
     211  newiil = (LPITEMIDLIST)SHAlloc(len1+len2);
    829212
    830213  memcpy(newiil,
    … …  
    844227 * free_check_ptr - frees memory (if not NULL) allocated by SHMalloc allocator
    845228 */
    846 DWORD WIN32API SHELL32_155(LPVOID x)
    847 {
    848   dprintf(("SHELL32: .155 (%08xh)\n",
     229DWORD WIN32API ILFree(LPVOID x)
     230{
     231  dprintf(("SHELL32: ILFree (%08xh)\n",
    849232           x));
    850233
    … …  
    852235    return 0;
    853236
    854   return SHELL32_195(x);
     237  return SHFree(x);
    855238}
    856239
    … …  
    860243 * unknown
    861244 */
    862 DWORD WIN32API SHELL32_85(DWORD x1,
     245DWORD WIN32API OpenRegStream(DWORD x1,
    863246                             DWORD x2,
    864247                             DWORD x3,
    865248                             DWORD x4)
    866249{
    867   dprintf(("SHELL32: .85 (%08x, %08xh, %08xh, %08xh) not implemented.\n",
     250  dprintf(("SHELL32: OpenRegStream (%08x, %08xh, %08xh, %08xh) not implemented.\n",
    868251           x1,
    869252           x2,
    … …  
    876259
    877260/*****************************************************************************
    878  * Name      : .4
     261 * Name      :
    879262 * Purpose   :
    880263 * Parameters:
    881264 * Variables :
    882265 * Result    :
    883  * Remark    : unknown
     266 * Remark    : SHELL32.162
    884267 * Status    : UNTESTED UNKNOWN STUB
    885268 *
    … …  
    887270 *****************************************************************************/
    888271
    889 DWORD WIN32API SHELL32_4(DWORD x1)
    890 {
    891   dprintf(("SHELL32: .4 (%08xh) not implemented.\n",
     272DWORD WIN32API SHSimpleIDListFromPathAW(DWORD x1)
     273{
     274  dprintf(("SHELL32: .162 (%08xh) not implemented.\n",
    892275           x1));
    893276
    … …  
    897280
    898281/*****************************************************************************
    899  * Name      : .59
     282 * Name      :
    900283 * Purpose   :
    901284 * Parameters:
    902285 * Variables :
    903286 * Result    :
    904  * Remark    : unknown
     287 * Remark    : SHELL32.102
    905288 * Status    : UNTESTED UNKNOWN STUB
    906289 *
    … …  
    908291 *****************************************************************************/
    909292
    910 DWORD WIN32API SHELL32_59(void)
    911 {
    912   dprintf(("SHELL32: .59 () not implemented.\n"));
    913 
    914   return (0);
    915 }
    916 
    917 
    918 /*****************************************************************************
    919  * Name      : .162
    920  * Purpose   :
    921  * Parameters:
    922  * Variables :
    923  * Result    :
    924  * Remark    : unknown
    925  * Status    : UNTESTED UNKNOWN STUB
    926  *
    927  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    928  *****************************************************************************/
    929 
    930 DWORD WIN32API SHELL32_162(DWORD x1)
    931 {
    932   dprintf(("SHELL32: .162 (%08xh) not implemented.\n",
    933            x1));
    934 
    935   return (0);
    936 }
    937 
    938 
    939 /*****************************************************************************
    940  * Name      : .145
    941  * Purpose   :
    942  * Parameters:
    943  * Variables :
    944  * Result    :
    945  * Remark    : unknown
    946  * Status    : UNTESTED UNKNOWN STUB
    947  *
    948  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    949  *****************************************************************************/
    950 
    951 DWORD WIN32API SHELL32_145(DWORD x1,
    952                             DWORD x2)
    953 {
    954   dprintf(("SHELL32: .145 (%08xh, %08xh) not implemented.\n",
    955            x1,
    956            x2));
    957 
    958   return (0);
    959 }
    960 
    961 
    962 /*****************************************************************************
    963  * Name      : .43
    964  * Purpose   :
    965  * Parameters:
    966  * Variables :
    967  * Result    :
    968  * Remark    : unknown
    969  * Status    : UNTESTED UNKNOWN STUB
    970  *
    971  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    972  *****************************************************************************/
    973 
    974 DWORD WIN32API SHELL32_43(DWORD x1)
    975 {
    976   dprintf(("SHELL32: .43 (%08xh) not implemented.\n",
    977            x1));
    978 
    979   return (0);
    980 }
    981 
    982 
    983 /*****************************************************************************
    984  * Name      : .51
    985  * Purpose   :
    986  * Parameters:
    987  * Variables :
    988  * Result    :
    989  * Remark    : unknown
    990  * Status    : UNTESTED UNKNOWN STUB
    991  *
    992  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    993  *****************************************************************************/
    994 
    995 DWORD WIN32API SHELL32_51(DWORD x1,
    996                            DWORD x2,
    997                            DWORD x3)
    998 {
    999   dprintf(("SHELL32: .51 (%08xh, %08xh, %08xh) not implemented.\n",
    1000            x1,
    1001            x2,
    1002            x3));
    1003 
    1004   return (0);
    1005 }
    1006 
    1007 
    1008 /*****************************************************************************
    1009  * Name      : .55
    1010  * Purpose   :
    1011  * Parameters:
    1012  * Variables :
    1013  * Result    :
    1014  * Remark    : unknown
    1015  * Status    : UNTESTED UNKNOWN STUB
    1016  *
    1017  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1018  *****************************************************************************/
    1019 
    1020 DWORD WIN32API SHELL32_55(DWORD x1)
    1021 {
    1022   dprintf(("SHELL32: .55 (%08xh) not implemented.\n",
    1023            x1));
    1024 
    1025   return (0);
    1026 }
    1027 
    1028 
    1029 /*****************************************************************************
    1030  * Name      : SetAppStartingCursor
    1031  * Purpose   :
    1032  * Parameters:
    1033  * Variables :
    1034  * Result    :
    1035  * Remark    : SHELL32.99
    1036  * Status    : UNTESTED UNKNOWN STUB
    1037  *
    1038  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1039  *****************************************************************************/
    1040 
    1041 HRESULT WIN32API SetAppStartingCursor(HWND  u,
    1042                                       DWORD v)
    1043 {
    1044   dprintf(("SHELL32: SetAppStartingCursor (SHELL32.99): (%08xh,%08xh) not implemented.\n",
    1045            u,
    1046            v));
    1047 
    1048   return 0;
    1049 }
    1050 
    1051 
    1052 /*****************************************************************************
    1053  * Name      : .102
    1054  * Purpose   :
    1055  * Parameters:
    1056  * Variables :
    1057  * Result    :
    1058  * Remark    : unknown
    1059  * Status    : UNTESTED UNKNOWN STUB
    1060  *
    1061  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1062  *****************************************************************************/
    1063 
    1064 DWORD WIN32API SHELL32_102(DWORD x1,
    1065                             DWORD x2,
    1066                             DWORD x3,
    1067                             DWORD x4,
    1068                             DWORD x5)
    1069 {
    1070   dprintf(("SHELL32: .102 (%08xh, %08xh, %08xh, %08xh, %08xh) not implemented.\n",
     293DWORD WIN32API SHCoCreateInstance(DWORD x1,
     294                                  DWORD x2,
     295                                  DWORD x3,
     296                                  DWORD x4,
     297                                  DWORD x5)
     298{
     299  dprintf(("SHELL32: SHCoCreateInstance (%08xh, %08xh, %08xh, %08xh, %08xh) not implemented.\n",
    1071300           x1,
    1072301           x2,
    … …  
    1077306  return (0);
    1078307}
    1079 
Note: See TracChangeset for help on using the changeset viewer.