Changeset 1214 for trunk/src


Ignore:
Timestamp:
Oct 9, 1999, 1:13:46 PM (26 years ago)
Author:
sandervl
Message:

Moved new shell32 to current dir

Location:
trunk/src/shell32
Files:
47 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/initterm.cpp

    r951 r1214  
    1 /* $Id: initterm.cpp,v 1.7 1999-09-15 23:26:09 sandervl Exp $ */
     1/* $Id: initterm.cpp,v 1.8 1999-10-09 11:13:19 sandervl Exp $ */
    22
    33/*

  • trunk/src/shell32/makefile

    r1118 r1214  
    1 # $Id: makefile,v 1.11 1999-10-04 09:55:59 sandervl Exp $
     1# $Id: makefile,v 1.12 1999-10-09 11:13:19 sandervl Exp $
    22
    33#
    … …  
    2222TARGET = shell32
    2323
    24 OBJS =  shell32.obj sh.obj she.obj drag.obj initterm.obj \
    25         misc.obj ordinal.obj unknown.obj path.obj
     24OBJS =  initterm.obj \
     25        brsfolder.obj classes.obj contmenu.obj dataobject.obj \
     26        enumidlist.obj folders.obj iconcache.obj memorystream.obj \
     27        pidl.obj regstream.obj shell32_main.obj \
     28        shellguid.obj shelllink.obj shlmenu.obj shellole.obj \
     29        shellord.obj shellpath.obj shv_bg_cmenu.obj \
     30        shlfolder.obj shlview.obj shell.obj unknown.obj misc.obj \
     31        she.obj sh.obj
    2632
    2733all: $(TARGET).dll $(TARGET).lib
    … …  
    3238              $(PDWIN32_LIB)/pmwinx.lib $(PDWIN32_LIB)/kernel32.lib \
    3339              $(PDWIN32_LIB)/user32.lib $(PDWIN32_LIB)/advapi32.lib \
     40              $(PDWIN32_LIB)/gdi32.lib $(PDWIN32_LIB)/ole32.lib  \
     41              $(PDWIN32_LIB)/version.lib $(PDWIN32_LIB)/comctl32.lib   \
    3442              $(PDWIN32_LIB)/odincrt.lib OS2386.LIB $(RTLLIB_O)
    3543        $(CP) $@ $(PDWIN32_BIN)
    … …  
    4351        $(IMPDEF) $** $@
    4452
    45 shell32.obj: shell32.cpp shell32.h
    4653
    47 drag.obj: drag.cpp shell32.h
    4854
    49 sh.obj: sh.cpp shell32.h
    50 
    51 she.obj: she.cpp shell32.h
    52 
    53 misc.obj: misc.cpp shell32.h
    54 
    55 ordinal.obj: ordinal.cpp shell32.h
    56 
    57 unknown.obj: unknown.cpp shell32.h
    58 
    59 path.obj: path.cpp shell32.h
    60 
    61 initterm.obj: initterm.cpp
    62 
     55initterm.obj:     initterm.cpp
     56brsfolder.obj:    brsfolder.cpp
     57classes.obj:      classes.cpp
     58contmenu.obj:     contmenu.cpp
     59dataobject.obj:   dataobject.cpp
     60enumidlist.obj:   enumidlist.cpp
     61folders.obj:      folders.cpp
     62iconcache.obj:    iconcache.cpp
     63memorystream.obj: memorystream.cpp
     64pidl.obj:         pidl.cpp
     65regstream.obj:    regstream.cpp
     66shell32_main.obj: shell32_main.cpp
     67shell.obj:        shell.cpp
     68shellguid.obj:    shellguid.cpp
     69shelllink.obj:    shelllink.cpp
     70shlmenu.obj:      shlmenu.cpp
     71shellole.obj:     shellole.cpp
     72shellord.obj:     shellord.cpp
     73shellpath.obj:    shellpath.cpp
     74shlfolder.obj:    shlfolder.cpp
     75shlview.obj:      shlview.cpp
     76shv_bg_cmenu.obj: shv_bg_cmenu.cpp
     77unknown.obj:      unknown.cpp
     78misc.obj:         misc.cpp
     79she.obj:          she.cpp
     80sh.obj:           sh.cpp
    6381
    6482clean:

  • trunk/src/shell32/misc.cpp

    r972 r1214  
    1 /* $Id: misc.cpp,v 1.4 1999-09-18 15:57:51 sandervl Exp $ */
     1/* $Id: misc.cpp,v 1.5 1999-10-09 11:13:19 sandervl Exp $ */
    22
    33/*
    … …  
    1515 *****************************************************************************/
    1616
    17 #include <os2win.h>
    18 #include <shellapi.h>
     17#include <odin.h>
    1918#include <wchar.h>
    2019#include <wcstr.h>
     20
     21#define ICOM_CINTERFACE 1
     22
     23//#include <os2win.h>
     24#include <shellapi.h>
    2125#include <winnls.h>
    22 #include "shell32.h"
     26#include "shell32_main.h"
    2327#include <misc.h>
    24 #include <string.h>
    25 #include "winbase.h"
     28//#include <string.h>
     29//#include "winbase.h"
    2630#include <heapstring.h>
    2731
    … …  
    3034 *****************************************************************************/
    3135
    32 
    33 /*****************************************************************************
    34  * Name      : LPWSTR* WIN32API CommandLineToArgvW
    35  * Purpose   :
    36  * Parameters:
    37  * Variables :
    38  * Result    :
    39  * Remark    :
    40  * Status    : UNTESTED STUB
    41  *
    42  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    43  *****************************************************************************/
    44 
    45 LPWSTR * WIN32API CommandLineToArgvW(LPCWSTR lpCmdLine,
    46                                      int     *pNumArgs)
    47 {
    48   LPWSTR *argv, s, t;
    49   int     i;
    50 
    51   dprintf(("SHELL32: CommandLineToArgvW(%s,%08xh)\n",
    52            lpCmdLine,
    53            pNumArgs));
    54 
    55   s = (LPWSTR)lpCmdLine;
    56   i = 0;
    57   while (*s) {
    58     /* space */
    59     if (*s==0x0020) {
    60         i++;
    61         s++;
    62         while (*s && *s==0x0020)
    63             s++;
    64         continue;
    65     }
    66     s++;
    67   }
    68   argv = (LPWSTR *)LocalAlloc(LPTR, sizeof(LPWSTR)*(i+1));
    69   s = t = (LPWSTR)lpCmdLine;
    70   i = 0;
    71   while(*s) {
    72     if (*s==0x0020) {
    73         *s=0;
    74         argv[i++] = t;
    75         *s=0x0020;
    76         while (*s && *s==0x0020)
    77             s++;
    78         if(*s)
    79             t=s+1;
    80         else    t=s;
    81         continue;
    82     }
    83     s++;
    84   }
    85   if(*t)
    86     argv[i++] = t;
    87 
    88   argv[i]=NULL;
    89   *pNumArgs = i;
    90   return argv;
    91 }
    92 
    93 
    94 /*****************************************************************************
    95  * Name      : HICON WIN32API ExtractIconA
    96  * Purpose   :
    97  * Parameters:
    98  * Variables :
    99  * Result    :
    100  * Remark    :
    101  * Status    : UNTESTED STUB
    102  *
    103  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    104  *****************************************************************************/
    105 
    106 HICON WIN32API ExtractIconA(HINSTANCE hInst,
    107                             LPCSTR    lpszExeFileName,
    108                             UINT      nIconIndex)
    109 {
    110   dprintf(("SHELL32: ExtractIconA(%08xh,%s,%08xh) not implemented.\n",
    111            hInst,
    112            lpszExeFileName,
    113            nIconIndex));
    114 
    115   return(NULL);
    116 }
    117 
    118 
    119 /*****************************************************************************
    120  * Name      : HICON WIN32API ExtractIconW
    121  * Purpose   :
    122  * Parameters:
    123  * Variables :
    124  * Result    :
    125  * Remark    :
    126  * Status    : UNTESTED STUB
    127  *
    128  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    129  *****************************************************************************/
    130 
    131 HICON WIN32API ExtractIconW(HINSTANCE hInst,
    132                                LPCWSTR   lpszExeFileName,
    133                                UINT      nIconIndex)
    134 {
    135   HICON hicon = NULL;
    136   char *astring = UnicodeToAsciiString((LPWSTR)lpszExeFileName);
    137 
    138   dprintf(("SHELL32: ExtractIconW(%08xh,%s,%08xh) not implemented.\n",
    139            hInst,
    140            lpszExeFileName,
    141            nIconIndex));
    142 
    143 
    144   FreeAsciiString(astring);
    145   return(hicon);
    146 }
    147 
    148 
    149 /*****************************************************************************
    150  * Name      : HICON WIN32API ExtractIconExA
    151  * Purpose   :
    152  * Parameters:
    153  * Variables :
    154  * Result    :
    155  * Remark    :
    156  * Status    : UNTESTED STUB
    157  *
    158  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    159  *****************************************************************************/
    160 
    161 DWORD WIN32API ExtractIconExA(LPCSTR lpszFile,
    162                               int    nIconIndex,
    163                               HICON  *phiconLarge,
    164                               HICON  *phiconSmall,
    165                               UINT   nIcons)
    166 {
    167   dprintf(("SHELL32: ExtractIconExA(%s,%08xh,%08xh,%08xh,%u) not implemented.\n",
    168            lpszFile,
    169            nIconIndex,
    170            phiconLarge,
    171            phiconSmall,
    172            nIcons));
    173 
    174   return (0);
    175 }
    176 
    177 
    178 /*****************************************************************************
    179  * Name      : HICON WIN32API ExtractIconExW
    180  * Purpose   :
    181  * Parameters:
    182  * Variables :
    183  * Result    :
    184  * Remark    :
    185  * Status    : UNTESTED STUB
    186  *
    187  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    188  *****************************************************************************/
    189 
    190 HICON WIN32API ExtractIconExW(LPCWSTR lpszFile,
    191                               int    nIconIndex,
    192                               HICON  *phiconLarge,
    193                               HICON  *phiconSmall,
    194                               UINT   nIcons)
    195 {
    196   dprintf(("SHELL32: ExtractIconExW(%s,%08xh,%08xh,%08xh,%u) not implemented.\n",
    197            lpszFile,
    198            nIconIndex,
    199            phiconLarge,
    200            phiconSmall,
    201            nIcons));
    202 
    203   return (0);
    204 }
    205 
    206 
    207 /*****************************************************************************
    208  * Name      : HINSTANCE WIN32API FindExecutableA
    209  * Purpose   :
    210  * Parameters:
    211  * Variables :
    212  * Result    :
    213  * Remark    :
    214  * Status    : UNTESTED STUB
    215  *
    216  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    217  *****************************************************************************/
    218 
    219 HINSTANCE WIN32API FindExecutableA(LPCSTR lpszFile,
    220                                    LPCSTR lpszDir,
    221                                    LPTSTR lpszResult)
    222 {
    223   dprintf(("SHELL32: FindExecutableA (%s,%s,%s) not implemented.\n",
    224            lpszFile,
    225            lpszDir,
    226            lpszResult));
    227 
    228   return(NULL);
    229 }
    230 
    231 
    232 /*****************************************************************************
    233  * Name      : HINSTANCE WIN32API FindExecutableW
    234  * Purpose   :
    235  * Parameters:
    236  * Variables :
    237  * Result    :
    238  * Remark    :
    239  * Status    : UNTESTED STUB
    240  *
    241  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    242  *****************************************************************************/
    243 
    244 HINSTANCE WIN32API FindExecutableW(LPCWSTR lpszFile,
    245                                    LPCWSTR lpszDir,
    246                                    LPWSTR  lpszResult)
    247 {
    248   dprintf(("SHELL32: FindExecutableW (%s,%s,%s) not implemented.\n",
    249            lpszFile,
    250            lpszDir,
    251            lpszResult));
    252 
    253   return(NULL);
    254 }
    255 
    256 
    257 /*****************************************************************************
    258  * Name      : HICON WIN32API ExtractAssociatedIconA
    259  * Purpose   : Return icon for given file (either from file itself or from associated
    260  *             executable) and patch parameters if needed.
    261  * Parameters:
    262  * Variables :
    263  * Result    :
    264  * Remark    : SHELL.36
    265  * Status    : UNTESTED STUB
    266  *
    267  * Author    : Patrick Haller [Sat, 1998/07/11 11:55]
    268  *****************************************************************************/
    269 
    270 HICON WIN32API ExtractAssociatedIconA(HINSTANCE hInst,
    271                                       LPSTR     lpIconPath,
    272                                       LPWORD    lpiIcon)
    273 {
    274   HICON hIcon;
    275 
    276   dprintf(("SHELL32: ExtractAssociatedIconA(%08xh,%s,%08xh)\n",
    277            hInst,
    278            lpIconPath,
    279            lpiIcon));
    280 
    281   hIcon = ExtractIconA(hInst,
    282                        lpIconPath,
    283                        *lpiIcon);
    284 
    285   if( hIcon < 2 )
    286   {
    287     if( hIcon == 1 ) /* no icons found in given file */
    288     {
    289       char tempPath[0x80];
    290       UINT uRet = FindExecutableA(lpIconPath,
    291                                   NULL,
    292                                   tempPath);
    293 
    294       if(uRet > 32 && tempPath[0])
    295       {
    296         strcpy(lpIconPath,tempPath);
    297         hIcon = ExtractIconA(hInst,
    298                              lpIconPath,
    299                              *lpiIcon);
    300         if( hIcon > 2 )
    301           return hIcon;
    302       }
    303       else
    304         hIcon = 0;
    305      }
    306 
    307      if( hIcon == 1 )
    308        *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
    309      else
    310        *lpiIcon = 6;   /* generic icon - found nothing */
    311 
    312      /* @@@PH - how is this supposed to work ?
    313      GetModuleFileNameA(hInst,
    314                         lpIconPath,
    315                         0x80);
    316      hIcon = LoadIconA(hInst,
    317                        *lpiIcon);
    318       */
    319   }
    320   return hIcon;
    321 }
    32236
    32337/*****************************************************************************
    … …  
    397111
    398112  return ExtractAssociatedIconW(hInst,lpIconPath,lpiIcon);
    399 }
    400 
    401 /*****************************************************************************
    402  * Name      : ParseField
    403  * Purpose   :
    404  * Parameters:
    405  * Variables :
    406  * Result    :
    407  * Remark    : SHELL32.58
    408  * Status    : UNTESTED UNKNOWN STUB
    409  *
    410  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    411  *****************************************************************************/
    412 
    413 DWORD WIN32API ParseFieldA(LPCSTR src,
    414                            DWORD  field,
    415                            LPSTR  dst,
    416                            DWORD  len)
    417 {
    418   dprintf(("SHELL32: ParseFieldA(%s,%08xh,%08xh,%08xh) not correctly implemented.\n",
    419            src,
    420            field,
    421            dst,
    422            len));
    423 
    424   if (!src || !src[0] || !dst || !len)
    425     return 0;
    426 
    427   if (field >1)
    428   {
    429     field--;
    430     while (field)
    431     {
    432       if (*src==0x0) return FALSE;
    433       if (*src==',') field--;
    434       src++;
    435     }
    436   }
    437 
    438   while (*src!=0x00 && *src!=',' && len>0)
    439   {
    440     *dst=*src; dst++, src++; len--;
    441   }
    442   *dst=0x0;
    443   return TRUE;
    444 }
    445 
    446 
    447 /*****************************************************************************
    448  * Name      : PickIconDlg
    449  * Purpose   :
    450  * Parameters:
    451  * Variables :
    452  * Result    :
    453  * Remark    : SHELL32.62
    454  * Status    : UNTESTED UNKNOWN STUB
    455  *
    456  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    457  *****************************************************************************/
    458 
    459 DWORD WIN32API PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
    460 {
    461   dprintf(("SHELL32: PickIconDlg(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    462            x,
    463            y,
    464            z,
    465            a));
    466 
    467   return 0xffffffff;
    468 }
    469 
    470 
    471 /*****************************************************************************
    472  * Name      : GetFileNameFromBrowse
    473  * Purpose   :
    474  * Parameters:
    475  * Variables :
    476  * Result    :
    477  * Remark    : SHELL32.63
    478  * Status    : UNTESTED UNKNOWN STUB
    479  *
    480  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    481  *****************************************************************************/
    482 
    483 DWORD WIN32API GetFileNameFromBrowse(HWND   howner,
    484                                      LPSTR  targetbuf,
    485                                      DWORD  len,
    486                                      DWORD  x,
    487                                      LPCSTR suffix,
    488                                      LPCSTR y,
    489                                      LPCSTR cmd)
    490 {
    491   dprintf(("SHELL32: GetFileNameFromBrowse(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    492            howner,
    493            targetbuf,
    494            len,
    495            x,
    496            suffix,
    497            y,
    498            cmd));
    499 
    500   /* puts up a Open Dialog and requests input into targetbuf */
    501   /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
    502   strcpy(targetbuf,
    503          "x:\\dummy.exe");
    504 
    505   return 1;
    506113}
    507114
    … …  
    570177                              lpWide,
    571178                              nWide);
    572 }
    573 
    574 
    575 /*****************************************************************************
    576  * Name      : RegisterShellHook
    577  * Purpose   :
    578  * Parameters:
    579  * Variables :
    580  * Result    :
    581  * Remark    : SHELL32.181
    582  * Status    : UNTESTED UNKNOWN STUB
    583  *
    584  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    585  *
    586  * PARAMS
    587  *      hwnd [I]  window handle
    588  *      y    [I]  flag ????
    589  *
    590  * NOTES
    591  *     exported by ordinal
    592  */
    593 
    594 void WIN32API RegisterShellHook(HWND  hwnd,
    595                                 DWORD y)
    596 {
    597   dprintf(("SHELL32: RegisterShellHook(%08xh, %08xh) not implemented.\n",
    598            hwnd,
    599            y));
    600 }
    601 
    602 
    603 /*****************************************************************************
    604  * Name      : RunFileDlg
    605  * Purpose   :
    606  * Parameters:
    607  * Variables :
    608  * Result    :
    609  * Remark    : SHELL32.61
    610  * Status    : UNTESTED UNKNOWN STUB
    611  *
    612  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    613  *****************************************************************************/
    614 
    615 DWORD WIN32API RunFileDlg (HWND  hwndOwner,
    616                            DWORD dwParam1,
    617                            DWORD dwParam2,
    618                            LPSTR lpszTitle,
    619                            LPSTR lpszPrompt,
    620                            UINT  uFlags)
    621 {
    622   dprintf(("SHELL32: RunFileDlg(%08xh,%08xh,%08xh,%s,%s,%08xh) not implemented.\n",
    623            hwndOwner,
    624            dwParam1,
    625            dwParam2,
    626            lpszTitle,
    627            lpszPrompt,
    628            uFlags));
    629 
    630   return 0;
    631 }
    632 
    633 
    634 /*****************************************************************************
    635  * Name      : ExitWindowsDialog
    636  * Purpose   :
    637  * Parameters:
    638  * Variables :
    639  * Result    :
    640  * Remark    : SHELL32.60
    641  * Status    : UNTESTED UNKNOWN STUB
    642  *
    643  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    644  *****************************************************************************/
    645 
    646 void WIN32API ExitWindowsDialog (HWND hWndOwner)
    647 {
    648   dprintf(("SHELL32: ExitWindowsDialog(%08xh)\n",
    649            hWndOwner));
    650 
    651    if (MessageBoxA(hWndOwner,
    652                    "Do you want to exit ODIN?",
    653                    "Shutdown",
    654                    MB_YESNO|MB_ICONQUESTION)
    655        == IDOK)
    656    {
    657      SendMessageA (hWndOwner,
    658                    WM_QUIT,
    659                    0,
    660                    0);
    661    }
    662 }
    663 
    664 
    665 /*****************************************************************************
    666  * Name      : ArrangeWindows
    667  * Purpose   :
    668  * Parameters:
    669  * Variables :
    670  * Result    :
    671  * Remark    : SHELL32.184
    672  * Status    : UNTESTED UNKNOWN STUB
    673  *
    674  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    675  *****************************************************************************/
    676 
    677 DWORD WIN32API ArrangeWindows (DWORD dwParam1,
    678                                DWORD dwParam2,
    679                                DWORD dwParam3,
    680                                DWORD dwParam4,
    681                                DWORD dwParam5)
    682 {
    683   dprintf(("SHELL32: ArrangeWindows(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    684            dwParam1,
    685            dwParam2,
    686            dwParam3,
    687            dwParam4,
    688            dwParam5));
    689 
    690   return 0;
    691 }
    692 
    693 
    694 /*****************************************************************************
    695  * Name      : SignalFileOpen
    696  * Purpose   :
    697  * Parameters:
    698  * Variables :
    699  * Result    :
    700  * Remark    : SHELL32.103
    701  * Status    : UNTESTED UNKNOWN STUB
    702  *
    703  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    704  *****************************************************************************/
    705 
    706 DWORD WIN32API SignalFileOpen (DWORD dwParam1)
    707 {
    708   dprintf(("SHELL32: SignalFileOpen(%08xh) not implemented.\n",
    709            dwParam1));
    710 
    711   return 0;
    712 }
    713 
    714 
    715 /*****************************************************************************
    716  * Name      : DAD_ShowDrawImage
    717  * Purpose   :
    718  * Parameters:
    719  * Variables :
    720  * Result    :
    721  * Remark    : SHELL32.137
    722  * Status    : UNTESTED UNKNOWN STUB
    723  *
    724  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    725  *****************************************************************************/
    726 
    727 HRESULT WIN32API DAD_ShowDragImage (DWORD u)
    728 {
    729   dprintf(("SHELL32: DAD_ShowDragImage(%08xh) not implemented.\n",
    730            u));
    731 
    732   return 0;
    733 }
    734 
    735 
    736 /*****************************************************************************
    737  * Name      : ReadCabinetState
    738  * Purpose   :
    739  * Parameters:
    740  * Variables :
    741  * Result    :
    742  * Remark    : SHELL32.651
    743  * Status    : UNTESTED UNKNOWN STUB
    744  *
    745  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    746  *****************************************************************************/
    747 
    748 HRESULT WIN32API ReadCabinetState(DWORD u,
    749                                   DWORD v)
    750 {
    751   dprintf(("SHELL32: ReadCabinetState(%08xh, %08xh) not implemented.\n",
    752            u,
    753            v));
    754 
    755   return 0;
    756 }
    757 
    758 
    759 /*****************************************************************************
    760  * Name      : WriteCabinetState
    761  * Purpose   :
    762  * Parameters:
    763  * Variables :
    764  * Result    :
    765  * Remark    : SHELL32.652
    766  * Status    : UNTESTED UNKNOWN STUB
    767  *
    768  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    769  *****************************************************************************/
    770 
    771 HRESULT WIN32API WriteCabinetState(DWORD u)
    772 {
    773   dprintf(("SHELL32: WriteCabinetState(%08xh) not implemented.\n",
    774            u));
    775 
    776   return 0;
    777 }
    778 
    779 
    780 /*****************************************************************************
    781  * Name      : FileIconInit
    782  * Purpose   :
    783  * Parameters:
    784  * Variables :
    785  * Result    :
    786  * Remark    : SHELL32.660
    787  * Status    : UNTESTED UNKNOWN STUB
    788  *
    789  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    790  *****************************************************************************/
    791 
    792 BOOL WIN32API FileIconInit(BOOL bFullInit)
    793 {
    794   dprintf(("SHELL32: FileIconInit(%08xh) not implemented.\n",
    795            bFullInit));
    796 
    797   return 0;
    798 }
    799 
    800 
    801 /*****************************************************************************
    802  * Name      : IsUserAdmin
    803  * Purpose   :
    804  * Parameters:
    805  * Variables :
    806  * Result    :
    807  * Remark    : SHELL32.680
    808  * Status    : UNTESTED UNKNOWN STUB
    809  *
    810  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    811  *****************************************************************************/
    812 
    813 HRESULT WIN32API IsUserAdmin(void)
    814 {
    815   dprintf(("SHELL32: IsUserAdmin() not implmented. Yes, user is admin ;-)\n"));
    816 
    817   return TRUE;
    818179}
    819180
    … …  
    888249}
    889250
    890 /*****************************************************************************
    891  * Name      : StrChrW
    892  * Purpose   :
    893  * Parameters:
    894  * Variables :
    895  * Result    :
    896  * Remark    : SHELL32.651
    897  * Status    : UNTESTED UNKNOWN STUB
    898  *
    899  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    900  *****************************************************************************/
    901 
    902 LPWSTR WIN32API StrChrW (LPWSTR str,
    903                          WCHAR  x)
    904 {
    905   dprintf (("SHELL32: StrChrW(%08xh, %08xh)\n",
    906             str,
    907             x));
    908 
    909   return ((LPWSTR)wcschr((const wchar_t*)str,
    910                          x));
    911 }
    912 
    913 
    914 /*****************************************************************************
    915  * Name      : StrChrNIW
    916  * Purpose   :
    917  * Parameters:
    918  * Variables :
    919  * Result    :
    920  * Remark    : SHELL32.?
    921  * Status    : UNTESTED UNKNOWN STUB
    922  *
    923  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    924  *****************************************************************************/
    925 
    926 INT WIN32API StrCmpNIW (LPWSTR wstr1,
    927                         LPWSTR wstr2,
    928                         INT    len)
    929 {
    930   dprintf(("SHELL32: StrCmpNIW(%08xh,%08xh,%08xh) not correctly implemented.\n",
    931            wstr1,
    932            wstr2,
    933            len));
    934 
    935   return (wcsncmp((const wchar_t*)wstr1,
    936                   (const wchar_t*)wstr2,
    937                   len));
    938 }
    939 
    940 
    941 /*****************************************************************************
    942  * Name      : DriveType
    943  * Purpose   :
    944  * Parameters:
    945  * Variables :
    946  * Result    :
    947  * Remark    : SHELL32.64
    948  * Status    : UNTESTED UNKNOWN STUB
    949  *
    950  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    951  *****************************************************************************/
    952 
    953 HRESULT WIN32API DriveType(DWORD u)
    954 {
    955   dprintf(("SHELL32: DriveType(%08xh) not implemented.\n",
    956            u));
    957 
    958   return 0;
    959 }
    960 
    961 
    962 /*****************************************************************************
    963  * Name      : StrRChrW
    964  * Purpose   :
    965  * Parameters:
    966  * Variables :
    967  * Result    :
    968  * Remark    : SHELL32.320, wcsrchr does not work?
    969  * Status    : UNTESTED UNKNOWN STUB
    970  *
    971  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    972  *****************************************************************************/
    973 
    974 LPWSTR WIN32API StrRChrW(LPWSTR lpStart,
    975                          LPWSTR lpEnd,
    976                          DWORD  wMatch)
    977 {
    978   LPWSTR wptr=NULL;
    979 
    980   dprintf(("SHELL32: StrRChrW(%08xh,%08xh,%08xh)\n",
    981            lpStart,
    982            lpEnd,
    983            wMatch));
    984 
    985   /* if the end not given, search*/
    986   if (!lpEnd)
    987   {
    988     lpEnd=lpStart;
    989     while (*lpEnd)
    990       lpEnd++;
    991   }
    992 
    993   do
    994   {
    995     if (*lpStart==(WCHAR)wMatch)
    996       wptr = lpStart;
    997     lpStart++;
    998   }
    999   while ( lpStart<=lpEnd );
    1000   return wptr;
    1001 }
    1002 
    1003 
    1004 /*****************************************************************************
    1005  * Name      : Control_FillCache_RunDLL
    1006  * Purpose   :
    1007  * Parameters:
    1008  * Variables :
    1009  * Result    :
    1010  * Remark    : SHELL32.8
    1011  * Status    : UNTESTED UNKNOWN STUB
    1012  *
    1013  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1014  *****************************************************************************/
    1015 
    1016 HRESULT WIN32API Control_FillCache_RunDLL(HWND   hWnd,
    1017                                           HANDLE hModule,
    1018                                           DWORD  w,
    1019                                           DWORD  x)
    1020 {
    1021   dprintf(("SHELL32: Control_FillCache_RunDLL(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1022            hWnd,
    1023            hModule,
    1024            w,
    1025            x));
    1026 
    1027   return 0;
    1028 }
    1029 
    1030 
    1031 /*****************************************************************************
    1032  * Name      : RunDLL_CallEntry16
    1033  * Purpose   :
    1034  * Parameters:
    1035  * Variables :
    1036  * Result    :
    1037  * Remark    : SHELL32.122 - the name is propably wrong
    1038  * Status    : UNTESTED UNKNOWN STUB
    1039  *
    1040  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1041  *****************************************************************************/
    1042 
    1043 HRESULT WIN32API RunDLL_CallEntry16(DWORD v,
    1044                                     DWORD w,
    1045                                     DWORD x,
    1046                                     DWORD y,
    1047                                     DWORD z)
    1048 {
    1049   dprintf(("SHELL32: RunDLL_CallEntry16(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1050            v,
    1051            w,
    1052            x,
    1053            y,
    1054            z));
    1055 
    1056   return 0;
    1057 }
    1058 
    1059251
    1060252/*****************************************************************************
    … …  
    1076268           x,
    1077269           y));
    1078   return 0;
    1079 }
    1080 
    1081 
    1082 /*****************************************************************************
    1083  * Name      : RLBuildListOfPaths
    1084  * Purpose   :
    1085  * Parameters:
    1086  * Variables :
    1087  * Result    :
    1088  * Remark    : SHELL32.146 - builds a DPA
    1089  * Status    : UNTESTED UNKNOWN STUB
    1090  *
    1091  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1092  *****************************************************************************/
    1093 
    1094 DWORD WIN32API RLBuildListOfPaths ()
    1095 {
    1096   dprintf(("SHELL32: RLBuildListOfPaths() not implemented.\n"));
    1097270  return 0;
    1098271}
    … …  
    1128301
    1129302/*****************************************************************************
    1130  * Name      : SetAppStartingCursor
    1131  * Purpose   :
    1132  * Parameters:
    1133  * Variables :
    1134  * Result    :
    1135  * Remark    : SHELL32.99
    1136  * Status    : UNTESTED UNKNOWN STUB
    1137  *
    1138  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1139  *****************************************************************************/
    1140 
    1141 HRESULT WIN32API SetAppStartingCursor(HWND  u,
    1142                                       DWORD v)
    1143 {
    1144   dprintf(("SHELL32: SetAppStartingCursor (SHELL32.99): (%08xh,%08xh) not implemented.\n",
    1145            u,
    1146            v));
    1147 
    1148   return 0;
    1149 }
    1150 
    1151 /*****************************************************************************
    1152303 * Name      : StrCpyNW
    1153304 * Purpose   :
    … …  
    1187338}
    1188339
    1189 /*****************************************************************************
    1190  * Name      : FreeIconList
    1191  * Purpose   :
    1192  * Parameters:
    1193  * Variables :
    1194  * Result    :
    1195  * Remark    : SHELL32.220 - used by progman.exe
    1196  * Status    : UNTESTED UNKNOWN STUB
    1197  *
    1198  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1199  *****************************************************************************/
    1200 
    1201 void WIN32API FreeIconList(DWORD dw)
    1202 {
    1203   dprintf(("SHELL32: undoc FreeIconList %08xh\n",dw));
    1204 }
    1205340
    1206341/*****************************************************************************
    … …  
    1294429}
    1295430
    1296 /*****************************************************************************
    1297  * Name      : DoEnvironmentSubstA
    1298  * Purpose   :
    1299  * Parameters: ??? ported WINE 16 bit function
    1300  * Variables :
    1301  * Result    :
    1302  * Remark    : SHELL32.44 - used by progman.exe
    1303  * Status    : UNTESTED UNKNOWN STUB
    1304  *
    1305  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1306  *****************************************************************************/
    1307 
    1308 DWORD WIN32API DoEnvironmentSubstA(LPSTR str,DWORD length)
    1309 {
    1310   LPSTR   lpEnv = (LPSTR)GetEnvironmentStringsA();
    1311   LPSTR   lpBuffer = (LPSTR)HeapAlloc( GetProcessHeap(), 0, length);
    1312   LPSTR   lpstr = str;
    1313   LPSTR   lpbstr = lpBuffer;
    1314 
    1315   dprintf(("SHELL32: undoc DoEnvironmentSubstA\n"));
    1316 
    1317   CharToOemA(str,str);
    1318 
    1319   while( *lpstr && lpbstr - lpBuffer < length )
    1320    {
    1321      LPSTR lpend = lpstr;
    1322 
    1323      if( *lpstr == '%' )
    1324        {
    1325           do { lpend++; } while( *lpend && *lpend != '%' );
    1326           if( *lpend == '%' && lpend - lpstr > 1 )      /* found key */
    1327             {
    1328                LPSTR lpKey;
    1329               *lpend = '\0';
    1330                lpKey = SHELL_FindStringA(lpEnv, lpstr+1);
    1331                if( lpKey )                              /* found key value */
    1332                  {
    1333                    int l = strlen(lpKey);
    1334 
    1335                    if( l > length - (lpbstr - lpBuffer) - 1 )
    1336                      {
    1337            //WARN_(shell)("-- Env subst aborted - string too short\n");
    1338                       *lpend = '%';
    1339                        break;
    1340                      }
    1341                    strcpy(lpbstr, lpKey);
    1342                    lpbstr += l;
    1343                  }
    1344                else break;
    1345               *lpend = '%';
    1346                lpstr = lpend + 1;
    1347             }
    1348           else break;                                   /* back off and whine */
    1349 
    1350           continue;
    1351        }
    1352 
    1353      *lpbstr++ = *lpstr++;
    1354    }
    1355 
    1356  *lpbstr = '\0';
    1357   if( lpstr - str == strlen(str) )
    1358     {
    1359       strncpy(str, lpBuffer, length);
    1360       length = 1;
    1361     }
    1362   else
    1363       length = 0;
    1364 
    1365   //TRACE_(shell)("-- return %s\n", str);
    1366 
    1367   OemToCharA(str,str);
    1368   HeapFree( GetProcessHeap(), 0, lpBuffer);
    1369 
    1370   FreeEnvironmentStringsA(lpEnv);
    1371 
    1372   /*  Return str length in the LOWORD
    1373    *  and 1 in HIWORD if subst was successful.
    1374    */
    1375 
    1376  return (DWORD)MAKELONG(strlen(str), length);
    1377 }
    1378 
    1379 /*****************************************************************************
    1380  * Name      : DoEnvironmentSubstW
    1381  * Purpose   :
    1382  * Parameters: ???
    1383  * Variables :
    1384  * Result    :
    1385  * Remark    : SHELL32.193 - used by progman.exe
    1386  * Status    : UNTESTED UNKNOWN STUB
    1387  *
    1388  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1389  *****************************************************************************/
    1390 
    1391 DWORD WIN32API DoEnvironmentSubstW(LPWSTR str,DWORD length)
    1392 {
    1393   //CB: call DoEnvironmentSubstW
    1394   dprintf(("SHELL32: undoc DoEnvironmentSubstW\n"));
     431
     432/*****************************************************************************
     433 * Name      : CheckEscapesA
     434 * Purpose   :
     435 * Parameters: ???
     436 * Variables :
     437 * Result    :
     438 * Remark    : SHELL32.3 - used by progman.exe
     439 * Status    : UNTESTED UNKNOWN STUB
     440 *
     441 * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
     442 *****************************************************************************/
     443
     444void WIN32API CheckEscapesA(DWORD x1,DWORD x2)
     445{
     446  dprintf(("SHELL32: undoc CheckEscapesA\n"));
     447}
     448
     449/*****************************************************************************
     450 * Name      : CheckEscapesW
     451 * Purpose   :
     452 * Parameters: ???
     453 * Variables :
     454 * Result    :
     455 * Remark    : SHELL32.6 - used by progman.exe
     456 * Status    : UNTESTED UNKNOWN STUB
     457 *
     458 * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
     459 *****************************************************************************/
     460
     461void WIN32API CheckEscapesW(DWORD x1,DWORD x2)
     462{
     463  dprintf(("SHELL32: undoc CheckEscapesW\n"));
     464}
     465
     466/*****************************************************************************
     467 * Name      : DuplicateIcon
     468 * Purpose   :
     469 * Parameters: ???
     470 * Variables :
     471 * Result    :
     472 * Remark    : SHELL32.138 - used by progman.exe
     473 * Status    : UNTESTED UNKNOWN STUB
     474 *
     475 * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
     476 *****************************************************************************/
     477
     478DWORD WIN32API DuplicateIcon(DWORD x1)
     479{
     480  dprintf(("SHELL32: undoc DuplicateIcon\n"));
    1395481
    1396482  return 0;
    1397483}
    1398 
    1399 /*****************************************************************************
    1400  * Name      : CheckEscapesA
    1401  * Purpose   :
    1402  * Parameters: ???
    1403  * Variables :
    1404  * Result    :
    1405  * Remark    : SHELL32.3 - used by progman.exe
    1406  * Status    : UNTESTED UNKNOWN STUB
    1407  *
    1408  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1409  *****************************************************************************/
    1410 
    1411 void WIN32API CheckEscapesA(DWORD x1,DWORD x2)
    1412 {
    1413   dprintf(("SHELL32: undoc CheckEscapesA\n"));
    1414 }
    1415 
    1416 /*****************************************************************************
    1417  * Name      : CheckEscapesW
    1418  * Purpose   :
    1419  * Parameters: ???
    1420  * Variables :
    1421  * Result    :
    1422  * Remark    : SHELL32.6 - used by progman.exe
    1423  * Status    : UNTESTED UNKNOWN STUB
    1424  *
    1425  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1426  *****************************************************************************/
    1427 
    1428 void WIN32API CheckEscapesW(DWORD x1,DWORD x2)
    1429 {
    1430   dprintf(("SHELL32: undoc CheckEscapesW\n"));
    1431 }
    1432 
    1433 /*****************************************************************************
    1434  * Name      : DuplicateIcon
    1435  * Purpose   :
    1436  * Parameters: ???
    1437  * Variables :
    1438  * Result    :
    1439  * Remark    : SHELL32.138 - used by progman.exe
    1440  * Status    : UNTESTED UNKNOWN STUB
    1441  *
    1442  * Author    : Christoph Bratschi [Fri, 1999/08/6 19:00]
    1443  *****************************************************************************/
    1444 
    1445 DWORD WIN32API DuplicateIcon(DWORD x1)
    1446 {
    1447   dprintf(("SHELL32: undoc DuplicateIcon\n"));
    1448 
    1449   return 0;
    1450 }

  • trunk/src/shell32/sh.cpp

    r972 r1214  
    1 /* $Id: sh.cpp,v 1.8 1999-09-18 15:57:52 sandervl Exp $ */
     1/* $Id: sh.cpp,v 1.9 1999-10-09 11:13:20 sandervl Exp $ */
    22
    33/*
    … …  
    1515#include <shellapi.h>
    1616#include <winreg.h>
    17 #include "shell32.h"
    18 
    1917#include <stdarg.h>
    2018//#include <builtin.h>
    … …  
    2321#include <string.h>
    2422
     23#define ICOM_CINTERFACE 1
     24#include "shell32_main.h"
     25#include <win\shlobj.h>
    2526#include <misc.h>
     27//#include <nameid.h>
     28#include <unicode.h>
    2629
    2730
    … …  
    3235#define LPSHELLVIEWDATA  LPVOID
    3336#define LPUNKNOWN        LPVOID
    34 #define IDSTRUCT         VOID
     37//#define IDSTRUCT         VOID
    3538#define IDropTarget      VOID
    3639
    3740static LPUNKNOWN SHELL32_IExplorerInterface=0;
    3841
    39 
    40 /*****************************************************************************
    41  * Name      : DWORD WIN32API SHChangeNotifyRegister
    42  * Purpose   :
    43  * Parameters:
    44  * Variables :
    45  * Result    :
    46  * Remark    : SHELL32.2
    47  * Status    : UNTESTED STUB
    48  *
    49  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    50  *
    51  * NOTES
    52  *   Idlist is an array of structures and Count specifies how many items in the array
    53  *   (usually just one I think).
    54  */
    55 
    56 DWORD WIN32API SHChangeNotifyRegister(HWND hwnd,
    57                                       LONG events1,
    58                                       LONG events2,
    59                                       DWORD msg,
    60                                       int count,
    61                                       IDSTRUCT *idlist)
    62 {
    63   dprintf(("SHELL32: SHChangeNotifyRegister(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    64            hwnd,
    65            events1,
    66            events2,
    67            msg,
    68            count,
    69            idlist));
    70 
    71   return 0;
    72 }
    73 
    74 
    75 /*****************************************************************************
    76  * Name      : DWORD WIN32API SHChangeNotifyDeregister
    77  * Purpose   :
    78  * Parameters:
    79  * Variables :
    80  * Result    :
    81  * Remark    : SHELL32.4
    82  * Status    : UNTESTED STUB
    83  *
    84  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    85  */
    86 
    87 DWORD WIN32API SHChangeNotifyDeregister(LONG x1)
    88 {
    89   dprintf(("SHELL32: SHChangeNotifyDeregister(%08xh) not implemented.\n",
    90            x1));
    91 
    92   return 0;
    93 }
    94 
    95 
    96 /*****************************************************************************
    97  * Name      : void WIN32API SHGetSettings
    98  * Purpose   :
    99  * Parameters:
    100  * Variables :
    101  * Result    :
    102  * Remark    : SHELL32.68
    103  * Status    : UNTESTED STUB
    104  *
    105  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    106  *
    107  * NOTES
    108  *  the registry path are for win98 (tested)
    109  *  and possibly are the same in nt40
    110  */
    111 
    112 void WIN32API SHGetSettings(LPSHELLFLAGSTATE lpsfs,
    113                             DWORD            dwMask,
    114                             DWORD            dwx)
    115 {
    116   HKEY  hKey;
    117   DWORD dwData;
    118   DWORD dwDataSize = sizeof (DWORD);
    119 
    120   dprintf(("SHELL32: SHGetSettings(%08xh, %08xh, %08xh)\n",
    121            lpsfs,
    122            dwMask,
    123            dwx));
    124 
    125   if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
    126             0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
    127     return;
    128 
    129    if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    130      lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
    131 
    132    if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    133      lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
    134 
    135    if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    136      lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
    137 
    138    if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    139      lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
    140 
    141    if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    142      lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
    143 
    144    if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    145      lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
    146 
    147    if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    148    { if (dwData == 0)
    149      { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 0;
    150        if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 0;
    151      }
    152      else if (dwData == 1)
    153      { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 1;
    154        if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 0;
    155      }
    156      else if (dwData == 2)
    157      { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 0;
    158        if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 1;
    159      }
    160    }
    161 
    162   RegCloseKey (hKey);
    163 }
    164 
    165 
    166 /*****************************************************************************
    167  * Name      : int WIN32API SHShellFolderView_Message
    168  * Purpose   :
    169  * Parameters:
    170  * Variables :
    171  * Result    :
    172  * Remark    : SHELL32.73
    173  * Status    : UNTESTED STUB
    174  *
    175  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    176  *
    177  * SHShellFolderView_Message                   [SHELL32.73]
    178  *
    179  * PARAMETERS
    180  *  hwndCabinet defines the explorer cabinet window that contains the
    181  *              shellview you need to communicate with
    182  *  uMsg        identifying the SFVM enum to perform
    183  *  lParam
    184  *
    185  * NOTES
    186  *  Message SFVM_REARRANGE = 1
    187  *    This message gets sent when a column gets clicked to instruct the
    188  *    shell view to re-sort the item list. lParam identifies the column
    189  *    that was clicked.
    190  */
    191 
    192 int WIN32API SHShellFolderView_Message(HWND   hwndCabinet,
    193                                        UINT   uMsg,
    194                                        LPARAM lParam)
    195 {
    196   dprintf(("SHELL32: SHShellFolderView_Message(%08xh,%08xh,%08xh) not implemented.\n",
    197            hwndCabinet,
    198            uMsg,
    199            lParam));
    200 
    201   return 0;
    202 }
    203 
    204 
    205 
    206 
    207 /*****************************************************************************
    208  * Name      : DWORD WIN32API SHRegisterDragDrop
    209  * Purpose   :
    210  * Parameters:
    211  * Variables :
    212  * Result    :
    213  * Remark    : SHELL32.86
    214  * Status    : UNTESTED STUB
    215  *
    216  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    217  *
    218  * NOTES
    219  *     exported by ordinal
    220  */
    221 
    222 DWORD WIN32API SHRegisterDragDrop(HWND        hWnd,
    223                                   IDropTarget *pDropTarget)
    224 {
    225   dprintf(("SHELL32: SHRegisterDragDrop(%08xh,%08xh)\n",
    226            hWnd,
    227            pDropTarget));
    228 
    229   // return RegisterDragDrop(hWnd,
    230   //                         pDropTarget);
    231   return 0;
    232 }
    233 
    234 /*****************************************************************************
    235  * Name      : DWORD WIN32API SHRevokeDragDrop
    236  * Purpose   :
    237  * Parameters:
    238  * Variables :
    239  * Result    :
    240  * Remark    : SHELL32.87
    241  * Status    : UNTESTED STUB
    242  *
    243  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    244  *
    245  * NOTES
    246  *     exported by ordinal
    247  */
    248 
    249 DWORD WIN32API SHRevokeDragDrop(DWORD x)
    250 {
    251   dprintf(("SHELL32: SHRevokeDragDrop(%08xh) not implemented.\n",
    252            x));
    253 
    254   return 0;
    255 }
    256 
    257 
    258 /*****************************************************************************
    259  * Name      : HRESULT SHWaitForFileToOpen
    260  * Purpose   :
    261  * Parameters: DWORD x
    262  *             DWORD y
    263  *             DWORD z
    264  * Variables :
    265  * Result    :
    266  * Remark    : SHELL32.97
    267  * Status    : UNTESTED STUB
    268  *
    269  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    270  *****************************************************************************/
    271 
    272 HRESULT WIN32API SHWaitForFileToOpen(DWORD u,
    273                                      DWORD v,
    274                                      DWORD w)
    275 {
    276   dprintf(("SHELL32: SHWaitForFileToOpen(%08xh,%08xh,%08xh) not implemented.\n",
    277            u,
    278            v,
    279            w));
    280 
    281   return 0;
    282 }
    283 
    284 
    285 /*****************************************************************************
    286  * Name      : DWORD WIN32API SHRestricted
    287  * Purpose   :
    288  * Parameters:
    289  * Variables :
    290  * Result    :
    291  * Remark    : SHELL32.100
    292  * Status    : UNTESTED STUB
    293  *
    294  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    295  *
    296  * walks through policy table, queries <app> key, <type> value, returns
    297  * queried (DWORD) value.
    298  * {0x00001,Explorer,NoRun}
    299  * {0x00002,Explorer,NoClose}
    300  * {0x00004,Explorer,NoSaveSettings}
    301  * {0x00008,Explorer,NoFileMenu}
    302  * {0x00010,Explorer,NoSetFolders}
    303  * {0x00020,Explorer,NoSetTaskbar}
    304  * {0x00040,Explorer,NoDesktop}
    305  * {0x00080,Explorer,NoFind}
    306  * {0x00100,Explorer,NoDrives}
    307  * {0x00200,Explorer,NoDriveAutoRun}
    308  * {0x00400,Explorer,NoDriveTypeAutoRun}
    309  * {0x00800,Explorer,NoNetHood}
    310  * {0x01000,Explorer,NoStartBanner}
    311  * {0x02000,Explorer,RestrictRun}
    312  * {0x04000,Explorer,NoPrinterTabs}
    313  * {0x08000,Explorer,NoDeletePrinter}
    314  * {0x10000,Explorer,NoAddPrinter}
    315  * {0x20000,Explorer,NoStartMenuSubFolders}
    316  * {0x40000,Explorer,MyDocsOnNet}
    317  * {0x80000,WinOldApp,NoRealMode}
    318  *
    319  * NOTES
    320  *     exported by ordinal
    321  */
    322 
    323 DWORD WIN32API SHRestricted (DWORD pol)
    324 {
    325   HKEY  xhkey;
    326 
    327   dprintf(("SHELL32: SHRestricted(%08xh) not implemented.\n",
    328            pol));
    329 
    330   if (RegOpenKeyA(HKEY_CURRENT_USER,
    331                   "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
    332                   &xhkey))
    333     return 0;
    334 
    335   /* FIXME: do nothing for now, just return 0 (== "allowed") */
    336   RegCloseKey(xhkey);
    337   return 0;
    338 }
    339 
    340 
    341 /*****************************************************************************
    342  * Name      : HRESULT SHFlushClipboard
    343  * Purpose   :
    344  * Parameters:
    345  * Variables :
    346  * Result    :
    347  * Remark    : SHELL32.121
    348  * Status    : UNTESTED STUB
    349  *
    350  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    351  *****************************************************************************/
    352 
    353 HRESULT WIN32API SHFlushClipboard(void)
    354 {
    355   dprintf(("SHELL32: SHFlushClipboard() not implemented.\n"));
    356 
    357   return 1;
    358 }
    359 
    360 
    361 /*****************************************************************************
    362  * Name      : HRESULT SHFreeUnusedLibraries
    363  * Purpose   :
    364  * Parameters:
    365  * Variables :
    366  * Result    :
    367  * Remark    : SHELL32.123
    368  * Status    : UNTESTED STUB
    369  *
    370  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    371  *****************************************************************************/
    372 
    373 HRESULT WIN32API SHFreeUnusedLibraries (void)
    374 {
    375   dprintf(("SHELL32: SHFreeUnusedLibraries() not implemented.\n"));
    376   return TRUE;
    377 }
    378 
    379 
    380 /*****************************************************************************
    381  * Name      : HRESULT SHWinHelp
    382  * Purpose   :
    383  * Parameters:
    384  * Variables :
    385  * Result    :
    386  * Remark    : SHELL32.127
    387  * Status    : UNTESTED STUB
    388  *
    389  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    390  *****************************************************************************/
    391 
    392 HRESULT WIN32API SHWinHelp (DWORD v,
    393                             DWORD w,
    394                             DWORD x,
    395                             DWORD z)
    396 {
    397   dprintf(("SHELL32: SHWinHelp(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    398            v,
    399            w,
    400            x,
    401            z));
    402 
    403   return 0;
    404 }
    405 
    406 
    407 /*****************************************************************************
    408  * Name      : HRESULT SHOutOfMemoryMessageBox
    409  * Purpose   :
    410  * Parameters:
    411  * Variables :
    412  * Result    :
    413  * Remark    : SHELL32.126
    414  * Status    : UNTESTED STUB
    415  *
    416  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    417  *****************************************************************************/
    418 
    419 HRESULT WIN32API SHOutOfMemoryMessageBox(DWORD u,
    420                                          DWORD v,
    421                                          DWORD w)
    422 {
    423   dprintf(("SHELL32: SHOutOfmemoryMessageBox(%08xh,%08xh,%08xh) not implemented.\n",
    424            u,
    425            v,
    426            w));
    427 
    428   return 0;
    429 }
    430 
    431 
    432 /*****************************************************************************
    433  * Name      : HRESULT SHLoadOLE
    434  * Purpose   :
    435  * Parameters:
    436  * Variables :
    437  * Result    :
    438  * Remark    : SHELL32.151
    439  * Status    : UNTESTED STUB
    440  *
    441  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    442  *****************************************************************************/
    443 
    444 HRESULT WIN32API SHLoadOLE(DWORD u)
    445 {
    446   dprintf(("SHELL32: SHLoadOle(%08xh) not implemented.\n",
    447            u));
    448 
    449   return S_OK;
    450 }
    451 
    452 
    453 /*****************************************************************************
    454  * Name      : HRESULT SHRunControlPanel
    455  * Purpose   :
    456  * Parameters:
    457  * Variables :
    458  * Result    :
    459  * Remark    : SHELL32.161
    460  * Status    : UNTESTED STUB
    461  *
    462  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    463  *****************************************************************************/
    464 
    465 HRESULT WIN32API SHRunControlPanel (DWORD x,
    466                                     DWORD z)
    467 {
    468   dprintf(("SHELL32: SHRunControlPanel(%08xh, %08xh) not implemented.\n",
    469            x,
    470            z));
    471 
    472   return 0;
    473 }
    474 
    475 
    476 /*****************************************************************************
    477  * Name      : DWORD WIN32API SHCreateDirectory
    478  * Purpose   :
    479  * Parameters:
    480  * Variables :
    481  * Result    :
    482  * Remark    : SHELL32.165
    483  * Status    : UNTESTED STUB
    484  *
    485  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    486  *
    487  * NOTES
    488  *  exported by ordinal
    489  *  not sure about LPSECURITY_ATTRIBUTES
    490  */
    491 
    492 DWORD WIN32API SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,
    493                                  LPCSTR                path)
    494 {
    495   dprintf(("SHELL32: SHCreateDirectory(%08xh, %08xh)\n",
    496            sec,
    497            path));
    498 
    499  if (CreateDirectoryA(path,sec))
    500    return TRUE;
    501 
    502  /* SHChangeNotify(8,1,path,0); */
    503  return FALSE;
    504 
    505 //   if (SHELL32_79(path,(LPVOID)x))
    506 //      return 0;
    507 //   FIXME("(%08lx,%s):stub.\n",x,path);
    508 //   return 0;
    509 }
    510 
    511 
    512 /*****************************************************************************
    513  * Name      : HRESULT SHValidateUNC
    514  * Purpose   : validating a UNC path ? so the parameters are not correct !
    515  * Parameters: DWORD x
    516  *             DWORD y
    517  *             DWORD z
    518  * Variables :
    519  * Result    :
    520  * Remark    : SHELL32.173
    521  * Status    : UNTESTED STUB
    522  *
    523  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    524  *****************************************************************************/
    525 
    526 HRESULT WIN32API SHValidateUNC (DWORD x,
    527                                 DWORD y,
    528                                 DWORD z)
    529 {
    530   dprintf(("SHELL32: SHValidateUnc(%08x,%08xh,%08xh) not implemented.\n",
    531            x,
    532            y,
    533            z));
    534 
    535  return 0;
    536 }
    537 
    538 
    539 /*****************************************************************************
    540  * Name      : HRESULT SHCreateShellFolderViewEx
    541  * Purpose   :
    542  * Parameters:
    543  * Variables :
    544  * Result    :
    545  * Remark    : SHELL32.174
    546  * Status    : UNTESTED STUB
    547  *
    548  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    549  *****************************************************************************/
    550 
    551 
    552 HRESULT WIN32API SHCreateShellFolderViewEx(LPSHELLVIEWDATA psvcbi,
    553                                            LPVOID* ppv)
    554 {
    555   dprintf(("SHELL32: SHCreateShellFolderViewEx(%08xh,%08xh) not implemented.\n",
    556            psvcbi,
    557            ppv));
    558 
    559   return 0;
    560 }
    561 
    562 
    563 /*****************************************************************************
    564  * Name      : HRESULT SHSetInstanceExplorer
    565  * Purpose   :
    566  * Parameters:
    567  * Variables :
    568  * Result    :
    569  * Remark    : SHELL32.176
    570  * Status    : UNTESTED STUB
    571  *
    572  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    573  *****************************************************************************/
    574 
    575 HRESULT WIN32API SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
    576 {
    577   dprintf(("SHELL32: SHSetInstanceExplorer(%08xh)\n",
    578            lpUnknown));
    579 
    580   SHELL32_IExplorerInterface = lpUnknown;
    581   return (HRESULT) lpUnknown;
    582 }
    583 
    584 
    585 /*****************************************************************************
    586  * Name      : DWORD WIN32API SHFree
    587  * Purpose   :
    588  * Parameters:
    589  * Variables :
    590  * Result    :
    591  * Remark    : SHELL32.195
    592  * Status    : UNTESTED STUB
    593  *
    594  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    595  *
    596  * NOTES
    597  *     free_ptr() - frees memory using IMalloc
    598  *     exported by ordinal
    599  */
    600 
    601 DWORD WIN32API SHFree(LPVOID x)
    602 {
    603   dprintf(("SHELL32: SHFree(%08xh)\n",
    604            x));
    605 
    606 // @@@PH what's that crap?
    607 //  if (!HIWORD(x))
    608 //  {
    609 //    *(LPDWORD)0xdeaf0000 = 0;
    610 //  }
    611 
    612   return HeapFree(GetProcessHeap(),0,x);
    613 }
    614 
    615 
    616 /*****************************************************************************
    617  * Name      : LPVOID WIN32API SHAlloc
    618  * Purpose   :
    619  * Parameters:
    620  * Variables :
    621  * Result    :
    622  * Remark    : SHELL32.196
    623  * Status    : UNTESTED STUB
    624  *
    625  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    626  *
    627  * NOTES
    628  *     void *task_alloc(DWORD len), uses SHMalloc allocator
    629  *     exported by ordinal
    630  */
    631 
    632 LPVOID WIN32API SHAlloc(DWORD len)
    633 {
    634   dprintf(("SHELL32: SHAlloc(%08xh)\n",
    635            len));
    636 
    637   return (LPVOID)HeapAlloc(GetProcessHeap(),0,len);
    638 }
    639 
    640 
    641 /*****************************************************************************
    642  * Name      : HRESULT SHAbortInvokeCommand
    643  * Purpose   :
    644  * Parameters:
    645  * Variables :
    646  * Result    :
    647  * Remark    : SHELL32.198
    648  * Status    : UNTESTED STUB
    649  *
    650  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    651  *****************************************************************************/
    652 
    653 HRESULT WIN32API SHAbortInvokeCommand(void)
    654 {
    655   dprintf(("SHELL32: SHAbortInvokeCommand() not implemented.\n"));
    656 
    657   return 1;
    658 }
    659 
    660 
    661 /*****************************************************************************
    662  * Name      : VOID SHAddToRecentDocs
    663  * Purpose   :
    664  * Parameters: UINT    uFlags
    665  *             LPCVOID pv
    666  * Variables :
    667  * Result    :
    668  * Remark    : SHELL32.234
    669  * Status    : UNTESTED STUB
    670  *
    671  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    672  *****************************************************************************/
    673 
    674 VOID WIN32API SHAddToRecentDocs(UINT    uFlags,
    675                                 LPCVOID pv)
    676 {
    677   dprintf(("SHELL32: SHAddToRecentDocs(%08xh,%08xh) not implemented.\n",
    678            uFlags,
    679            pv));
    680 }
    681 
    682 
    683 /*****************************************************************************
    684  * Name      : DWORD SHAppBarMessage
    685  * Purpose   : ... be the janitor
    686  * Parameters:
    687  * Variables :
    688  * Result    :
    689  * Remark    : SHELL32.235
    690  * Status    : UNTESTED STUB UNKNOWN
    691  *
    692  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    693  *****************************************************************************/
    694 
    695 DWORD WIN32API SHAppBarMessage(LONG   x1,
    696                                LPVOID x2)
    697 {
    698   dprintf(("SHELL32: SHAppBarMessage(%08xh,%08xh) not implemented.\n",
    699            x1,
    700            x2));
    701 
    702   return 0;
    703 }
    70442
    70543
    … …  
    72866
    72967/*****************************************************************************
    730  * Name      : LPITEMIDLIST SHBrowseForFolderA
    731  * Purpose   :
    732  * Parameters: LPBROWSEINFOA lpbi
    733  * Variables :
    734  * Result    :
    735  * Remark    : SHELL32.237
    736  * Status    : UNTESTED STUB
    737  *
    738  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    739  *****************************************************************************/
    740 
    741 LPITEMIDLIST WIN32API SHBrowseForFolderA(LPBROWSEINFOA lpbi)
    742 {
    743   dprintf(("SHELL32: SHBrowseForFolderA(%08xh) not implemented.\n",
    744            lpbi));
    745 
    746   return(NULL);
    747 }
    748 
    749 
    750 /*****************************************************************************
    75168 * Name      : LPITEMIDLIST SHBrowseForFolderW
    75269 * Purpose   :
    … …  
    76683
    76784  return(NULL);
    768 }
    769 
    770 
    771 /*****************************************************************************
    772  * Name      : VOID SHChangeNotify
    773  * Purpose   :
    774  * Parameters: LONG    wEventId
    775  *             UINT    uFlags
    776  *             LPCVOID dwItem1
    777  *             LPCVOID dwItem2
    778  * Variables :
    779  * Result    :
    780  * Remark    : SHELL32.239
    781  * Status    : UNTESTED STUB
    782  *
    783  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    784  *****************************************************************************/
    785 
    786 VOID WIN32API SHChangeNotify(LONG    wEventId,
    787                              UINT    uFlags,
    788                              LPCVOID dwItem1,
    789                              LPCVOID dwItem2)
    790 {
    791   dprintf(("SHELL32: SHChangeNotify(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    792            wEventId,
    793            uFlags,
    794            dwItem1,
    795            dwItem2));
    796 
    79785}
    79886
    … …  
    843131           x2,
    844132           x3));
    845 
    846   return 0;
    847 }
    848 
    849 
    850 /*****************************************************************************
    851  * Name      : HRESULT SHFileOperation
    852  * Purpose   :
    853  * Parameters:
    854  * Variables :
    855  * Result    :
    856  * Remark    : SHELL32.242
    857  * Status    : UNTESTED STUB
    858  *
    859  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    860  *****************************************************************************/
    861 
    862 DWORD WIN32API SHFileOperationAW(LPVOID lpFileOp)
    863 {
    864   dprintf(("SHELL32: SHFileOperationAW(%08xh) not implemented.\n",
    865            lpFileOp));
    866 
    867   // if OsIsUnicode()
    868   //   SHFileOperationA(lpFileOp);
    869   // else
    870   //   SHFileOperationW(lpFileOp);
    871 
    872   return 0;
    873 }
    874 
    875 
    876 /*****************************************************************************
    877  * Name      : HRESULT SHFileOperationA
    878  * Purpose   :
    879  * Parameters:
    880  * Variables :
    881  * Result    :
    882  * Remark    : SHELL32.243
    883  * Status    : UNTESTED STUB
    884  *
    885  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    886  *****************************************************************************/
    887 
    888 DWORD WIN32API SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp)
    889 {
    890   dprintf(("SHELL32: SHFileOperationA(%08xh) not implemented.\n",
    891            lpFileOp));
    892 
    893   return 0;
    894 }
    895 
    896 
    897 /*****************************************************************************
    898  * Name      : HRESULT SHFileOperationW
    899  * Purpose   :
    900  * Parameters:
    901  * Variables :
    902  * Result    :
    903  * Remark    : SHELL32.244
    904  * Status    : UNTESTED STUB
    905  *
    906  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    907  *****************************************************************************/
    908 
    909 DWORD WIN32API SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp)
    910 {
    911   dprintf(("SHELL32: SHFileOperationW(%08xh) not implemented.\n",
    912            lpFileOp));
    913133
    914134  return 0;
    … …  
    961181
    962182  return 0;
    963 }
    964 
    965 
    966 /*****************************************************************************
    967  * Name      : DWORD SHGetDataFromIDListA
    968  * Purpose   :
    969  * Parameters:
    970  * Variables :
    971  * Result    :
    972  * Remark    : SHELL32.247
    973  * Status    : UNTESTED STUB UNKNOWN
    974  *
    975  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    976  *****************************************************************************/
    977 
    978 DWORD WIN32API SHGetDataFromIDListA(LPVOID x1,
    979                                     LPVOID x2,
    980                                     DWORD  x3,
    981                                     LPVOID x4,
    982                                     DWORD  x5)
    983 {
    984   dprintf(("SHELL32: SHGetDataFromIDListA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    985            x1,
    986            x2,
    987            x3,
    988            x4,
    989            x5));
    990 
    991   return 0;
    992 }
    993 
    994 
    995 /*****************************************************************************
    996  * Name      : DWORD SHGetDataFromIDListW
    997  * Purpose   :
    998  * Parameters:
    999  * Variables :
    1000  * Result    :
    1001  * Remark    : SHELL32.248
    1002  * Status    : UNTESTED STUB UNKNOWN
    1003  *
    1004  * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
    1005  *****************************************************************************/
    1006 
    1007 DWORD WIN32API SHGetDataFromIDListW(LPVOID x1,
    1008                                     LPVOID x2,
    1009                                     DWORD  x3,
    1010                                     LPVOID x4,
    1011                                     DWORD  x5)
    1012 {
    1013   dprintf(("SHELL32: SHGetDataFromIDListW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1014            x1,
    1015            x2,
    1016            x3,
    1017            x4,
    1018            x5));
    1019 
    1020   return 0;
    1021 }
    1022 
    1023 
    1024 /*****************************************************************************
    1025  * Name      : HRESULT SHGetDesktopFolder
    1026  * Purpose   :
    1027  * Parameters: LPSHELLFOLDER *ppshf
    1028  * Variables :
    1029  * Result    :
    1030  * Remark    : SHELL32.252
    1031  * Status    : UNTESTED STUB
    1032  *
    1033  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1034  *****************************************************************************/
    1035 
    1036 HRESULT WIN32API SHGetDesktopFolder(LPSHELLFOLDER *ppshf)
    1037 {
    1038   dprintf(("SHELL32: SHGetDesktopFolder(%08xh) not implemented.\n",
    1039            ppshf));
    1040 
    1041   return(1);
    1042 }
    1043 
    1044 
    1045 
    1046 /*****************************************************************************
    1047  * Name      : DWORD SHGetFileInfoA
    1048  * Purpose   :
    1049  * Parameters: LPCSTR      pszPath
    1050  *             DWORD       dwFileAttributes
    1051  *             SHFILEINFOA *psfi
    1052  *             UINT        cbFileInfo
    1053  *             UINT        uFlags
    1054  * Variables :
    1055  * Result    :
    1056  * Remark    : SHELL32.253 .254
    1057  * Status    : UNTESTED STUB
    1058  *
    1059  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1060  *****************************************************************************/
    1061 
    1062 DWORD WIN32API SHGetFileInfoA(LPCSTR      pszPath,
    1063                               DWORD       dwFileAttributes,
    1064                               SHFILEINFOA *psfi,
    1065                               UINT        cbFileInfo,
    1066                               UINT        uFlags)
    1067 {
    1068   dprintf(("SHELL32: SHGetFileInfoA (%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1069            pszPath,
    1070            dwFileAttributes,
    1071            psfi,
    1072            cbFileInfo,
    1073            uFlags));
    1074 
    1075   return(0);
    1076 }
    1077 
    1078 
    1079 /*****************************************************************************
    1080  * Name      : DWORD SHGetFileInfoW
    1081  * Purpose   :
    1082  * Parameters: LPWSTR      pszPath
    1083  *             DWORD       dwFileAttributes
    1084  *             SHFILEINFOA *psfi
    1085  *             UINT        cbFileInfo
    1086  *             UINT        uFlags
    1087  * Variables :
    1088  * Result    :
    1089  * Remark    : SHELL32.255
    1090  * Status    : UNTESTED STUB
    1091  *
    1092  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1093  *****************************************************************************/
    1094 
    1095 DWORD WIN32API SHGetFileInfoW(LPCWSTR         pszPath,
    1096                               DWORD           dwFileAttributes,
    1097                               SHFILEINFOW     *psfi,
    1098                               UINT            cbFileInfo,
    1099                               UINT            uFlags)
    1100 {
    1101   char *astring = UnicodeToAsciiString((LPWSTR)pszPath);
    1102 
    1103   dprintf(("SHELL32: SHGetFileInfoW (%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1104            astring,
    1105            dwFileAttributes,
    1106            psfi,
    1107            cbFileInfo,
    1108            uFlags));
    1109 
    1110   FreeAsciiString(astring);
    1111   return(0);
    1112 }
    1113 
    1114 
    1115 /*****************************************************************************
    1116  * Name      : HRESULT SHGetInstanceExplorer
    1117  * Purpose   :
    1118  * Parameters:
    1119  * Variables :
    1120  * Result    :
    1121  * Remark    : SHELL32.256
    1122  * Status    : UNTESTED STUB
    1123  *
    1124  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1125  *****************************************************************************/
    1126 
    1127 HRESULT WIN32API SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
    1128 {
    1129   dprintf(("SHELL32: SHGetInstanceExplorer(%08xh) not implemented.\n",
    1130            lpUnknown));
    1131 
    1132   *lpUnknown = SHELL32_IExplorerInterface;
    1133 
    1134   if (!SHELL32_IExplorerInterface)
    1135     return E_FAIL;
    1136 
    1137   //@@@PH to do:
    1138   //SHELL32_IExplorerInterface->lpvtbl->fnAddRef(SHELL32_IExplorerInterface);
    1139   return NOERROR;
    1140 }
    1141 
    1142 
    1143 /*****************************************************************************
    1144  * Name      : HRESULT SHGetMalloc
    1145  * Purpose   :
    1146  * Parameters: LPMALLOC *ppMalloc
    1147  * Variables :
    1148  * Result    :
    1149  * Remark    : SHELL32.257
    1150  * Status    : UNTESTED STUB
    1151  *
    1152  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1153  *****************************************************************************/
    1154 
    1155 HRESULT WIN32API SHGetMalloc(LPMALLOC *ppMalloc)
    1156 {
    1157   dprintf(("SHELL32: SHGetMalloc(%08xh) not implemented.\n",
    1158            ppMalloc));
    1159 
    1160   return(0);
    1161183}
    1162184
    … …  
    1192214
    1193215/*****************************************************************************
    1194  * Name      : BOOL SHGetPathFromIDListA
    1195  * Purpose   :
    1196  * Parameters: LPCITEMIDLIST pidl
    1197  *             LPSTR         pszPath
    1198  * Variables :
    1199  * Result    :
    1200  * Remark    : SHELL32.259 .260
    1201  * Status    : UNTESTED STUB
    1202  *
    1203  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1204  *****************************************************************************/
    1205 
    1206 BOOL WIN32API SHGetPathFromIDListA(LPCITEMIDLIST pidl,
    1207                                    LPSTR         pszPath)
    1208 {
    1209   dprintf(("SHELL32: SHGetPathFromIDListA(%08xh,%s) not implemented.\n",
    1210            pidl,
    1211            pszPath));
    1212 
    1213   return(FALSE);
    1214 }
    1215 
    1216 
    1217 /*****************************************************************************
    1218  * Name      : BOOL SHGetPathFromIDListW
    1219  * Purpose   :
    1220  * Parameters: LPCITEMIDLIST pidl
    1221  *             LPSTR         pszPath
    1222  * Variables :
    1223  * Result    :
    1224  * Remark    : SHELL32.261
    1225  * Status    : UNTESTED STUB
    1226  *
    1227  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1228  *****************************************************************************/
    1229 
    1230 BOOL WIN32API SHGetPathFromIDListW(LPCITEMIDLIST pidl,
    1231                                    LPWSTR        pszPath)
    1232 {
    1233   dprintf(("SHELL32: SHGetPathFromIDListW(%08xh,%08xh) not implemented.\n",
    1234            pidl,
    1235            pszPath));
    1236 
    1237   return(FALSE);
    1238 }
    1239 
    1240 
    1241 /*****************************************************************************
    1242  * Name      : HRESULT SHGetSpecialFolderLocation
    1243  * Purpose   :
    1244  * Parameters: HWND         hwndOwner
    1245  *             int          nFolder
    1246  *             LPITEMIDLIST *ppidl
    1247  * Variables :
    1248  * Result    :
    1249  * Remark    : SHELL32.262
    1250  * Status    : UNTESTED STUB
    1251  *
    1252  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1253  *****************************************************************************/
    1254 
    1255 HRESULT WIN32API SHGetSpecialFolderLocation(HWND         hwndOwner,
    1256                                             int          nFolder,
    1257                                             LPITEMIDLIST * ppidl)
    1258 {
    1259   dprintf(("SHELL32: SHGetSpecialFolderLocation(%08xh,%08xh,%08xh) not implemented.\n",
    1260            hwndOwner,
    1261            nFolder,
    1262            ppidl));
    1263 
    1264   return(1);
    1265 }
    1266 
    1267 
    1268 /*****************************************************************************
    1269  * Name      : DWORD SHHelpShortcuts_RunDLL
    1270  * Purpose   :
    1271  * Parameters:
    1272  * Variables :
    1273  * Result    :
    1274  * Remark    : SHELL32.263
    1275  * Status    : UNTESTED STUB
    1276  *
    1277  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1278  *****************************************************************************/
    1279 
    1280 DWORD WIN32API SHHelpShortcuts_RunDLL(DWORD x1,
    1281                                       DWORD x2,
    1282                                       DWORD x3,
    1283                                       DWORD x4)
    1284 {
    1285   dprintf(("SHELL32: SHHelpShortcuts_RunDLL(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1286            x1,
    1287            x2,
    1288            x3,
    1289            x4));
    1290 
    1291   return(0);
    1292 }
    1293 
    1294 
    1295 /*****************************************************************************
    1296216 * Name      : DWORD SHHelpShortcuts_RunDLLA
    1297217 * Purpose   :
    … …  
    1348268
    1349269/*****************************************************************************
    1350  * Name      : DWORD SHLoadInProc
    1351  * Purpose   :
    1352  * Parameters:
    1353  * Variables :
    1354  * Result    :
    1355  * Remark    : SHELL32.267
    1356  * Status    : UNTESTED STUB
    1357  *
    1358  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1359  *****************************************************************************/
    1360 
    1361 DWORD WIN32API SHLoadInProc(DWORD x1)
    1362 {
    1363   dprintf(("SHELL32: SHLoadInProc(%08xh) not implemented.\n",
    1364            x1));
    1365 
    1366   return(0);
    1367 }
    1368 
    1369 
    1370 /*****************************************************************************
    1371270 * Name      : DWORD SHQueryRecycleBinA
    1372271 * Purpose   :
    … …  
    1431330
    1432331  return(0);
    1433 }
    1434 
    1435 
    1436 /*****************************************************************************
    1437  * Name      : HRESULT SHRegCloseKey
    1438  * Purpose   :
    1439  * Parameters:
    1440  * Variables :
    1441  * Result    :
    1442  * Remark    : SHELL32.505
    1443  * Status    : UNTESTED STUB
    1444  *
    1445  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1446  *****************************************************************************/
    1447 
    1448 HRESULT WIN32API SHRegCloseKey (HKEY hkey)
    1449 {
    1450   dprintf(("SHELL32: SHRegCloseKey(%08xh)\n",
    1451            hkey));
    1452 
    1453   return RegCloseKey( hkey );
    1454 }
    1455 
    1456 
    1457 /*****************************************************************************
    1458  * Name      : HRESULT SHRegOpenKeyA
    1459  * Purpose   :
    1460  * Parameters:
    1461  * Variables :
    1462  * Result    :
    1463  * Remark    : SHELL32.506
    1464  * Status    : UNTESTED STUB
    1465  *
    1466  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1467  *****************************************************************************/
    1468 
    1469 HRESULT WIN32API SHRegOpenKeyA(HKEY  hKey,
    1470                                LPSTR lpSubKey,
    1471                                LPHKEY phkResult)
    1472 {
    1473   dprintf(("SHELL32: SHRegOpenKeyA(%08xh,%s,%08xh)\n",
    1474            hKey,
    1475            lpSubKey,
    1476            phkResult));
    1477 
    1478  return RegOpenKeyA(hKey,
    1479                     lpSubKey,
    1480                     phkResult);
    1481 }
    1482 
    1483 
    1484 /*****************************************************************************
    1485  * Name      : HRESULT SHRegOpenKeyW
    1486  * Purpose   :
    1487  * Parameters:
    1488  * Variables :
    1489  * Result    :
    1490  * Remark    : SHELL32.507
    1491  * Status    : UNTESTED STUB
    1492  *
    1493  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1494  *****************************************************************************/
    1495 
    1496 HRESULT WIN32API SHRegOpenKeyW (HKEY    hKey,
    1497                                 LPCWSTR lpszSubKey,
    1498                                 LPHKEY  phkResult)
    1499 {
    1500   dprintf(("SHELL32: SHRegOpenKeyW(%08xh,%08xh,%08xh)\n",
    1501            hKey,
    1502            lpszSubKey,
    1503            phkResult));
    1504 
    1505  return RegOpenKeyW(hKey,
    1506                     lpszSubKey,
    1507                     phkResult);
    1508 }
    1509 
    1510 
    1511 /*****************************************************************************
    1512  * Name      : HRESULT SHRegQueryValueA
    1513  * Purpose   :
    1514  * Parameters:
    1515  * Variables :
    1516  * Result    :
    1517  * Remark    : SHELL32.508
    1518  * Status    : UNTESTED STUB
    1519  *
    1520  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1521  *****************************************************************************/
    1522 
    1523 HRESULT WIN32API SHRegQueryValueA(HKEY   hKey,
    1524                                   LPSTR  lpszSubKey,
    1525                                   LPSTR  lpszData,
    1526                                   LPLONG lpcbData)
    1527 {
    1528   dprintf(("SHELL32: SHRegQueryValueW(%08xh,%s,%08xh,%08xh)\n",
    1529            hKey,
    1530            lpszSubKey,
    1531            lpszData,
    1532            lpcbData));
    1533 
    1534   return (HRESULT)RegQueryValueA(hKey,
    1535                                  lpszSubKey,
    1536                                  lpszData,
    1537                                  lpcbData);
    1538 }
    1539 
    1540 
    1541 /*****************************************************************************
    1542  * Name      : HRESULT SHRegQueryValueExA
    1543  * Purpose   :
    1544  * Parameters:
    1545  * Variables :
    1546  * Result    :
    1547  * Remark    : SHELL32.509
    1548  * Status    : UNTESTED STUB
    1549  *
    1550  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1551  *****************************************************************************/
    1552 
    1553 HRESULT WIN32API SHRegQueryValueExA(DWORD   u,
    1554                                     LPSTR   v,
    1555                                     LPDWORD w,
    1556                                     LPDWORD x,
    1557                                     LPBYTE  y,
    1558                                     LPDWORD z)
    1559 {
    1560   dprintf(("SHELL32: SHRegQueryValueExA(%08xh,%s,%08xh,%08xh,%08xh,%08xh)\n",
    1561            u,
    1562            v,
    1563            w,
    1564            x,
    1565            y,
    1566            z));
    1567 
    1568   return (HRESULT)RegQueryValueExA(u,
    1569                                    v,
    1570                                    w,
    1571                                    x,
    1572                                    y,
    1573                                    z);
    1574 }
    1575 
    1576 
    1577 /*****************************************************************************
    1578  * Name      : HRESULT SHRegQueryValueExW
    1579  * Purpose   :
    1580  * Parameters:
    1581  * Variables :
    1582  * Result    :
    1583  * Remark    : SHELL32.510
    1584  * Status    : UNTESTED STUB
    1585  *
    1586  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1587  *****************************************************************************/
    1588 
    1589 HRESULT WIN32API SHRegQueryValueExW(DWORD    u,
    1590                                     LPWSTR   v,
    1591                                     LPDWORD  w,
    1592                                     LPDWORD  x,
    1593                                     LPBYTE   y,
    1594                                     LPDWORD  z)
    1595 {
    1596   dprintf(("SHELL32: SHRegQueryValueExW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    1597            u,
    1598            v,
    1599            w,
    1600            x,
    1601            y,
    1602            z));
    1603 
    1604   return (HRESULT)RegQueryValueExW(u,
    1605                                    v,
    1606                                    w,
    1607                                    x,
    1608                                    y,
    1609                                    z);
    1610 }
    1611 
    1612 
    1613 /*****************************************************************************
    1614  * Name      : HRESULT SHRegQueryValueW
    1615  * Purpose   :
    1616  * Parameters:
    1617  * Variables :
    1618  * Result    :
    1619  * Remark    : SHELL32.511
    1620  * Status    : UNTESTED STUB
    1621  *
    1622  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1623  *****************************************************************************/
    1624 
    1625 HRESULT WIN32API SHRegQueryValueW(HKEY   hKey,
    1626                                   LPWSTR lpszSubKey,
    1627                                   LPWSTR lpszData,
    1628                                   LPLONG lpcbData)
    1629 {
    1630   dprintf(("SHELL32: SHRegQueryValueW(%08xh,%08xh,%08xh,%08xh)\n",
    1631            hKey,
    1632            lpszSubKey,
    1633            lpszData,
    1634            lpcbData));
    1635 
    1636   return (HRESULT)RegQueryValueW(hKey,
    1637                                  lpszSubKey,
    1638                                  lpszData,
    1639                                  lpcbData);
    1640332}
    1641333
    … …  
    1687379                       lpszKey);
    1688380}
    1689 
    1690 
    1691 /*****************************************************************************
    1692  * Name      : HGLOBAL SHAllocShared
    1693  * Purpose   : allocate shared memory ?
    1694  * Parameters:
    1695  * Variables :
    1696  * Result    :
    1697  * Remark    : SHELL32.520
    1698  * Status    : UNTESTED STUB
    1699  *
    1700  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1701  *
    1702  * NOTES
    1703  *  parameter1 is return value from HeapAlloc
    1704  *  parameter2 is equal to the size allocated with HeapAlloc
    1705  *  parameter3 is return value from GetCurrentProcessId
    1706  *
    1707  *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
    1708  *  WM_USER+2 could be the undocumented CWM_SETPATH
    1709  *  the allocated memory contains a pidl
    1710  */
    1711 
    1712 HGLOBAL WIN32API SHAllocShared(LPVOID psrc,
    1713                                DWORD  size,
    1714                                DWORD  procID)
    1715 {
    1716   HGLOBAL hmem;
    1717   LPVOID pmem;
    1718 
    1719   dprintf(("SHELL32: SHAllocShared(%08xh,%08xh,%08xh)\n",
    1720            psrc,
    1721            size,
    1722            procID));
    1723 
    1724   hmem = GlobalAlloc(GMEM_FIXED,
    1725                      size);
    1726   if (!hmem)
    1727     return 0;
    1728 
    1729   pmem = GlobalLock (hmem);
    1730   if (! pmem)
    1731     return 0;
    1732 
    1733   memcpy (pmem, psrc, size);
    1734   GlobalUnlock(hmem);
    1735   return hmem;
    1736 }
    1737 
    1738 
    1739 /*****************************************************************************
    1740  * Name      : LPVOID SHLockShared
    1741  * Purpose   :
    1742  * Parameters:
    1743  * Variables :
    1744  * Result    :
    1745  * Remark    : SHELL32.521
    1746  * Status    : UNTESTED STUB
    1747  *
    1748  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1749  *
    1750  * NOTES
    1751  *  parameter1 is return value from SHAllocShared
    1752  *  parameter2 is return value from GetCurrentProcessId
    1753  *  the receiver of (WM_USER+2) trys to lock the HANDLE (?)
    1754  *  the returnvalue seems to be a memoryadress
    1755  */
    1756 LPVOID WIN32API SHLockShared(HANDLE hmem,
    1757                              DWORD  procID)
    1758 {
    1759   dprintf(("SHELL32: SHLockShared(%08xh,%08xh).\n",
    1760            hmem,
    1761            procID));
    1762 
    1763   return GlobalLock(hmem);
    1764 }
    1765 
    1766 
    1767 /*****************************************************************************
    1768  * Name      : LPVOID SHUnlockShared
    1769  * Purpose   :
    1770  * Parameters:
    1771  * Variables :
    1772  * Result    :
    1773  * Remark    : SHELL32.522
    1774  * Status    : UNTESTED STUB
    1775  *
    1776  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1777  *
    1778  * NOTES
    1779  *  parameter1 is return value from SHLockShared
    1780  */
    1781 
    1782 BOOL WIN32API SHUnlockShared(HANDLE pmem)
    1783 {
    1784   dprintf(("SHELL32: SHUnlockShared(%08xh)\n",
    1785            pmem));
    1786 
    1787   return GlobalUnlock(pmem);
    1788 }
    1789 
    1790 
    1791 /*****************************************************************************
    1792  * Name      : LPVOID SHFreeShared
    1793  * Purpose   :
    1794  * Parameters:
    1795  * Variables :
    1796  * Result    :
    1797  * Remark    : SHELL32.523
    1798  * Status    : UNTESTED STUB
    1799  *
    1800  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1801  *
    1802  * NOTES
    1803  *  parameter1 is return value from SHAllocShared
    1804  *  parameter2 is return value from GetCurrentProcessId
    1805  */
    1806 
    1807 HANDLE WIN32API SHFreeShared(HANDLE hmem,
    1808                              DWORD  procID)
    1809 {
    1810   dprintf(("SHELL32: SHFreeShared(%08xh,%08xh)\n",
    1811            hmem,
    1812            procID));
    1813 
    1814   return GlobalFree(hmem);
    1815 }
    1816 
    1817 
    1818 /*****************************************************************************
    1819  * Name      : DWORD WIN32API NTSHChangeNotifyRegister
    1820  * Purpose   :
    1821  * Parameters:
    1822  * Variables :
    1823  * Result    :
    1824  * Remark    : SHELL32.640
    1825  * Status    : UNTESTED STUB
    1826  *
    1827  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1828  *
    1829  * NOTES
    1830  *   Idlist is an array of structures and Count specifies how many items in the array
    1831  *   (usually just one I think).
    1832  */
    1833 
    1834 DWORD WIN32API NTSHChangeNotifyRegister(HWND hwnd,
    1835                                         LONG events1,
    1836                                         LONG events2,
    1837                                         DWORD msg,
    1838                                         int count,
    1839                                         IDSTRUCT *idlist)
    1840 {
    1841   dprintf(("SHELL32: NTSHChangeNotifyRegister(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1842            hwnd,
    1843            events1,
    1844            events2,
    1845            msg,
    1846            count,
    1847            idlist));
    1848 
    1849    return SHChangeNotifyRegister(hwnd,
    1850                                  events1,
    1851                                  events2,
    1852                                  msg,
    1853                                  count,
    1854                                  idlist);
    1855 }
    1856 
    1857 
    1858 /*****************************************************************************
    1859  * Name      : DWORD WIN32API NTSHChangeNotifyDeregister
    1860  * Purpose   :
    1861  * Parameters:
    1862  * Variables :
    1863  * Result    :
    1864  * Remark    : SHELL32.641
    1865  * Status    : UNTESTED STUB
    1866  *
    1867  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    1868  */
    1869 DWORD WIN32API NTSHChangeNotifyDeregister(LONG x1)
    1870 {
    1871   dprintf(("SHELL32: NTSHChangeNotifyDeregister(%08xh) not implemented.\n",
    1872            x1));
    1873 
    1874   return SHChangeNotifyDeregister(x1);
    1875 }
    1876 

  • trunk/src/shell32/she.cpp

    r972 r1214  
    1 /* $Id: she.cpp,v 1.6 1999-09-18 15:57:52 sandervl Exp $ */
     1/* $Id: she.cpp,v 1.7 1999-10-09 11:13:20 sandervl Exp $ */
    22
    33/*
    … …  
    1212 *****************************************************************************/
    1313
     14#include <odin.h>
     15#include <odinwrap.h>
     16
    1417#include <os2win.h>
    1518#include <shellapi.h>
    1619#include <winreg.h>
    17 #include "shell32.h"
    18 
    1920#include <stdarg.h>
    2021//#include <builtin.h>
    … …  
    2324#include <string.h>
    2425
     26
     27#define ICOM_CINTERFACE 1
     28#include "shell32_main.h"
     29
    2530#include <misc.h>
     31//#include <nameid.h>
    2632#include <unicode.h>
    2733
    … …  
    3036 * Types & Defines                                                           *
    3137 *****************************************************************************/
     38
     39ODINDEBUGCHANNEL(SHELL32-SHE)
    3240
    3341
    … …  
    4452 *****************************************************************************/
    4553
    46 HRESULT WIN32API SheSetCurDrive(DWORD x1)
     54ODINFUNCTION1(HRESULT, SheSetCurDrive,
     55              DWORD, x1)
    4756{
    48   dprintf(("SHELL32: SheSetCurDrive(%08xh) not implemented.\n",
    49            x1));
     57  dprintf(("SHELL32: SheSetCurDrive not implemented.\n"));
    5058
    5159  return 0;
    5260}
     61
    5362
    5463/*****************************************************************************
    … …  
    6473 *****************************************************************************/
    6574
    66 void WIN32API SheRemoveQuotesA(VOID)
     75ODINFUNCTION1(HRESULT, SheRemoveQuotesA,
     76              LPCSTR,  lpszString)
    6777{
    68   dprintf(("SHELL32: undoc SheRemoveQuotesA\n"));
     78  dprintf(("SHELL32: SheRemoveQuotesA\n not implemented"));
     79
     80  return 0;
    6981}
     82
    7083
    7184/*****************************************************************************
    … …  
    8194 *****************************************************************************/
    8295
    83 void WIN32API SheRemoveQuotesW(VOID)
     96ODINFUNCTION1(HRESULT, SheRemoveQuotesW,
     97              LPCWSTR, lpszString)
    8498{
    85   dprintf(("SHELL32: undoc SheRemoveQuotesW\n"));
     99  dprintf(("SHELL32: SheRemoveQuotesW\n not implemented"));
     100
     101  return 0;
    86102}
     103

  • trunk/src/shell32/shell32.def

    r505 r1214  
    1 ; $Id: shell32.def,v 1.14 1999-08-16 10:31:28 phaller Exp $
     1; $Id: shell32.def,v 1.15 1999-10-09 11:13:21 sandervl Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    2121;   PifMgr_CloseProperties            = _PifMgr_CloseProperties@8             @13
    2222;   Control_FillCache_RunDLLW         = _Control_FillCache_RunDLLW@16         @14
    23 ;   ILGetDisplayName                  = _ILGetDisplayName@8                   @15
     23    ILGetDisplayName                  = _ILGetDisplayName@8                   @15
    2424    ILFindLastID                      = _ILFindLastID@4                       @16
    25 ;   ILRemoveLastID                    = _ILRemoveLastID@4                     @17
     25    ILRemoveLastID                    = _ILRemoveLastID@4                     @17
    2626    ILClone                           = _ILClone@4                            @18
    27 ;   ILCloneFirst                      = _ILCloneFirst@4                       @19
    28 ;   ILGlobalClone                     = _ILGlobalClone@4                      @20
    29 ;   ILIsEqual                         = _ILIsEqual@8                          @21
    30 ;   Control_RunDLL                    = _Control_RunDLL@16                    @22
    31 ;   ILIsParent                        = _ILIsParent@12                        @23
    32 ;   ILFindChild                       = _ILFindChild@8                        @24
     27    ILCloneFirst                      = _ILCloneFirst@4                       @19
     28    ILGlobalClone                     = _ILGlobalClone@4                      @20
     29    ILIsEqual                         = _ILIsEqual@8                          @21
     30    Control_RunDLL                    = _Control_RunDLL@16                    @22
     31    ILIsParent                        = _ILIsParent@12                        @23
     32    ILFindChild                       = _ILFindChild@8                        @24
    3333    ILCombine                         = _ILCombine@8                          @25
    34 ;   ILLoadFromStream                  = _ILLoadFromStream@8                   @26
     34    ILLoadFromStream                  = _ILLoadFromStream@8                   @26
    3535;   ILSaveToStream                    = _ILSaveToStream@8                     @27
    36 ;   SHILCreateFromPath                = _SHILCreateFromPath@12                @28
     36    SHILCreateFromPath                = _SHILCreateFromPathAW@12              @28
    3737    PathIsRoot                        = _PathIsRootAW@4                       @29
    38     PathBuildRoot                     = _PathBuildRootAW@8                    @30
     38    PathBuildRoot                     = _PathBuildRootA@8                     @30
    3939    PathFindExtension                 = _PathFindExtensionAW@4                @31
    4040    PathAddBackslash                  = _PathAddBackslashAW@4                 @32
    … …  
    5151    PathIsExe                         = _PathIsExeAW@4                        @43
    5252    DoEnvironmentSubstA               = _DoEnvironmentSubstA@8                @44
    53     PathFileExists                    = _PathFileExistsAW@4                   @45
     53    PathFileExists                    = _PathFileExistsA@4                    @45
    5454    PathMatchSpec                     = _PathMatchSpecAW@8                    @46
    5555;   PathMakeUniqueName                = _PathMakeUniqueNameAW@20              @47
    … …  
    7373;   InvalidateDriveType               = _InvalidateDriveType@?                @65
    7474;   IsNetDrive                        = _IsNetDrive@?                         @66
    75 ;   Shell_MergeMenus                  = _Shell_MergeMenus@24                  @67
     75    Shell_MergeMenus                  = _Shell_MergeMenus@24                  @67
    7676    SHGetSettings                     = _SHGetSettings@12                     @68
    7777;   SHGetNetResource                  = _SHGetNetResource@?                   @69
    78 ;   SHCreateDefClassObject            = _SHCreateDefClassObject@?             @70
     78    SHCreateDefClassObject            = _SHCreateDefClassObject@20            @70
    7979    Shell_GetImageList                = _Shell_GetImageList@8                 @71
    80     Shell_GetCachedImageIndex         = _Shell_GetCachedImageIndex@12         @72
     80    Shell_GetCachedImageIndex         = _Shell_GetCachedImageIndexA@12        @72
     81;   Shell_GetCachedImageIndexW        = _Shell_GetCachedImageIndexW@12
     82;   Shell_GetCachedImageIndexA        = _Shell_GetCachedImageIndexA@12
    8183    SHShellFolderView_Message         = _SHShellFolderView_Message@12         @73
    8284;   SHCreateStdEnumFmtEtc             = _SHCreateStdEnumFmtEtc@?              @74
    … …  
    9496    SHRegisterDragDrop                = _SHRegisterDragDrop@8                 @86
    9597    SHRevokeDragDrop                  = _SHRevokeDragDrop@4                   @87
    96 ;   SHDoDragDrop                      = _SHDoDragDrop@?                       @88
     98    SHDoDragDrop                      = _SHDoDragDrop@24                      @88
    9799    SHCloneSpecialIDList              = _SHCloneSpecialIDList@12              @89
    98100;   SHFindFiles                       = _SHFindFiles@?                        @90
    … …  
    101103;   Win32CreateDirectory              = _Win32CreateDirectory@?               @93
    102104;   Win32RemoveDirectory              = _Win32RemoveDirectory@?               @94
    103 ;   SHLogILFromFSIL                   = _SHLogILFromFSIL@4                    @95
     105    SHLogILFromFSIL                   = _SHLogILFromFSIL@4                    @95
    104106    StrRetToStrN                      = _StrRetToStrN@16                      @96
    105107    SHWaitForFileToOpen               = _SHWaitForFileToOpen@12               @97
    106 ;   SHGetRealIDL                      = _SHGetRealIDL@12                      @98
     108    SHGetRealIDL                      = _SHGetRealIDL@12                      @98
    107109    SetAppStartingCursor              = _SetAppStartingCursor@8               @99
    108110    SHRestricted                      = _SHRestricted@4                       @100
    … …  
    110112    SHCoCreateInstance                = _SHCoCreateInstance@20                @102
    111113    SignalFileOpen                    = _SignalFileOpen@4                     @103
    112 ;   FileMenu_DeleteAllItems           = _FileMenu_DeleteAllItems@4            @104
    113 ;   FileMenu_DrawItem                 = _FileMenu_DrawItem@8                  @105
    114 ;   FileMenu_FindSubMenuByPidl        = _FileMenu_FindSubMenuByPidl@8         @106
    115 ;   FileMenu_GetLastSelectedItemPidls = _FileMenu_GetLastSelectedItemPidls@12 @107
    116 ;   FileMenu_HandleMenuChar           = _FileMenu_HandleMenuChar@8            @108
    117 ;   FileMenu_InitMenuPopup            = _FileMenu_InitMenuPopup@4             @109
    118 ;   FileMenu_InsertUsingPidl          = _FileMenu_InsertUsingPidl@24          @110
    119 ;   FileMenu_Invalidate               = _FileMenu_Invalidate@4                @111
    120 ;   FileMenu_MeasureItem              = _FileMenu_MeasureItem@8               @112
    121 ;   FileMenu_ReplaceUsingPidl         = _FileMenu_ReplaceUsingPidl@20         @113
    122 ;   FileMenu_Create                   = _FileMenu_Create@20                   @114
    123 ;   FileMenu_AppendItem               = _FileMenu_AppendItem@24               @115
    124 ;   FileMenu_TrackPopupMenuEx         = _FileMenu_TrackPopupMenuEx@24         @116
    125 ;   FileMenu_DeleteItemByCmd          = _FileMenu_DeleteItemByCmd@8           @117
    126 ;   FileMenu_Destroy                  = _FileMenu_Destroy@4                   @118
    127     IsLFNDrive                        = _IsLFNDrive@4                         @119
    128 ;   FileMenu_AbortInitMenu            = _FileMenu_AbortInitMenu@0             @120
     114    FileMenu_DeleteAllItems           = _FileMenu_DeleteAllItems@4            @104
     115    FileMenu_DrawItem                 = _FileMenu_DrawItem@8                  @105
     116    FileMenu_FindSubMenuByPidl        = _FileMenu_FindSubMenuByPidl@8         @106
     117    FileMenu_GetLastSelectedItemPidls = _FileMenu_GetLastSelectedItemPidls@12 @107
     118    FileMenu_HandleMenuChar           = _FileMenu_HandleMenuChar@8            @108
     119    FileMenu_InitMenuPopup            = _FileMenu_InitMenuPopup@4             @109
     120    FileMenu_InsertUsingPidl          = _FileMenu_InsertUsingPidl@24          @110
     121    FileMenu_Invalidate               = _FileMenu_Invalidate@4                @111
     122    FileMenu_MeasureItem              = _FileMenu_MeasureItem@8               @112
     123    FileMenu_ReplaceUsingPidl         = _FileMenu_ReplaceUsingPidl@20         @113
     124    FileMenu_Create                   = _FileMenu_Create@20                   @114
     125    FileMenu_AppendItem               = _FileMenu_AppendItemAW@24             @115
     126    FileMenu_TrackPopupMenuEx         = _FileMenu_TrackPopupMenuEx@24         @116
     127    FileMenu_DeleteItemByCmd          = _FileMenu_DeleteItemByCmd@8           @117
     128    FileMenu_Destroy                  = _FileMenu_Destroy@4                   @118
     129    IsLFNDrive                        = _IsLFNDriveA@4                        @119
     130    FileMenu_AbortInitMenu            = _FileMenu_AbortInitMenu@0             @120
    129131    SHFlushClipboard                  = _SHFlushClipboard@0                   @121
    130132    RunDLL_CallEntry16                = _RunDLL_CallEntry16@20                @122
    131133    SHFreeUnusedLibraries             = _SHFreeUnusedLibraries@0              @123
    132 ;   FileMenu_AppendFilesForPidl       = _FileMenu_AppendFilesForPidl@12       @124
    133 ;   FileMenu_AddFilesForPidl          = _FileMenu_AddFilesForPidl@28          @125
     134    FileMenu_AppendFilesForPidl       = _FileMenu_AppendFilesForPidl@12       @124
     135    FileMenu_AddFilesForPidl          = _FileMenu_AddFilesForPidl@28          @125
    134136    SHOutOfMemoryMessageBox           = _SHOutOfMemoryMessageBox@12           @126
    135137    SHWinHelp                         = _SHWinHelp@16                         @127
    136 ;   DllGetClassObject                 = _DllGetClassObject@?                  @128
     138    DllGetClassObject                 = _SHELL32_DllGetClassObject@12         @128
    137139;   DAD_AutoScroll                    = _DAD_AutoScroll@?                     @129
    138140;   DAD_DragEnter                     = _DAD_DragEnter@?                      @130
    … …  
    142144;   DAD_DragMove                      = _DAD_DragMove@?                       @134
    143145    DragQueryPoint                    = _DragQueryPoint@8                     @135
    144 ;   DAD_SetDragImage                  = _DAD_SetDragImage@?                   @136
     146    DAD_SetDragImage                  = _DAD_SetDragImage@8                   @136
    145147    DAD_ShowDragImage                 = _DAD_ShowDragImage@4                  @137
    146148    DuplicateIcon                     = _DuplicateIcon@4                      @138
    147149;   Desktop_UpdateBriefcaseOnEvent    = _Desktop_UpdateBriefcaseOnEvent@?     @139
    148 ;   FileMenu_DeleteItemByIndex        = _FileMenu_DeleteItemByIndex@8         @140
    149 ;   FileMenu_DeleteItemByFirstID      = _FileMenu_DeleteItemByFirstID@8       @141
    150 ;   FileMenu_DeleteSeparator          = _FileMenu_DeleteSeparator@4           @142
    151 ;   FileMenu_EnableItemByCmd          = _FileMenu_EnableItemByCmd@12          @143
    152 ;   FileMenu_GetItemExtent            = _FileMenu_GetItemExtent@8             @144
     150    FileMenu_DeleteItemByIndex        = _FileMenu_DeleteItemByIndex@8         @140
     151    FileMenu_DeleteItemByFirstID      = _FileMenu_DeleteItemByFirstID@8       @141
     152    FileMenu_DeleteSeparator          = _FileMenu_DeleteSeparator@4           @142
     153    FileMenu_EnableItemByCmd          = _FileMenu_EnableItemByCmd@12          @143
     154    FileMenu_GetItemExtent            = _FileMenu_GetItemExtent@8             @144
    153155    PathFindOnPath                    = _PathFindOnPathAW@8                   @145
    154156    RLBuildListOfPaths                = _RLBuildListOfPaths@0                 @146
    155 ;   SHCLSIDFromString                 = _SHCLSIDFromString@8                  @147
     157    SHCLSIDFromString                 = _SHCLSIDFromStringAW@8                @147
    156158    ExtractAssociatedIconA            = _ExtractAssociatedIconA@12            @148
    157 ;   SHFind_InitMenuPopup              = _SHFind_InitMenuPopup@16              @149
     159    SHFind_InitMenuPopup              = _SHFind_InitMenuPopup@16              @149
    158160    ExtractAssociatedIconExA          = _ExtractAssociatedIconExA@12          @150
    159161    SHLoadOLE                         = _SHLoadOLE@4                          @151
    160162    ILGetSize                         = _ILGetSize@4                          @152
    161 ;   ILGetNext                         = _ILGetNext@4                          @153
    162 ;   ILAppend                          = _ILAppend@12                          @154
     163    ILGetNext                         = _ILGetNext@4                          @153
     164    ILAppend                          = _ILAppend@12                          @154
    163165    ILFree                            = _ILFree@4                             @155
    164 ;   ILGlobalGree                      = _ILGlobalFree@4                       @156
    165 ;   ILCreateFromPath                  = _ILCreateFromPath@4                   @157
     166    ILGlobalGree                      = _ILGlobalFree@4                       @156
     167    ILCreateFromPath                  = _ILCreateFromPathAW@4                 @157
    166168    PathGetExtension                  = _PathGetExtensionAW@12                @158
    167169;   PathIsDirectory                   = _PathIsDirectoryAW@?                  @159
    … …  
    177179;   SHDestroyPropSheetExtArray        = _SHDestroyPropSheetExtArray@?         @169
    178180;   SHReplaceFromPropSheetExtArray    = _SHReplaceFromPropSheetExtArray@?     @170
    179 ;   PathCleanupSpec                   = _PathCleanupSpecAW@?                  @171
     181    PathCleanupSpec                   = _PathCleanupSpecAW@8                  @171
    180182;   SHCreateLinks                     = _SHCreateLinks@?                      @172
    181183    SHValidateUNC                     = _SHValidateUNC@12                     @173
    182184    SHCreateShellFolderViewEx         = _SHCreateShellFolderViewEx@8          @174
    183     SHGetSpecialFolderPath            = _SHGetSpecialFolderPath@16            @175
     185    SHGetSpecialFolderPathA           = _SHGetSpecialFolderPathA@16           @175
    184186    SHSetInstanceExplorer             = _SHSetInstanceExplorer@4              @176
    185187;   DAD_SetDragImageFromListView      = _DAD_SetDragImageFromListView@?       @177
    … …  
    288290    SheGetDirW                        = _SheGetDirW@8                         @280
    289291;   SheGetPathOffsetW                 = _SheGetPathOffsetW@?                  @281
    290     SheRemoveQuotesA                  = _SheRemoveQuotesA@0                   @282
    291     SheRemoveQuotesW                  = _SheRemoveQuotesW@0                   @283
     292    SheRemoveQuotesA                  = _SheRemoveQuotesA@4                   @282
     293    SheRemoveQuotesW                  = _SheRemoveQuotesW@4                   @283
    292294;   SheSetCurDrive                    = _SheSetCurDrive@?                     @284
    293295    SheShortenPathA                   = _SheShortenPathA@8                    @285
    … …  
    362364    ReadCabinetState                  = _ReadCabinetState@8                   @651
    363365    WriteCabinetState                 = _WriteCabinetState@4                  @652
    364     PathProcessCommand                = _PathProcessCommand@16                @653
     366    PathProcessCommandA               = _PathProcessCommandA@16               @653
     367    PathProcessCommandW               = _PathProcessCommandW@16
     368    PathProcessCommand                = _PathProcessCommandAW@16
    365369                                        _SHELL32_654@8                        @654
    366370    FileIconInit                      = _FileIconInit@4                       @660

  • trunk/src/shell32/unknown.cpp

    r429 r1214  
    1 /* $Id: unknown.cpp,v 1.6 1999-08-05 23:19:56 phaller Exp $ */
     1/* $Id: unknown.cpp,v 1.7 1999-10-09 11:13:25 sandervl Exp $ */
    22
    33/*
    … …  
    1111 *****************************************************************************/
    1212
     13#include <odin.h>
     14#include <odinwrap.h>
    1315#include <os2win.h>
    1416#include <shellapi.h>
    1517#include <winreg.h>
    16 #include "shell32.h"
    17 
     18//#include "shell32.h"
     19
     20
     21ODINDEBUGCHANNEL(SHELL32-UNKNOWN)
    1822
    1923/*****************************************************************************
    … …  
    4751 *****************************************************************************/
    4852
    49 HINSTANCE WIN32API RealShellExecuteA(HWND    hwnd,
    50                                      LPCTSTR lpOperation,
    51                                      LPCTSTR lpFile,
    52                                      LPCTSTR lpParameters,
    53                                      LPCTSTR lpDirectory,
    54                                      INT     nShowCmd)
    55 {
    56   dprintf (("SHELL32: RealShellExecuteA(%08xh,%s,%s,%s,%s,%08xh) not implemented.\n",
    57             hwnd,
    58             lpOperation,
    59             lpFile,
    60             lpParameters,
    61             lpDirectory,
    62             nShowCmd));
     53ODINFUNCTION6(HINSTANCE, RealShellExecuteA,
     54              HWND,      hwnd,
     55              LPCTSTR,   lpOperation,
     56              LPCTSTR,   lpFile,
     57              LPCTSTR,   lpParameters,
     58              LPCTSTR,   lpDirectory,
     59              INT,       nShowCmd)
     60{
     61  dprintf (("SHELL32: RealShellExecuteA not implemented.\n"));
    6362
    6463  return(0); //out of memory
    … …  
    8382 *****************************************************************************/
    8483
    85 HINSTANCE WIN32API RealShellExecuteW(HWND    hwnd,
    86                                      LPCWSTR lpOperation,
    87                                      LPCWSTR lpFile,
    88                                      LPCWSTR lpParameters,
    89                                      LPCWSTR lpDirectory,
    90                                      INT     nShowCmd)
     84ODINFUNCTION6(HINSTANCE, RealShellExecuteW,
     85              HWND,      hwnd,
     86              LPCWSTR,   lpOperation,
     87              LPCWSTR,   lpFile,
     88              LPCWSTR,   lpParameters,
     89              LPCWSTR,   lpDirectory,
     90              INT,       nShowCmd)
    9191{
    9292  HINSTANCE hInstance;
    … …  
    132132 *****************************************************************************/
    133133
    134 BOOL WIN32API RealShellExecuteExA(LPSHELLEXECUTEINFOA lpExecInfo)
    135 {
    136   dprintf(("SHELL32: RealShellExecuteExA (%08xh) not implemented.\n",
    137            lpExecInfo));
     134ODINFUNCTION1(BOOL,                RealShellExecuteExA,
     135              LPSHELLEXECUTEINFOA, lpExecInfo)
     136{
     137  dprintf(("SHELL32: RealShellExecuteExA not implemented.\n"));
    138138
    139139  return (0);
    … …  
    153153 *****************************************************************************/
    154154
    155 BOOL WIN32API RealShellExecuteExW(LPSHELLEXECUTEINFOW lpExecInfo)
    156 {
    157   dprintf(("SHELL32: RealShellExecuteExW (%08xh) not implemented.\n",
    158            lpExecInfo));
     155ODINFUNCTION1(BOOL,                RealShellExecuteExW,
     156              LPSHELLEXECUTEINFOW, lpExecInfo)
     157{
     158  dprintf(("SHELL32: RealShellExecuteExW not implemented.\n"));
    159159
    160160  return (0);
    … …  
    174174 *****************************************************************************/
    175175
    176 DWORD WIN32API RegenerateUserEnvironment(DWORD x1,
    177                                          DWORD x2)
    178 {
    179   dprintf(("SHELL32: RegenerateUserEnvironment(%08xh,%08xhz) not implemented.\n",
    180            x1,
    181            x2));
     176ODINFUNCTION2(DWORD, RegenerateUserEnvironment,
     177              DWORD, x1,
     178              DWORD, x2)
     179{
     180  dprintf(("SHELL32: RegenerateUserEnvironment not implemented.\n"));
    182181
    183182  return (0);
    … …  
    197196 *****************************************************************************/
    198197
    199 DWORD WIN32API RestartDialog(DWORD x1,
    200                              DWORD x2,
    201                              DWORD x3)
    202 {
    203   dprintf(("SHELL32: RestartDialog(%08xh,%08xh,%08xh) not implemented.\n",
    204            x1,
    205            x2,
    206            x3));
     198ODINFUNCTION3(DWORD, RestartDialog,
     199              DWORD, x1,
     200              DWORD, x2,
     201              DWORD, x3)
     202{
     203  dprintf(("SHELL32: RestartDialog not implemented.\n"));
    207204
    208205  return (0);
    … …  
    222219 *****************************************************************************/
    223220
    224 DWORD WIN32API SheConvertPathW(DWORD x1,
    225                                DWORD x2)
    226 {
    227   dprintf(("SHELL32: SheConvertPathW(%08xh,%08xh) not implemented.\n",
    228            x1,
    229            x2));
     221ODINFUNCTION2(DWORD, SheConvertPathW,
     222              DWORD, x1,
     223              DWORD, x2)
     224{
     225  dprintf(("SHELL32: SheConvertPathW not implemented.\n"));
    230226
    231227  return (0);
    … …  
    245241 *****************************************************************************/
    246242
    247 DWORD WIN32API SheShortenPathW(DWORD x1,
    248                                DWORD x2)
    249 {
    250   dprintf(("SHELL32: SheShortenPathW(%08xh,%08xh) not implemented.\n",
    251            x1,
    252            x2));
     243ODINFUNCTION2(DWORD, SheShortenPathW,
     244              DWORD, x1,
     245              DWORD, x2)
     246{
     247  dprintf(("SHELL32: SheShortenPathW not implemented.\n"));
    253248
    254249  return (0);
    … …  
    268263 *****************************************************************************/
    269264
    270 DWORD WIN32API SheShortenPathA(DWORD x1,
    271                                DWORD x2)
    272 {
    273   dprintf(("SHELL32: SheShortenPathA(%08xh,%08xh) not implemented.\n",
    274            x1,
    275            x2));
    276 
    277   return (0);
    278 }
     265ODINFUNCTION2(DWORD, SheShortenPathA,
     266              DWORD, x1,
     267              DWORD, x2)
     268{
     269  dprintf(("SHELL32: SheShortenPathA not implemented.\n"));
     270
     271  return (0);
     272}
     273
Note: See TracChangeset for help on using the changeset viewer.