Changeset 183 for trunk/src


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

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

Location:
trunk/src/shell32
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/makefile

    r169 r183  
    1 # $Id: makefile,v 1.6 1999-06-23 22:19:05 phaller Exp $
     1# $Id: makefile,v 1.7 1999-06-24 19:27:48 phaller Exp $
    22
    33#
    … …  
    2121TARGET = shell32
    2222
    23 OBJS =  shell32.obj sh.obj she.obj drag.obj initterm.obj misc.obj ordinal.obj unknown.obj
     23OBJS =  shell32.obj sh.obj she.obj drag.obj initterm.obj \
     24        misc.obj ordinal.obj unknown.obj path.obj
    2425
    2526all: $(TARGET).dll $(TARGET).lib
    … …  
    5354unknown.obj: unknown.cpp shell32.h
    5455
     56path.obj: path.cpp shell32.h
     57
    5558initterm.obj: initterm.cpp
    5659

  • trunk/src/shell32/misc.cpp

    r168 r183  
    1 /* $Id: misc.cpp,v 1.1 1999-06-23 22:17:52 phaller Exp $ */
     1/* $Id: misc.cpp,v 1.2 1999-06-24 19:27:48 phaller Exp $ */
    22
    33/*
    … …  
    1717#include <os2win.h>
    1818#include <shellapi.h>
     19#include <wchar.h>
     20#include <wcstr.h>
     21#include <winnls.h>
    1922#include "shell32.h"
    2023#include <misc.h>
    … …  
    352355}
    353356
     357
     358/*****************************************************************************
     359 * Name      : ParseField
     360 * Purpose   :
     361 * Parameters:
     362 * Variables :
     363 * Result    :
     364 * Remark    : SHELL32.58
     365 * Status    : UNTESTED UNKNOWN STUB
     366 *
     367 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     368 *****************************************************************************/
     369
     370DWORD WIN32API ParseFieldA(LPCSTR src,
     371                           DWORD  field,
     372                           LPSTR  dst,
     373                           DWORD  len)
     374{
     375  dprintf(("SHELL32: ParseFieldA(%s,%08xh,%08xh,%08xh) not correctly implemented.\n",
     376           src,
     377           field,
     378           dst,
     379           len));
     380
     381  if (!src || !src[0] || !dst || !len)
     382    return 0;
     383
     384  if (field >1)
     385  {
     386    field--;
     387    while (field)
     388    {
     389      if (*src==0x0) return FALSE;
     390      if (*src==',') field--;
     391      src++;
     392    }
     393  }
     394
     395  while (*src!=0x00 && *src!=',' && len>0)
     396  {
     397    *dst=*src; dst++, src++; len--;
     398  }
     399  *dst=0x0;
     400  return TRUE;
     401}
     402
     403
     404/*****************************************************************************
     405 * Name      : PickIconDlg
     406 * Purpose   :
     407 * Parameters:
     408 * Variables :
     409 * Result    :
     410 * Remark    : SHELL32.62
     411 * Status    : UNTESTED UNKNOWN STUB
     412 *
     413 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     414 *****************************************************************************/
     415
     416DWORD WIN32API PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
     417{
     418  dprintf(("SHELL32: PickIconDlg(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     419           x,
     420           y,
     421           z,
     422           a));
     423
     424  return 0xffffffff;
     425}
     426
     427
     428/*****************************************************************************
     429 * Name      : GetFileNameFromBrowse
     430 * Purpose   :
     431 * Parameters:
     432 * Variables :
     433 * Result    :
     434 * Remark    : SHELL32.63
     435 * Status    : UNTESTED UNKNOWN STUB
     436 *
     437 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     438 *****************************************************************************/
     439
     440DWORD WIN32API GetFileNameFromBrowse(HWND   howner,
     441                                     LPSTR  targetbuf,
     442                                     DWORD  len,
     443                                     DWORD  x,
     444                                     LPCSTR suffix,
     445                                     LPCSTR y,
     446                                     LPCSTR cmd)
     447{
     448  dprintf(("SHELL32: GetFileNameFromBrowse(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     449           howner,
     450           targetbuf,
     451           len,
     452           x,
     453           suffix,
     454           y,
     455           cmd));
     456
     457  /* puts up a Open Dialog and requests input into targetbuf */
     458  /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
     459  strcpy(targetbuf,
     460         "x:\\dummy.exe");
     461
     462  return 1;
     463}
     464
     465
     466/*****************************************************************************
     467 * Name      : OleStrToStrN
     468 * Purpose   :
     469 * Parameters:
     470 * Variables :
     471 * Result    :
     472 * Remark    : SHELL32.78
     473 * Status    : UNTESTED UNKNOWN STUB
     474 *
     475 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     476 *****************************************************************************/
     477
     478BOOL WIN32API OleStrToStrN (LPSTR   lpMulti,
     479                            INT     nMulti,
     480                            LPCWSTR lpWide,
     481                            INT     nWide)
     482{
     483  dprintf(("SHELL32: OleStrToStrN(%08xh,%08xh,%08xh,%08xh)\n",
     484           lpMulti,
     485           nMulti,
     486           lpWide,
     487           nWide));
     488
     489  return WideCharToMultiByte (0,
     490                              0,
     491                              lpWide,
     492                              nWide,
     493                              lpMulti,
     494                              nMulti,
     495                              NULL,
     496                              NULL);
     497}
     498
     499
     500/*****************************************************************************
     501 * Name      : StrToOleStrN
     502 * Purpose   :
     503 * Parameters:
     504 * Variables :
     505 * Result    :
     506 * Remark    : SHELL32.79
     507 * Status    : UNTESTED UNKNOWN STUB
     508 *
     509 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     510 *****************************************************************************/
     511
     512BOOL WIN32API StrToOleStrN (LPWSTR lpWide,
     513                            INT    nWide,
     514                            LPCSTR lpMulti,
     515                            INT    nMulti)
     516{
     517  dprintf(("SHELL32: StrToOleStrN(%08xh,%08xh,%08xh,%08xh)\n",
     518           lpWide,
     519           nWide,
     520           lpMulti,
     521           nMulti));
     522
     523  return MultiByteToWideChar (0,
     524                              0,
     525                              lpMulti,
     526                              nMulti,
     527                              lpWide,
     528                              nWide);
     529}
     530
     531
     532/*****************************************************************************
     533 * Name      : RegisterShellHook
     534 * Purpose   :
     535 * Parameters:
     536 * Variables :
     537 * Result    :
     538 * Remark    : SHELL32.181
     539 * Status    : UNTESTED UNKNOWN STUB
     540 *
     541 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     542 *
     543 * PARAMS
     544 *      hwnd [I]  window handle
     545 *      y    [I]  flag ????
     546 *
     547 * NOTES
     548 *     exported by ordinal
     549 */
     550
     551void WIN32API RegisterShellHook(HWND  hwnd,
     552                                DWORD y)
     553{
     554  dprintf(("SHELL32: RegisterShellHook(%08xh, %08xh) not implemented.\n",
     555           hwnd,
     556           y));
     557}
     558
     559
     560/*****************************************************************************
     561 * Name      : RunFileDlg
     562 * Purpose   :
     563 * Parameters:
     564 * Variables :
     565 * Result    :
     566 * Remark    : SHELL32.61
     567 * Status    : UNTESTED UNKNOWN STUB
     568 *
     569 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     570 *****************************************************************************/
     571
     572DWORD WIN32API RunFileDlg (HWND  hwndOwner,
     573                           DWORD dwParam1,
     574                           DWORD dwParam2,
     575                           LPSTR lpszTitle,
     576                           LPSTR lpszPrompt,
     577                           UINT  uFlags)
     578{
     579  dprintf(("SHELL32: RunFileDlg(%08xh,%08xh,%08xh,%s,%s,%08xh) not implemented.\n",
     580           hwndOwner,
     581           dwParam1,
     582           dwParam2,
     583           lpszTitle,
     584           lpszPrompt,
     585           uFlags));
     586
     587  return 0;
     588}
     589
     590
     591/*****************************************************************************
     592 * Name      : ExitWindowsDialog
     593 * Purpose   :
     594 * Parameters:
     595 * Variables :
     596 * Result    :
     597 * Remark    : SHELL32.60
     598 * Status    : UNTESTED UNKNOWN STUB
     599 *
     600 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     601 *****************************************************************************/
     602
     603void WIN32API ExitWindowsDialog (HWND hWndOwner)
     604{
     605  dprintf(("SHELL32: ExitWindowsDialog(%08xh)\n",
     606           hWndOwner));
     607
     608   if (MessageBoxA(hWndOwner,
     609                   "Do you want to exit ODIN?",
     610                   "Shutdown",
     611                   MB_YESNO|MB_ICONQUESTION)
     612       == IDOK)
     613   {
     614     SendMessageA (hWndOwner,
     615                   WM_QUIT,
     616                   0,
     617                   0);
     618   }
     619}
     620
     621
     622/*****************************************************************************
     623 * Name      : ArrangeWindows
     624 * Purpose   :
     625 * Parameters:
     626 * Variables :
     627 * Result    :
     628 * Remark    : SHELL32.184
     629 * Status    : UNTESTED UNKNOWN STUB
     630 *
     631 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     632 *****************************************************************************/
     633
     634DWORD WIN32API ArrangeWindows (DWORD dwParam1,
     635                               DWORD dwParam2,
     636                               DWORD dwParam3,
     637                               DWORD dwParam4,
     638                               DWORD dwParam5)
     639{
     640  dprintf(("SHELL32: ArrangeWindows(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     641           dwParam1,
     642           dwParam2,
     643           dwParam3,
     644           dwParam4,
     645           dwParam5));
     646
     647  return 0;
     648}
     649
     650
     651/*****************************************************************************
     652 * Name      : SignalFileOpen
     653 * Purpose   :
     654 * Parameters:
     655 * Variables :
     656 * Result    :
     657 * Remark    : SHELL32.103
     658 * Status    : UNTESTED UNKNOWN STUB
     659 *
     660 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     661 *****************************************************************************/
     662
     663DWORD WIN32API SignalFileOpen (DWORD dwParam1)
     664{
     665  dprintf(("SHELL32: SignalFileOpen(%08xh) not implemented.\n",
     666           dwParam1));
     667
     668  return 0;
     669}
     670
     671
     672/*****************************************************************************
     673 * Name      : DAD_ShowDrawImage
     674 * Purpose   :
     675 * Parameters:
     676 * Variables :
     677 * Result    :
     678 * Remark    : SHELL32.137
     679 * Status    : UNTESTED UNKNOWN STUB
     680 *
     681 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     682 *****************************************************************************/
     683
     684HRESULT WIN32API DAD_ShowDragImage (DWORD u)
     685{
     686  dprintf(("SHELL32: DAD_ShowDragImage(%08xh) not implemented.\n",
     687           u));
     688
     689  return 0;
     690}
     691
     692
     693/*****************************************************************************
     694 * Name      : ReadCabinetState
     695 * Purpose   :
     696 * Parameters:
     697 * Variables :
     698 * Result    :
     699 * Remark    : SHELL32.651
     700 * Status    : UNTESTED UNKNOWN STUB
     701 *
     702 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     703 *****************************************************************************/
     704
     705HRESULT WIN32API ReadCabinetState(DWORD u,
     706                                  DWORD v)
     707{
     708  dprintf(("SHELL32: ReadCabinetState(%08xh, %08xh) not implemented.\n",
     709           u,
     710           v));
     711
     712  return 0;
     713}
     714
     715
     716/*****************************************************************************
     717 * Name      : WriteCabinetState
     718 * Purpose   :
     719 * Parameters:
     720 * Variables :
     721 * Result    :
     722 * Remark    : SHELL32.652
     723 * Status    : UNTESTED UNKNOWN STUB
     724 *
     725 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     726 *****************************************************************************/
     727
     728HRESULT WIN32API WriteCabinetState(DWORD u)
     729{
     730  dprintf(("SHELL32: WriteCabinetState(%08xh) not implemented.\n",
     731           u));
     732
     733  return 0;
     734}
     735
     736
     737/*****************************************************************************
     738 * Name      : FileIconInit
     739 * Purpose   :
     740 * Parameters:
     741 * Variables :
     742 * Result    :
     743 * Remark    : SHELL32.660
     744 * Status    : UNTESTED UNKNOWN STUB
     745 *
     746 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     747 *****************************************************************************/
     748
     749BOOL WIN32API FileIconInit(BOOL bFullInit)
     750{
     751  dprintf(("SHELL32: FileIconInit(%08xh) not implemented.\n",
     752           bFullInit));
     753
     754  return 0;
     755}
     756
     757
     758/*****************************************************************************
     759 * Name      : IsUserAdmin
     760 * Purpose   :
     761 * Parameters:
     762 * Variables :
     763 * Result    :
     764 * Remark    : SHELL32.680
     765 * Status    : UNTESTED UNKNOWN STUB
     766 *
     767 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     768 *****************************************************************************/
     769
     770HRESULT WIN32API IsUserAdmin(void)
     771{
     772  dprintf(("SHELL32: IsUserAdmin() not implmented. Yes, user is admin ;-)\n"));
     773
     774  return TRUE;
     775}
     776
     777
     778/*****************************************************************************
     779 * Name      : StrRetToStrN
     780 * Purpose   : converts a STRRET to a normal string
     781 * Parameters: the pidl is for STRRET OFFSET
     782 * Variables :
     783 * Result    :
     784 * Remark    : SHELL32.96
     785 * Status    : UNTESTED UNKNOWN STUB
     786 *
     787 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     788 *****************************************************************************/
     789
     790HRESULT WIN32API StrRetToStrN (LPVOID       dest,
     791                               DWORD        len,
     792                               LPSTRRET     src,
     793                               LPITEMIDLIST pidl)
     794{
     795  dprintf(("SHELL32: StrRetToStrN(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     796           dest,
     797           len,
     798           src,
     799           pidl));
     800
     801  switch (src->uType)
     802  {
     803    case STRRET_WSTR:
     804      WideCharToMultiByte(CP_ACP,
     805                          0,
     806                          src->u.pOleStr,
     807                          -1,
     808                          (LPSTR)dest,
     809                          len,
     810                          NULL,
     811                          NULL);
     812      SHFree(src->u.pOleStr);
     813      break;
     814
     815    case STRRET_CSTRA:
     816      //if (VERSION_OsIsUnicode())
     817      //  lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
     818      //else
     819        strncpy((LPSTR)dest,
     820                src->u.cStr,
     821                len);
     822      break;
     823
     824    case STRRET_OFFSETA:
     825      if (pidl)
     826      {
     827        //if(VERSION_OsIsUnicode())
     828        //  lstrcpynAtoW((LPWSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
     829        //else
     830          strncpy((LPSTR)dest,
     831                  ((LPCSTR)&pidl->mkid)+src->u.uOffset,
     832                  len);
     833        break;
     834      }
     835
     836    default:
     837      dprintf(("SHELL32: StrRetToStrN: unknown type!\n"));
     838
     839      if (len)
     840        *(LPSTR)dest = '\0';
     841
     842      return(FALSE);
     843  }
     844  return(TRUE);
     845}
     846
     847/*****************************************************************************
     848 * Name      : StrChrW
     849 * Purpose   :
     850 * Parameters:
     851 * Variables :
     852 * Result    :
     853 * Remark    : SHELL32.651
     854 * Status    : UNTESTED UNKNOWN STUB
     855 *
     856 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     857 *****************************************************************************/
     858
     859LPWSTR WIN32API StrChrW (LPWSTR str,
     860                         WCHAR  x)
     861{
     862  dprintf (("SHELL32: StrChrW(%08xh, %08xh)\n",
     863            str,
     864            x));
     865
     866  return ((LPWSTR)wcschr((const wchar_t*)str,
     867                         x));
     868}
     869
     870
     871/*****************************************************************************
     872 * Name      : StrChrNIW
     873 * Purpose   :
     874 * Parameters:
     875 * Variables :
     876 * Result    :
     877 * Remark    : SHELL32.?
     878 * Status    : UNTESTED UNKNOWN STUB
     879 *
     880 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     881 *****************************************************************************/
     882
     883INT WIN32API StrCmpNIW (LPWSTR wstr1,
     884                        LPWSTR wstr2,
     885                        INT    len)
     886{
     887  dprintf(("SHELL32: StrCmpNIW(%08xh,%08xh,%08xh) not correctly implemented.\n",
     888           wstr1,
     889           wstr2,
     890           len));
     891
     892  return (wcsncmp((const wchar_t*)wstr1,
     893                  (const wchar_t*)wstr2,
     894                  len));
     895}
     896
     897
     898/*****************************************************************************
     899 * Name      : DriveType
     900 * Purpose   :
     901 * Parameters:
     902 * Variables :
     903 * Result    :
     904 * Remark    : SHELL32.64
     905 * Status    : UNTESTED UNKNOWN STUB
     906 *
     907 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     908 *****************************************************************************/
     909
     910HRESULT WIN32API DriveType(DWORD u)
     911{
     912  dprintf(("SHELL32: DriveType(%08xh) not implemented.\n",
     913           u));
     914
     915  return 0;
     916}
     917
     918
     919/*****************************************************************************
     920 * Name      : StrRChrW
     921 * Purpose   :
     922 * Parameters:
     923 * Variables :
     924 * Result    :
     925 * Remark    : SHELL32.320, wcsrchr does not work?
     926 * Status    : UNTESTED UNKNOWN STUB
     927 *
     928 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     929 *****************************************************************************/
     930
     931LPWSTR WIN32API StrRChrW(LPWSTR lpStart,
     932                         LPWSTR lpEnd,
     933                         DWORD  wMatch)
     934{
     935  LPWSTR wptr=NULL;
     936
     937  dprintf(("SHELL32: StrRChrW(%08xh,%08xh,%08xh)\n",
     938           lpStart,
     939           lpEnd,
     940           wMatch));
     941
     942  /* if the end not given, search*/
     943  if (!lpEnd)
     944  {
     945    lpEnd=lpStart;
     946    while (*lpEnd)
     947      lpEnd++;
     948  }
     949
     950  do
     951  {
     952    if (*lpStart==(WCHAR)wMatch)
     953      wptr = lpStart;
     954    lpStart++;
     955  }
     956  while ( lpStart<=lpEnd );
     957  return wptr;
     958}
     959
     960
     961/*****************************************************************************
     962 * Name      : Control_FillCache_RunDLL
     963 * Purpose   :
     964 * Parameters:
     965 * Variables :
     966 * Result    :
     967 * Remark    : SHELL32.8
     968 * Status    : UNTESTED UNKNOWN STUB
     969 *
     970 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     971 *****************************************************************************/
     972
     973HRESULT WIN32API Control_FillCache_RunDLL(HWND   hWnd,
     974                                          HANDLE hModule,
     975                                          DWORD  w,
     976                                          DWORD  x)
     977{
     978  dprintf(("SHELL32: Control_FillCache_RunDLL(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     979           hWnd,
     980           hModule,
     981           w,
     982           x));
     983
     984  return 0;
     985}
     986
     987
     988/*****************************************************************************
     989 * Name      : RunDLL_CallEntry16
     990 * Purpose   :
     991 * Parameters:
     992 * Variables :
     993 * Result    :
     994 * Remark    : SHELL32.122 - the name is propably wrong
     995 * Status    : UNTESTED UNKNOWN STUB
     996 *
     997 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     998 *****************************************************************************/
     999
     1000HRESULT WIN32API RunDLL_CallEntry16(DWORD v,
     1001                                    DWORD w,
     1002                                    DWORD x,
     1003                                    DWORD y,
     1004                                    DWORD z)
     1005{
     1006  dprintf(("SHELL32: RunDLL_CallEntry16(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     1007           v,
     1008           w,
     1009           x,
     1010           y,
     1011           z));
     1012
     1013  return 0;
     1014}
     1015
     1016
     1017/*****************************************************************************
     1018 * Name      : SHELL32_654
     1019 * Purpose   :
     1020 * Parameters:
     1021 * Variables :
     1022 * Result    :
     1023 * Remark    : SHELL32.654
     1024 * Status    : UNTESTED UNKNOWN STUB
     1025 *
     1026 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     1027 *****************************************************************************/
     1028
     1029HRESULT WIN32API SHELL32_654 (DWORD x,
     1030                              DWORD y)
     1031{
     1032  dprintf(("SHELL32: SHELL32_654(%08xh,%08xh) not implemented.\n",
     1033           x,
     1034           y));
     1035  return 0;
     1036}
     1037
     1038
     1039/*****************************************************************************
     1040 * Name      : RLBuildListOfPaths
     1041 * Purpose   :
     1042 * Parameters:
     1043 * Variables :
     1044 * Result    :
     1045 * Remark    : SHELL32.146 - builds a DPA
     1046 * Status    : UNTESTED UNKNOWN STUB
     1047 *
     1048 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     1049 *****************************************************************************/
     1050
     1051DWORD WIN32API RLBuildListOfPaths ()
     1052{
     1053  dprintf(("SHELL32: RLBuildListOfPaths() not implemented.\n"));
     1054  return 0;
     1055}
     1056
     1057
     1058/*****************************************************************************
     1059 * Name      : StrToOleStr
     1060 * Purpose   :
     1061 * Parameters:
     1062 * Variables :
     1063 * Result    :
     1064 * Remark    : SHELL32.163
     1065 * Status    : UNTESTED UNKNOWN STUB
     1066 *
     1067 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     1068 *****************************************************************************/
     1069
     1070int WIN32API StrToOleStr (LPWSTR lpWideCharStr,
     1071                          LPCSTR lpMultiByteString)
     1072{
     1073  dprintf(("SHELL32: StrToOleStr(%08xh,%08xh)\n",
     1074           lpWideCharStr,
     1075           lpMultiByteString));
     1076
     1077  return MultiByteToWideChar(0,
     1078                             0,
     1079                             lpMultiByteString,
     1080                             -1,
     1081                             lpWideCharStr,
     1082                             MAX_PATH);
     1083}
     1084
     1085
     1086/*****************************************************************************
     1087 * Name      : SetAppStartingCursor
     1088 * Purpose   :
     1089 * Parameters:
     1090 * Variables :
     1091 * Result    :
     1092 * Remark    : SHELL32.99
     1093 * Status    : UNTESTED UNKNOWN STUB
     1094 *
     1095 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     1096 *****************************************************************************/
     1097
     1098HRESULT WIN32API SetAppStartingCursor(HWND  u,
     1099                                      DWORD v)
     1100{
     1101  dprintf(("SHELL32: SetAppStartingCursor (SHELL32.99): (%08xh,%08xh) not implemented.\n",
     1102           u,
     1103           v));
     1104
     1105  return 0;
     1106}
     1107

  • trunk/src/shell32/ordinal.cpp

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

  • trunk/src/shell32/sh.cpp

    r177 r183  
    1 /* $Id: sh.cpp,v 1.3 1999-06-24 09:02:08 phaller Exp $ */
     1/* $Id: sh.cpp,v 1.4 1999-06-24 19:27:49 phaller Exp $ */
    22
    33/*
    … …  
    1515#include <shellapi.h>
    1616#include <winreg.h>
     17//#include <shlobj.h> @@@PH shlobj is yet to be ported
    1718#include "shell32.h"
    1819
    … …  
    3233 *****************************************************************************/
    3334
    34 
    35 /*****************************************************************************
    36  * Name      : HRESULT SHGetMalloc
    37  * Purpose   :
    38  * Parameters: LPMALLOC *ppMalloc
    39  * Variables :
    40  * Result    :
    41  * Remark    :
    42  * Status    : UNTESTED STUB
    43  *
    44  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    45  *****************************************************************************/
    46 
    47 HRESULT WIN32API SHGetMalloc(LPMALLOC *ppMalloc)
    48 {
    49   dprintf(("SHELL32: SHGetMalloc(%08xh) not implemented.\n",
    50            ppMalloc));
    51 
    52   return(0);
    53 }
     35#define LPSHELLVIEWDATA  LPVOID
     36#define LPUNKNOWN        LPVOID
     37#define IDSTRUCT         VOID
     38#define LPSHELLFLAGSTATE LPVOID
     39#define IDropTarget      VOID
     40
     41static LPUNKNOWN SHELL32_IExplorerInterface=0;
     42
     43
     44/*****************************************************************************
     45 * Name      : DWORD WIN32API SHChangeNotifyRegister
     46 * Purpose   :
     47 * Parameters:
     48 * Variables :
     49 * Result    :
     50 * Remark    : SHELL32.2
     51 * Status    : UNTESTED STUB
     52 *
     53 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     54 *
     55 * NOTES
     56 *   Idlist is an array of structures and Count specifies how many items in the array
     57 *   (usually just one I think).
     58 */
     59
     60DWORD WIN32API SHChangeNotifyRegister(HWND hwnd,
     61                                      LONG events1,
     62                                      LONG events2,
     63                                      DWORD msg,
     64                                      int count,
     65                                      IDSTRUCT *idlist)
     66{
     67  dprintf(("SHELL32: SHChangeNotifyRegister(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     68           hwnd,
     69           events1,
     70           events2,
     71           msg,
     72           count,
     73           idlist));
     74
     75  return 0;
     76}
     77
     78
     79/*****************************************************************************
     80 * Name      : DWORD WIN32API SHChangeNotifyDeregister
     81 * Purpose   :
     82 * Parameters:
     83 * Variables :
     84 * Result    :
     85 * Remark    : SHELL32.4
     86 * Status    : UNTESTED STUB
     87 *
     88 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     89 */
     90
     91DWORD WIN32API SHChangeNotifyDeregister(LONG x1)
     92{
     93  dprintf(("SHELL32: SHChangeNotifyDeregister(%08xh) not implemented.\n",
     94           x1));
     95
     96  return 0;
     97}
     98
     99
     100/*****************************************************************************
     101 * Name      : void WIN32API SHGetSettings
     102 * Purpose   :
     103 * Parameters:
     104 * Variables :
     105 * Result    :
     106 * Remark    : SHELL32.68
     107 * Status    : UNTESTED STUB
     108 *
     109 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     110 *
     111 * NOTES
     112 *  the registry path are for win98 (tested)
     113 *  and possibly are the same in nt40
     114 */
     115
     116void WIN32API SHGetSettings(LPSHELLFLAGSTATE lpsfs,
     117                            DWORD            dwMask,
     118                            DWORD            dwx)
     119{
     120  HKEY  hKey;
     121  DWORD dwData;
     122  DWORD dwDataSize = sizeof (DWORD);
     123
     124  dprintf(("SHELL32: SHGetSettings(%08xh, %08xh, %08xh)\n",
     125           lpsfs,
     126           dwMask,
     127           dwx));
     128
     129  if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
     130            0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
     131    return;
     132
     133//@@@PH: todo
     134#if 0
     135   if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     136     lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
     137
     138   if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     139     lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
     140
     141   if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     142     lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
     143
     144   if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     145     lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
     146
     147   if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     148     lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
     149
     150   if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     151     lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
     152
     153   if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
     154   { if (dwData == 0)
     155     { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 0;
     156       if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 0;
     157     }
     158     else if (dwData == 1)
     159     { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 1;
     160       if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 0;
     161     }
     162     else if (dwData == 2)
     163     { if (SSF_SHOWALLOBJECTS & dwMask)  lpsfs->fShowAllObjects  = 0;
     164       if (SSF_SHOWSYSFILES & dwMask)    lpsfs->fShowSysFiles  = 1;
     165     }
     166   }
     167#endif
     168
     169  RegCloseKey (hKey);
     170}
     171
     172
     173/*****************************************************************************
     174 * Name      : int WIN32API SHShellFolderView_Message
     175 * Purpose   :
     176 * Parameters:
     177 * Variables :
     178 * Result    :
     179 * Remark    : SHELL32.73
     180 * Status    : UNTESTED STUB
     181 *
     182 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     183 *
     184 * SHShellFolderView_Message                   [SHELL32.73]
     185 *
     186 * PARAMETERS
     187 *  hwndCabinet defines the explorer cabinet window that contains the
     188 *              shellview you need to communicate with
     189 *  uMsg        identifying the SFVM enum to perform
     190 *  lParam
     191 *
     192 * NOTES
     193 *  Message SFVM_REARRANGE = 1
     194 *    This message gets sent when a column gets clicked to instruct the
     195 *    shell view to re-sort the item list. lParam identifies the column
     196 *    that was clicked.
     197 */
     198
     199int WIN32API SHShellFolderView_Message(HWND   hwndCabinet,
     200                                       UINT   uMsg,
     201                                       LPARAM lParam)
     202{
     203  dprintf(("SHELL32: SHShellFolderView_Message(%08xh,%08xh,%08xh) not implemented.\n",
     204           hwndCabinet,
     205           uMsg,
     206           lParam));
     207
     208  return 0;
     209}
     210
     211
     212
     213
     214/*****************************************************************************
     215 * Name      : DWORD WIN32API SHRegisterDragDrop
     216 * Purpose   :
     217 * Parameters:
     218 * Variables :
     219 * Result    :
     220 * Remark    : SHELL32.86
     221 * Status    : UNTESTED STUB
     222 *
     223 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     224 *
     225 * NOTES
     226 *     exported by ordinal
     227 */
     228
     229DWORD WIN32API SHRegisterDragDrop(HWND        hWnd,
     230                                  IDropTarget *pDropTarget)
     231{
     232  dprintf(("SHELL32: SHRegisterDragDrop(%08xh,%08xh)\n",
     233           hWnd,
     234           pDropTarget));
     235
     236  // return RegisterDragDrop(hWnd,
     237  //                         pDropTarget);
     238  return 0;
     239}
     240
     241/*****************************************************************************
     242 * Name      : DWORD WIN32API SHRevokeDragDrop
     243 * Purpose   :
     244 * Parameters:
     245 * Variables :
     246 * Result    :
     247 * Remark    : SHELL32.87
     248 * Status    : UNTESTED STUB
     249 *
     250 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     251 *
     252 * NOTES
     253 *     exported by ordinal
     254 */
     255
     256DWORD WIN32API SHRevokeDragDrop(DWORD x)
     257{
     258  dprintf(("SHELL32: SHRevokeDragDrop(%08xh) not implemented.\n",
     259           x));
     260
     261  return 0;
     262}
     263
     264
     265/*****************************************************************************
     266 * Name      : HRESULT SHWaitForFileToOpen
     267 * Purpose   :
     268 * Parameters: DWORD x
     269 *             DWORD y
     270 *             DWORD z
     271 * Variables :
     272 * Result    :
     273 * Remark    : SHELL32.97
     274 * Status    : UNTESTED STUB
     275 *
     276 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     277 *****************************************************************************/
     278
     279HRESULT WIN32API SHWaitForFileToOpen(DWORD u,
     280                                     DWORD v,
     281                                     DWORD w)
     282{
     283  dprintf(("SHELL32: SHWaitForFileToOpen(%08xh,%08xh,%08xh) not implemented.\n",
     284           u,
     285           v,
     286           w));
     287
     288  return 0;
     289}
     290
     291
     292/*****************************************************************************
     293 * Name      : DWORD WIN32API SHRestricted
     294 * Purpose   :
     295 * Parameters:
     296 * Variables :
     297 * Result    :
     298 * Remark    : SHELL32.100
     299 * Status    : UNTESTED STUB
     300 *
     301 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     302 *
     303 * walks through policy table, queries <app> key, <type> value, returns
     304 * queried (DWORD) value.
     305 * {0x00001,Explorer,NoRun}
     306 * {0x00002,Explorer,NoClose}
     307 * {0x00004,Explorer,NoSaveSettings}
     308 * {0x00008,Explorer,NoFileMenu}
     309 * {0x00010,Explorer,NoSetFolders}
     310 * {0x00020,Explorer,NoSetTaskbar}
     311 * {0x00040,Explorer,NoDesktop}
     312 * {0x00080,Explorer,NoFind}
     313 * {0x00100,Explorer,NoDrives}
     314 * {0x00200,Explorer,NoDriveAutoRun}
     315 * {0x00400,Explorer,NoDriveTypeAutoRun}
     316 * {0x00800,Explorer,NoNetHood}
     317 * {0x01000,Explorer,NoStartBanner}
     318 * {0x02000,Explorer,RestrictRun}
     319 * {0x04000,Explorer,NoPrinterTabs}
     320 * {0x08000,Explorer,NoDeletePrinter}
     321 * {0x10000,Explorer,NoAddPrinter}
     322 * {0x20000,Explorer,NoStartMenuSubFolders}
     323 * {0x40000,Explorer,MyDocsOnNet}
     324 * {0x80000,WinOldApp,NoRealMode}
     325 *
     326 * NOTES
     327 *     exported by ordinal
     328 */
     329
     330DWORD WIN32API SHRestricted (DWORD pol)
     331{
     332  HKEY  xhkey;
     333
     334  dprintf(("SHELL32: SHRestricted(%08xh) not implemented.\n",
     335           pol));
     336
     337  if (RegOpenKeyA(HKEY_CURRENT_USER,
     338                  "Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
     339                  &xhkey))
     340    return 0;
     341
     342  /* FIXME: do nothing for now, just return 0 (== "allowed") */
     343  RegCloseKey(xhkey);
     344  return 0;
     345}
     346
     347
     348/*****************************************************************************
     349 * Name      : HRESULT SHFlushClipboard
     350 * Purpose   :
     351 * Parameters:
     352 * Variables :
     353 * Result    :
     354 * Remark    : SHELL32.121
     355 * Status    : UNTESTED STUB
     356 *
     357 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     358 *****************************************************************************/
     359
     360HRESULT WIN32API SHFlushClipboard(void)
     361{
     362  dprintf(("SHELL32: SHFlushClipboard() not implemented.\n"));
     363
     364  return 1;
     365}
     366
     367
     368/*****************************************************************************
     369 * Name      : HRESULT SHFreeUnusedLibraries
     370 * Purpose   :
     371 * Parameters:
     372 * Variables :
     373 * Result    :
     374 * Remark    : SHELL32.123
     375 * Status    : UNTESTED STUB
     376 *
     377 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     378 *****************************************************************************/
     379
     380HRESULT WIN32API SHFreeUnusedLibraries (void)
     381{
     382  dprintf(("SHELL32: SHFreeUnusedLibraries() not implemented.\n"));
     383  return TRUE;
     384}
     385
     386
     387/*****************************************************************************
     388 * Name      : HRESULT SHWinHelp
     389 * Purpose   :
     390 * Parameters:
     391 * Variables :
     392 * Result    :
     393 * Remark    : SHELL32.127
     394 * Status    : UNTESTED STUB
     395 *
     396 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     397 *****************************************************************************/
     398
     399HRESULT WIN32API SHWinHelp (DWORD v,
     400                            DWORD w,
     401                            DWORD x,
     402                            DWORD z)
     403{
     404  dprintf(("SHELL32: SHWinHelp(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     405           v,
     406           w,
     407           x,
     408           z));
     409
     410  return 0;
     411}
     412
     413
     414/*****************************************************************************
     415 * Name      : HRESULT SHOutOfMemoryMessageBox
     416 * Purpose   :
     417 * Parameters:
     418 * Variables :
     419 * Result    :
     420 * Remark    : SHELL32.126
     421 * Status    : UNTESTED STUB
     422 *
     423 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     424 *****************************************************************************/
     425
     426HRESULT WIN32API SHOutOfMemoryMessageBox(DWORD u,
     427                                         DWORD v,
     428                                         DWORD w)
     429{
     430  dprintf(("SHELL32: SHOutOfmemoryMessageBox(%08xh,%08xh,%08xh) not implemented.\n",
     431           u,
     432           v,
     433           w));
     434
     435  return 0;
     436}
     437
     438
     439/*****************************************************************************
     440 * Name      : HRESULT SHLoadOLE
     441 * Purpose   :
     442 * Parameters:
     443 * Variables :
     444 * Result    :
     445 * Remark    : SHELL32.151
     446 * Status    : UNTESTED STUB
     447 *
     448 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     449 *****************************************************************************/
     450
     451HRESULT WIN32API SHLoadOLE(DWORD u)
     452{
     453  dprintf(("SHELL32: SHLoadOle(%08xh) not implemented.\n",
     454           u));
     455
     456  return S_OK;
     457}
     458
     459
     460/*****************************************************************************
     461 * Name      : HRESULT SHRunControlPanel
     462 * Purpose   :
     463 * Parameters:
     464 * Variables :
     465 * Result    :
     466 * Remark    : SHELL32.161
     467 * Status    : UNTESTED STUB
     468 *
     469 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     470 *****************************************************************************/
     471
     472HRESULT WIN32API SHRunControlPanel (DWORD x,
     473                                    DWORD z)
     474{
     475  dprintf(("SHELL32: SHRunControlPanel(%08xh, %08xh) not implemented.\n",
     476           x,
     477           z));
     478
     479  return 0;
     480}
     481
     482
     483/*****************************************************************************
     484 * Name      : DWORD WIN32API SHCreateDirectory
     485 * Purpose   :
     486 * Parameters:
     487 * Variables :
     488 * Result    :
     489 * Remark    : SHELL32.165
     490 * Status    : UNTESTED STUB
     491 *
     492 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     493 *
     494 * NOTES
     495 *  exported by ordinal
     496 *  not sure about LPSECURITY_ATTRIBUTES
     497 */
     498
     499DWORD WIN32API SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,
     500                                 LPCSTR                path)
     501{
     502  dprintf(("SHELL32: SHCreateDirectory(%08xh, %08xh) not implemented.\n",
     503           sec,
     504           path));
     505
     506 if (CreateDirectoryA(path,sec))
     507   return TRUE;
     508
     509 /* SHChangeNotify(8,1,path,0); */
     510 return FALSE;
     511
     512//   if (SHELL32_79(path,(LPVOID)x))
     513//      return 0;
     514//   FIXME("(%08lx,%s):stub.\n",x,path);
     515//   return 0;
     516}
     517
     518
     519/*****************************************************************************
     520 * Name      : HRESULT SHValidateUNC
     521 * Purpose   : validating a UNC path ? so the parameters are not correct !
     522 * Parameters: DWORD x
     523 *             DWORD y
     524 *             DWORD z
     525 * Variables :
     526 * Result    :
     527 * Remark    : SHELL32.173
     528 * Status    : UNTESTED STUB
     529 *
     530 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     531 *****************************************************************************/
     532
     533HRESULT WIN32API SHValidateUNC (DWORD x,
     534                                DWORD y,
     535                                DWORD z)
     536{
     537  dprintf(("SHELL32: SHValidateUnc(%08x,%08xh,%08xh) not implemented.\n",
     538           x,
     539           y,
     540           z));
     541
     542 return 0;
     543}
     544
     545
     546/*****************************************************************************
     547 * Name      : HRESULT SHCreateShellFolderViewEx
     548 * Purpose   :
     549 * Parameters:
     550 * Variables :
     551 * Result    :
     552 * Remark    : SHELL32.174
     553 * Status    : UNTESTED STUB
     554 *
     555 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     556 *****************************************************************************/
     557
     558
     559HRESULT WIN32API SHCreateShellFolderViewEx(LPSHELLVIEWDATA psvcbi,
     560                                           LPVOID* ppv)
     561{
     562  dprintf(("SHELL32: SHCreateShellFolderViewEx(%08xh,%08xh) not implemented.\n",
     563           psvcbi,
     564           ppv));
     565
     566  return 0;
     567}
     568
     569
     570/*****************************************************************************
     571 * Name      : HRESULT SHSetInstanceExplorer
     572 * Purpose   :
     573 * Parameters:
     574 * Variables :
     575 * Result    :
     576 * Remark    : SHELL32.176
     577 * Status    : UNTESTED STUB
     578 *
     579 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     580 *****************************************************************************/
     581
     582HRESULT WIN32API SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
     583{
     584  dprintf(("SHELL32: SHSetInstanceExplorer(%08xh)\n",
     585           lpUnknown));
     586
     587  SHELL32_IExplorerInterface = lpUnknown;
     588  return (HRESULT) lpUnknown;
     589}
     590
     591
     592/*****************************************************************************
     593 * Name      : DWORD WIN32API SHFree
     594 * Purpose   :
     595 * Parameters:
     596 * Variables :
     597 * Result    :
     598 * Remark    : SHELL32.195
     599 * Status    : UNTESTED STUB
     600 *
     601 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     602 *
     603 * NOTES
     604 *     free_ptr() - frees memory using IMalloc
     605 *     exported by ordinal
     606 */
     607
     608DWORD WIN32API SHFree(LPVOID x)
     609{
     610  dprintf(("SHELL32: SHFree(%08xh)\n",
     611           x));
     612
     613  if (!HIWORD(x))
     614  {
     615    *(LPDWORD)0xdeaf0000 = 0;
     616  }
     617
     618  return HeapFree(GetProcessHeap(),0,x);
     619}
     620
     621
     622/*****************************************************************************
     623 * Name      : LPVOID WIN32API SHAlloc
     624 * Purpose   :
     625 * Parameters:
     626 * Variables :
     627 * Result    :
     628 * Remark    : SHELL32.196
     629 * Status    : UNTESTED STUB
     630 *
     631 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     632 *
     633 * NOTES
     634 *     void *task_alloc(DWORD len), uses SHMalloc allocator
     635 *     exported by ordinal
     636 */
     637
     638LPVOID WIN32API SHAlloc(DWORD len)
     639{
     640  dprintf(("SHELL32: SHAlloc(%08xh)\n",
     641           len));
     642
     643  return (LPVOID)HeapAlloc(GetProcessHeap(),0,len);
     644}
     645
     646
     647/*****************************************************************************
     648 * Name      : HRESULT SHAbortInvokeCommand
     649 * Purpose   :
     650 * Parameters:
     651 * Variables :
     652 * Result    :
     653 * Remark    : SHELL32.198
     654 * Status    : UNTESTED STUB
     655 *
     656 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     657 *****************************************************************************/
     658
     659HRESULT WIN32API SHAbortInvokeCommand(void)
     660{
     661  dprintf(("SHELL32: SHAbortInvokeCommand() not implemented.\n"));
     662
     663  return 1;
     664}
     665
     666
     667/*****************************************************************************
     668 * Name      : VOID SHAddToRecentDocs
     669 * Purpose   :
     670 * Parameters: UINT    uFlags
     671 *             LPCVOID pv
     672 * Variables :
     673 * Result    :
     674 * Remark    : SHELL32.234
     675 * Status    : UNTESTED STUB
     676 *
     677 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     678 *****************************************************************************/
     679
     680VOID WIN32API SHAddToRecentDocs(UINT    uFlags,
     681                                LPCVOID pv)
     682{
     683  dprintf(("SHELL32: SHAddToRecentDocs(%08xh,%08xh) not implemented.\n",
     684           uFlags,
     685           pv));
     686}
     687
     688
     689/*****************************************************************************
     690 * Name      : LPITEMIDLIST SHBrowseForFolder
     691 * Purpose   :
     692 * Parameters: LPBROWSEINFOA lpbi
     693 * Variables :
     694 * Result    :
     695 * Remark    : SHELL32.236
     696 * Status    : UNTESTED STUB
     697 *
     698 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     699 *****************************************************************************/
     700
     701LPITEMIDLIST WIN32API SHBrowseForFolder(LPBROWSEINFOA lpbi)
     702{
     703  dprintf(("SHELL32: SHBrowseForFolder(%08xh) not implemented.\n",
     704           lpbi));
     705
     706  //@@@PH automatically decide between A and W
     707
     708  return(NULL);
     709}
     710
     711
     712/*****************************************************************************
     713 * Name      : LPITEMIDLIST SHBrowseForFolderA
     714 * Purpose   :
     715 * Parameters: LPBROWSEINFOA lpbi
     716 * Variables :
     717 * Result    :
     718 * Remark    : SHELL32.237
     719 * Status    : UNTESTED STUB
     720 *
     721 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     722 *****************************************************************************/
     723
     724LPITEMIDLIST WIN32API SHBrowseForFolderA(LPBROWSEINFOA lpbi)
     725{
     726  dprintf(("SHELL32: SHBrowseForFolderA(%08xh) not implemented.\n",
     727           lpbi));
     728
     729  return(NULL);
     730}
     731
     732
     733/*****************************************************************************
     734 * Name      : LPITEMIDLIST SHBrowseForFolderW
     735 * Purpose   :
     736 * Parameters: LPBROWSEINFOW lpbi
     737 * Variables :
     738 * Result    :
     739 * Remark    : SHELL32.238
     740 * Status    : UNTESTED STUB
     741 *
     742 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     743 *****************************************************************************/
     744
     745LPITEMIDLIST WIN32API SHBrowseForFolderW(LPBROWSEINFOA lpbi)
     746{
     747  dprintf(("SHELL32: SHBrowseForFolderW(%08xh) not implemented.\n",
     748           lpbi));
     749
     750  return(NULL);
     751}
     752
     753
     754/*****************************************************************************
     755 * Name      : VOID SHChangeNotify
     756 * Purpose   :
     757 * Parameters: LONG    wEventId
     758 *             UINT    uFlags
     759 *             LPCVOID dwItem1
     760 *             LPCVOID dwItem2
     761 * Variables :
     762 * Result    :
     763 * Remark    : SHELL32.239
     764 * Status    : UNTESTED STUB
     765 *
     766 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     767 *****************************************************************************/
     768
     769VOID WIN32API SHChangeNotify(LONG    wEventId,
     770                             UINT    uFlags,
     771                             LPCVOID dwItem1,
     772                             LPCVOID dwItem2)
     773{
     774  dprintf(("SHELL32: SHChangeNotify(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     775           wEventId,
     776           uFlags,
     777           dwItem1,
     778           dwItem2));
     779
     780}
     781
     782
     783/*****************************************************************************
     784 * Name      : HRESULT SHFileOperation
     785 * Purpose   :
     786 * Parameters:
     787 * Variables :
     788 * Result    :
     789 * Remark    : SHELL32.242
     790 * Status    : UNTESTED STUB
     791 *
     792 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     793 *****************************************************************************/
     794
     795DWORD WIN32API SHFileOperationAW(LPVOID lpFileOp)
     796{
     797  dprintf(("SHELL32: SHFileOperationAW(%08xh) not implemented.\n",
     798           lpFileOp));
     799
     800  // if OsIsUnicode()
     801  //   SHFileOperationA(lpFileOp);
     802  // else
     803  //   SHFileOperationW(lpFileOp);
     804
     805  return 0;
     806}
     807
     808
     809/*****************************************************************************
     810 * Name      : HRESULT SHFileOperationA
     811 * Purpose   :
     812 * Parameters:
     813 * Variables :
     814 * Result    :
     815 * Remark    : SHELL32.243
     816 * Status    : UNTESTED STUB
     817 *
     818 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     819 *****************************************************************************/
     820
     821DWORD WIN32API SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp)
     822{
     823  dprintf(("SHELL32: SHFileOperationA(%08xh) not implemented.\n",
     824           lpFileOp));
     825
     826  return 0;
     827}
     828
     829
     830/*****************************************************************************
     831 * Name      : HRESULT SHFileOperationW
     832 * Purpose   :
     833 * Parameters:
     834 * Variables :
     835 * Result    :
     836 * Remark    : SHELL32.244
     837 * Status    : UNTESTED STUB
     838 *
     839 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     840 *****************************************************************************/
     841
     842DWORD WIN32API SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp)
     843{
     844  dprintf(("SHELL32: SHFileOperationW(%08xh) not implemented.\n",
     845           lpFileOp));
     846
     847  return 0;
     848}
     849
     850
     851/*****************************************************************************
     852 * Name      : HRESULT SHGetDesktopFolder
     853 * Purpose   :
     854 * Parameters: LPSHELLFOLDER *ppshf
     855 * Variables :
     856 * Result    :
     857 * Remark    : SHELL32.252
     858 * Status    : UNTESTED STUB
     859 *
     860 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     861 *****************************************************************************/
     862
     863HRESULT WIN32API SHGetDesktopFolder(LPSHELLFOLDER *ppshf)
     864{
     865  dprintf(("SHELL32: SHGetDesktopFolder(%08xh) not implemented.\n",
     866           ppshf));
     867
     868  return(1);
     869}
     870
    54871
    55872
    … …  
    64881 * Variables :
    65882 * Result    :
    66  * Remark    :
     883 * Remark    : SHELL32.253 .254
    67884 * Status    : UNTESTED STUB
    68885 *
    … …  
    97914 * Variables :
    98915 * Result    :
    99  * Remark    :
     916 * Remark    : SHELL32.255
    100917 * Status    : UNTESTED STUB
    101918 *
    … …  
    124941
    125942/*****************************************************************************
    126  * Name      : HRESULT SHGetDesktopFolder
    127  * Purpose   :
    128  * Parameters: LPSHELLFOLDER *ppshf
    129  * Variables :
    130  * Result    :
    131  * Remark    :
    132  * Status    : UNTESTED STUB
    133  *
    134  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    135  *****************************************************************************/
    136 
    137 HRESULT WIN32API SHGetDesktopFolder(LPSHELLFOLDER *ppshf)
    138 {
    139   dprintf(("SHELL32: SHGetDesktopFolder(%08xh) not implemented.\n",
    140            ppshf));
    141 
    142   return(1);
    143 }
    144 
    145 
    146 /*****************************************************************************
    147  * Name      : VOID SHAddToRecentDocs
    148  * Purpose   :
    149  * Parameters: UINT    uFlags
    150  *             LPCVOID pv
    151  * Variables :
    152  * Result    :
    153  * Remark    :
    154  * Status    : UNTESTED STUB
    155  *
    156  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    157  *****************************************************************************/
    158 
    159 VOID WIN32API SHAddToRecentDocs(UINT    uFlags,
    160                                 LPCVOID pv)
    161 {
    162   dprintf(("SHELL32: SHAddToRecentDocs(%08xh,%08xh) not implemented.\n",
    163            uFlags,
    164            pv));
    165 }
    166 
    167 
    168 /*****************************************************************************
    169  * Name      : VOID SHChangeNotify
    170  * Purpose   :
    171  * Parameters: LONG    wEventId
    172  *             UINT    uFlags
    173  *             LPCVOID dwItem1
    174  *             LPCVOID dwItem2
    175  * Variables :
    176  * Result    :
    177  * Remark    :
    178  * Status    : UNTESTED STUB
    179  *
    180  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    181  *****************************************************************************/
    182 
    183 VOID WIN32API SHChangeNotify(LONG    wEventId,
    184                              UINT    uFlags,
    185                              LPCVOID dwItem1,
    186                              LPCVOID dwItem2)
    187 {
    188   dprintf(("SHELL32: SHChangeNotify(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    189            wEventId,
    190            uFlags,
    191            dwItem1,
    192            dwItem2));
    193 }
    194 
    195 
    196 /*****************************************************************************
    197  * Name      : DWORD SHFileOperationA
    198  * Purpose   :
    199  * Parameters: LPSHFILEOPSTRUCTA lpFileOp
    200  * Variables :
    201  * Result    :
    202  * Remark    :
    203  * Status    : UNTESTED STUB
    204  *
    205  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    206  *****************************************************************************/
    207 
    208 DWORD WIN32API SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp)
    209 {
    210   dprintf(("SHELL32: SHFileOperationA(%08xh) not implemented.\n",
    211            lpFileOp));
     943 * Name      : HRESULT SHGetInstanceExplorer
     944 * Purpose   :
     945 * Parameters:
     946 * Variables :
     947 * Result    :
     948 * Remark    : SHELL32.256
     949 * Status    : UNTESTED STUB
     950 *
     951 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     952 *****************************************************************************/
     953
     954HRESULT WIN32API SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
     955{
     956  dprintf(("SHELL32: SHGetInstanceExplorer(%08xh) not implemented.\n",
     957           lpUnknown));
     958
     959  *lpUnknown = SHELL32_IExplorerInterface;
     960
     961  if (!SHELL32_IExplorerInterface)
     962    return E_FAIL;
     963
     964  //@@@PH to do:
     965  //SHELL32_IExplorerInterface->lpvtbl->fnAddRef(SHELL32_IExplorerInterface);
     966  return NOERROR;
     967}
     968
     969
     970/*****************************************************************************
     971 * Name      : HRESULT SHGetMalloc
     972 * Purpose   :
     973 * Parameters: LPMALLOC *ppMalloc
     974 * Variables :
     975 * Result    :
     976 * Remark    : SHELL32.257
     977 * Status    : UNTESTED STUB
     978 *
     979 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     980 *****************************************************************************/
     981
     982HRESULT WIN32API SHGetMalloc(LPMALLOC *ppMalloc)
     983{
     984  dprintf(("SHELL32: SHGetMalloc(%08xh) not implemented.\n",
     985           ppMalloc));
    212986
    213987  return(0);
    214988}
    215989
    216 
    217 /*****************************************************************************
    218  * Name      : DWORD SHFileOperationW
    219  * Purpose   :
    220  * Parameters: LPSHFILEOPSTRUCTW lpFileOp
    221  * Variables :
    222  * Result    :
    223  * Remark    :
    224  * Status    : UNTESTED STUB
    225  *
    226  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    227  *****************************************************************************/
    228 
    229 DWORD WIN32API SHFileOperationW(LPSHFILEOPSTRUCTW lpFileOp)
    230 {
    231   dprintf(("SHELL32: SHFileOperationW(%08xh) not implemented.\n",
    232            lpFileOp));
    233 
    234   return(0);
    235 }
    236990
    237991
    … …  
    243997 * Variables :
    244998 * Result    :
    245  * Remark    :
     999 * Remark    : SHELL32.259 .260
    2461000 * Status    : UNTESTED STUB
    2471001 *
    … …  
    2611015
    2621016/*****************************************************************************
     1017 * Name      : BOOL SHGetPathFromIDListW
     1018 * Purpose   :
     1019 * Parameters: LPCITEMIDLIST pidl
     1020 *             LPSTR         pszPath
     1021 * Variables :
     1022 * Result    :
     1023 * Remark    : SHELL32.261
     1024 * Status    : UNTESTED STUB
     1025 *
     1026 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1027 *****************************************************************************/
     1028
     1029BOOL WIN32API SHGetPathFromIDListW(LPCITEMIDLIST pidl,
     1030                                   LPWSTR        pszPath)
     1031{
     1032  dprintf(("SHELL32: SHGetPathFromIDListW(%08xh,%08xh) not implemented.\n",
     1033           pidl,
     1034           pszPath));
     1035
     1036  return(FALSE);
     1037}
     1038
     1039
     1040/*****************************************************************************
    2631041 * Name      : HRESULT SHGetSpecialFolderLocation
    2641042 * Purpose   :
    … …  
    2681046 * Variables :
    2691047 * Result    :
    270  * Remark    :
     1048 * Remark    : SHELL32.262
    2711049 * Status    : UNTESTED STUB
    2721050 *
    … …  
    2881066
    2891067/*****************************************************************************
    290  * Name      : LPITEMIDLIST SHBrowseForFolder
    291  * Purpose   :
    292  * Parameters: LPBROWSEINFOA lpbi
    293  * Variables :
    294  * Result    :
    295  * Remark    :
    296  * Status    : UNTESTED STUB
    297  *
    298  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    299  *****************************************************************************/
    300 
    301 LPITEMIDLIST WIN32API SHBrowseForFolder(LPBROWSEINFOA lpbi)
    302 {
    303   dprintf(("SHELL32: SHBrowseForFolder(%08xh) not implemented.\n",
    304            lpbi));
    305 
    306   return(NULL);
    307 }
    308 
     1068 * Name      : HRESULT SHRegCloseKey
     1069 * Purpose   :
     1070 * Parameters:
     1071 * Variables :
     1072 * Result    :
     1073 * Remark    : SHELL32.505
     1074 * Status    : UNTESTED STUB
     1075 *
     1076 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1077 *****************************************************************************/
     1078
     1079HRESULT WIN32API SHRegCloseKey (HKEY hkey)
     1080{
     1081  dprintf(("SHELL32: SHRegCloseKey(%08xh)\n",
     1082           hkey));
     1083
     1084  return RegCloseKey( hkey );
     1085}
     1086
     1087/*****************************************************************************
     1088 * Name      : HRESULT SHRegOpenKeyA
     1089 * Purpose   :
     1090 * Parameters:
     1091 * Variables :
     1092 * Result    :
     1093 * Remark    : SHELL32.506
     1094 * Status    : UNTESTED STUB
     1095 *
     1096 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1097 *****************************************************************************/
     1098
     1099HRESULT WIN32API SHRegOpenKeyA(HKEY  hKey,
     1100                               LPSTR lpSubKey,
     1101                               LPHKEY phkResult)
     1102{
     1103  dprintf(("SHELL32: SHRegOpenKeyA(%08xh,%s,%08xh)\n",
     1104           hKey,
     1105           lpSubKey,
     1106           phkResult));
     1107
     1108 return RegOpenKeyA(hKey,
     1109                    lpSubKey,
     1110                    phkResult);
     1111}
     1112
     1113
     1114/*****************************************************************************
     1115 * Name      : HRESULT SHRegOpenKeyW
     1116 * Purpose   :
     1117 * Parameters:
     1118 * Variables :
     1119 * Result    :
     1120 * Remark    : SHELL32.507
     1121 * Status    : UNTESTED STUB
     1122 *
     1123 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1124 *****************************************************************************/
     1125
     1126HRESULT WIN32API SHRegOpenKeyW (HKEY    hKey,
     1127                                LPCWSTR lpszSubKey,
     1128                                LPHKEY  phkResult)
     1129{
     1130  dprintf(("SHELL32: SHRegOpenKeyW(%08xh,%08xh,%08xh)\n",
     1131           hKey,
     1132           lpszSubKey,
     1133           phkResult));
     1134
     1135 return RegOpenKeyW(hKey,
     1136                    lpszSubKey,
     1137                    phkResult);
     1138}
     1139
     1140
     1141/*****************************************************************************
     1142 * Name      : HRESULT SHRegQueryValueA
     1143 * Purpose   :
     1144 * Parameters:
     1145 * Variables :
     1146 * Result    :
     1147 * Remark    : SHELL32.508
     1148 * Status    : UNTESTED STUB
     1149 *
     1150 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1151 *****************************************************************************/
     1152
     1153HRESULT WIN32API SHRegQueryValueA(HKEY   hKey,
     1154                                  LPSTR  lpszSubKey,
     1155                                  LPSTR  lpszData,
     1156                                  LPLONG lpcbData)
     1157{
     1158  dprintf(("SHELL32: SHRegQueryValueW(%08xh,%s,%08xh,%08xh)\n",
     1159           hKey,
     1160           lpszSubKey,
     1161           lpszData,
     1162           lpcbData));
     1163
     1164  return (HRESULT)RegQueryValueA(hKey,
     1165                                 lpszSubKey,
     1166                                 lpszData,
     1167                                 lpcbData);
     1168}
     1169
     1170
     1171/*****************************************************************************
     1172 * Name      : HRESULT SHRegQueryValueExA
     1173 * Purpose   :
     1174 * Parameters:
     1175 * Variables :
     1176 * Result    :
     1177 * Remark    : SHELL32.509
     1178 * Status    : UNTESTED STUB
     1179 *
     1180 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1181 *****************************************************************************/
     1182
     1183HRESULT WIN32API SHRegQueryValueExA(DWORD   u,
     1184                                    LPSTR   v,
     1185                                    LPDWORD w,
     1186                                    LPDWORD x,
     1187                                    LPBYTE  y,
     1188                                    LPDWORD z)
     1189{
     1190  dprintf(("SHELL32: SHRegQueryValueExA(%08xh,%s,%08xh,%08xh,%08xh,%08xh)\n",
     1191           u,
     1192           v,
     1193           w,
     1194           x,
     1195           y,
     1196           z));
     1197
     1198  return (HRESULT)RegQueryValueExA(u,
     1199                                   v,
     1200                                   w,
     1201                                   x,
     1202                                   y,
     1203                                   z);
     1204}
     1205
     1206
     1207/*****************************************************************************
     1208 * Name      : HRESULT SHRegQueryValueExW
     1209 * Purpose   :
     1210 * Parameters:
     1211 * Variables :
     1212 * Result    :
     1213 * Remark    : SHELL32.510
     1214 * Status    : UNTESTED STUB
     1215 *
     1216 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1217 *****************************************************************************/
     1218
     1219HRESULT WIN32API SHRegQueryValueExW(DWORD    u,
     1220                                    LPWSTR   v,
     1221                                    LPDWORD  w,
     1222                                    LPDWORD  x,
     1223                                    LPBYTE   y,
     1224                                    LPDWORD  z)
     1225{
     1226  dprintf(("SHELL32: SHRegQueryValueExW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     1227           u,
     1228           v,
     1229           w,
     1230           x,
     1231           y,
     1232           z));
     1233
     1234  return (HRESULT)RegQueryValueExW(u,
     1235                                   v,
     1236                                   w,
     1237                                   x,
     1238                                   y,
     1239                                   z);
     1240}
     1241
     1242
     1243/*****************************************************************************
     1244 * Name      : HRESULT SHRegQueryValueW
     1245 * Purpose   :
     1246 * Parameters:
     1247 * Variables :
     1248 * Result    :
     1249 * Remark    : SHELL32.511
     1250 * Status    : UNTESTED STUB
     1251 *
     1252 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1253 *****************************************************************************/
     1254
     1255HRESULT WIN32API SHRegQueryValueW(HKEY   hKey,
     1256                                  LPWSTR lpszSubKey,
     1257                                  LPWSTR lpszData,
     1258                                  LPLONG lpcbData)
     1259{
     1260  dprintf(("SHELL32: SHRegQueryValueW(%08xh,%08xh,%08xh,%08xh)\n",
     1261           hKey,
     1262           lpszSubKey,
     1263           lpszData,
     1264           lpcbData));
     1265
     1266  return (HRESULT)RegQueryValueW(hKey,
     1267                                 lpszSubKey,
     1268                                 lpszData,
     1269                                 lpcbData);
     1270}
     1271
     1272
     1273/*****************************************************************************
     1274 * Name      : HGLOBAL SHAllocShared
     1275 * Purpose   : allocate shared memory ?
     1276 * Parameters:
     1277 * Variables :
     1278 * Result    :
     1279 * Remark    : SHELL32.520
     1280 * Status    : UNTESTED STUB
     1281 *
     1282 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1283 *
     1284 * NOTES
     1285 *  parameter1 is return value from HeapAlloc
     1286 *  parameter2 is equal to the size allocated with HeapAlloc
     1287 *  parameter3 is return value from GetCurrentProcessId
     1288 *
     1289 *  the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
     1290 *  WM_USER+2 could be the undocumented CWM_SETPATH
     1291 *  the allocated memory contains a pidl
     1292 */
     1293
     1294HGLOBAL WIN32API SHAllocShared(LPVOID psrc,
     1295                               DWORD  size,
     1296                               DWORD  procID)
     1297{
     1298  HGLOBAL hmem;
     1299  LPVOID pmem;
     1300
     1301  dprintf(("SHELL32: SHAllocShared(%08xh,%08xh,%08xh)\n",
     1302           psrc,
     1303           size,
     1304           procID));
     1305
     1306  hmem = GlobalAlloc(GMEM_FIXED,
     1307                     size);
     1308  if (!hmem)
     1309    return 0;
     1310
     1311  pmem = GlobalLock (hmem);
     1312  if (! pmem)
     1313    return 0;
     1314
     1315  memcpy (pmem, psrc, size);
     1316  GlobalUnlock(hmem);
     1317  return hmem;
     1318}
    3091319
    3101320
    … …  
    3761386 *  parameter2 is return value from GetCurrentProcessId
    3771387 */
     1388
    3781389HANDLE WIN32API SHFreeShared(HANDLE hmem,
    3791390                             DWORD  procID)
    … …  
    3861397}
    3871398
     1399
     1400/*****************************************************************************
     1401 * Name      : DWORD WIN32API NTSHChangeNotifyRegister
     1402 * Purpose   :
     1403 * Parameters:
     1404 * Variables :
     1405 * Result    :
     1406 * Remark    : SHELL32.640
     1407 * Status    : UNTESTED STUB
     1408 *
     1409 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1410 *
     1411 * NOTES
     1412 *   Idlist is an array of structures and Count specifies how many items in the array
     1413 *   (usually just one I think).
     1414 */
     1415
     1416DWORD WIN32API NTSHChangeNotifyRegister(HWND hwnd,
     1417                                        LONG events1,
     1418                                        LONG events2,
     1419                                        DWORD msg,
     1420                                        int count,
     1421                                        IDSTRUCT *idlist)
     1422{
     1423  dprintf(("SHELL32: NTSHChangeNotifyRegister(%08xh,  %08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     1424           hwnd,
     1425           events1,
     1426           events2,
     1427           msg,
     1428           count,
     1429           idlist));
     1430
     1431   return SHChangeNotifyRegister(hwnd,
     1432                                 events1,
     1433                                 events2,
     1434                                 msg,
     1435                                 count,
     1436                                 idlist);
     1437}
     1438
     1439
     1440/*****************************************************************************
     1441 * Name      : DWORD WIN32API NTSHChangeNotifyDeregister
     1442 * Purpose   :
     1443 * Parameters:
     1444 * Variables :
     1445 * Result    :
     1446 * Remark    : SHELL32.641
     1447 * Status    : UNTESTED STUB
     1448 *
     1449 * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
     1450 */
     1451DWORD WIN32API NTSHChangeNotifyDeregister(LONG x1)
     1452{
     1453  dprintf(("SHELL32: NTSHChangeNotifyDeregister(%08xh) not implemented.\n",
     1454           x1));
     1455
     1456  return SHChangeNotifyDeregister(x1);
     1457}
     1458

  • trunk/src/shell32/shell32.cpp

    r170 r183  
    1 /* $Id: shell32.cpp,v 1.7 1999-06-23 22:28:52 phaller Exp $ */
     1/* $Id: shell32.cpp,v 1.8 1999-06-24 19:27:49 phaller Exp $ */
    22
    33/*
    … …  
    2121 *****************************************************************************/
    2222
     23#include <odin.h>
    2324#include <os2win.h>
    2425#include <shellapi.h>
    … …  
    6566 * Variables :
    6667 * Result    :
    67  * Remark    :
     68 * Remark    : SHELL32.289
    6869 * Status    : UNTESTED
    6970 *
    … …  
    101102 * Variables :
    102103 * Result    :
    103  * Remark    :
     104 * Remark    : SHELL32.293
    104105 * Status    : UNTESTED
    105106 *
    … …  
    154155 * Variables :
    155156 * Result    :
    156  * Remark    :
     157 * Remark    : SHELL32.287
    157158 * Status    : UNTESTED
    158159 *
    … …  
    193194 * Variables :
    194195 * Result    :
    195  * Remark    :
     196 * Remark    : SHELL32.288
    196197 * Status    : UNTESTED
    197198 *
    … …  
    239240
    240241
    241 /*************************************************************************
    242  *              Shell_NotifyIcon    [SHELL32.240]
    243  *  FIXME
    244  *  This function is supposed to deal with the systray.
    245  *  Any ideas on how this is to be implimented?
    246  */
    247 BOOL WIN32API Shell_NotifyIconA(DWORD dwMessage,
    248                            PNOTIFYICONDATAA pnid )
     242/*****************************************************************************
     243 * Name      : BOOL Shell_NotifyIconA
     244 * Purpose   :
     245 * Parameters:
     246 * Variables :
     247 * Result    :
     248 * Remark    : SHELL32.296 .297
     249 * Status    : UNTESTED STUB
     250 *
     251 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     252 *****************************************************************************/
     253
     254BOOL WIN32API Shell_NotifyIconA(DWORD            dwMessage,
     255                                PNOTIFYICONDATAA pnid)
    249256{
    250257  dprintf(("SHELL32: Shell_NotifyIconA(%08xh,%08xh) not implemented.\n",
    … …  
    256263
    257264
    258 /*************************************************************************
    259  *              Shell_NotifyIcon    [SHELL32.240]
    260  *  FIXME
    261  *  This function is supposed to deal with the systray.
    262  *  Any ideas on how this is to be implimented?
    263  */
     265/*****************************************************************************
     266 * Name      : BOOL Shell_NotifyIconW
     267 * Purpose   :
     268 * Parameters:
     269 * Variables :
     270 * Result    :
     271 * Remark    : SHELL32.298
     272 * Status    : UNTESTED STUB
     273 *
     274 * Author    : Patrick Haller [Tue, 1998/06/15 03:00]
     275 *****************************************************************************/
     276
    264277BOOL WIN32API Shell_NotifyIconW(DWORD dwMessage,
    265278                                         PNOTIFYICONDATAW pnid )
    … …  
    301314 * Variables :
    302315 * Result    :
    303  * Remark    :
     316 * Remark    : SHELL32.290 .291
    304317 * Status    : UNTESTED STUB
    305318 *
    … …  
    322335 * Variables :
    323336 * Result    :
    324  * Remark    :
     337 * Remark    : SHELL32.292
    325338 * Status    : UNTESTED STUB
    326339 *
    … …  
    354367 *****************************************************************************/
    355368
    356 DWORD WIN32API ShellMessageBoxW(HMODULE hmod,
    357                                 HWND    hwnd,
    358                                 DWORD   idText,
    359                                 DWORD   idTitle,
    360                                 DWORD   uType,
    361                                 LPCVOID arglist)
     369DWORD CDECL ShellMessageBoxW(HMODULE hmod,
     370                                      HWND    hwnd,
     371                                      DWORD   idText,
     372                                      DWORD   idTitle,
     373                                      DWORD   uType,
     374                                      LPCVOID arglist)
    362375{
    363376  WCHAR   szText[100],
    364          szTitle[100],
    365          szTemp[256];
     377          szTitle[100],
     378          szTemp[256];
    366379  LPWSTR pszText = &szText[0],
    367380         pszTitle = &szTitle[0];
    … …  
    385398
    386399  if (! HIWORD (idText))
    387     LoadStringW(hmod,idText,pszText,100);
     400    LoadStringW(hmod,
     401                idText,
     402                pszText,
     403                100);
    388404  else
    389405    pszText = (LPWSTR)idText;
    … …  
    421437 *****************************************************************************/
    422438
    423 DWORD WIN32API ShellMessageBoxA(HMODULE hmod,
    424                                 HWND    hwnd,
    425                                 DWORD   idText,
    426                                 DWORD   idTitle,
    427                                 DWORD   uType,
    428                                 LPCVOID arglist)
     439DWORD CDECL ShellMessageBoxA(HMODULE hmod,
     440                                      HWND    hwnd,
     441                                      DWORD   idText,
     442                                      DWORD   idTitle,
     443                                      DWORD   uType,
     444                                      LPCVOID arglist)
    429445{
    430446  char   szText[100],
    … …  
    444460
    445461  if (!HIWORD (idTitle))
    446     LoadStringA(hmod,idTitle,pszTitle,100);
     462    LoadStringA(hmod,
     463                idTitle,
     464                pszTitle,
     465                100);
    447466  else
    448467    pszTitle = (LPSTR)idTitle;
    449468
    450469  if (! HIWORD (idText))
    451     LoadStringA(hmod,idText,pszText,100);
     470    LoadStringA(hmod,
     471                idText,
     472                pszText,
     473                100);
    452474  else
    453475    pszText = (LPSTR)idText;
    … …  
    466488                     uType);
    467489}
    468 
    469 

  • trunk/src/shell32/shell32.def

    r177 r183  
    1 ; $Id: shell32.def,v 1.8 1999-06-24 09:02:08 phaller Exp $
     1; $Id: shell32.def,v 1.9 1999-06-24 19:27:49 phaller Exp $
    22
    33;Created by BLAST for IBM's compiler
    4 ;based on Windows NT4, SP3
     4;based on Windows 95
    55LIBRARY SHELL32 INITINSTANCE
    66DATA MULTIPLE NONSHARED
    … …  
    88EXPORTS
    99
    10 ;   CheckEscapesA              = _CheckEscapesA@?                   @1
    11                                  _SHELL32_2@24                      @2
    12 ;   CheckEscapesW              = _CheckEscapesW@?                   @4
    13                                  _SHELL32_4@4                       @4
    14     CommandLineToArgvW         = _CommandLineToArgvW@8              @5
    15 ;   Control_FillCache_RunDLL   = _Control_FillCache_RunDLL@?        @6
    16 ;   Control_RunDLL             = _Control_RunDLL@?                  @10
    17 ;   DllGetClassObject          = _DllGetClassObject@?               @12
    18                                  _SHELL32_16@4                      @16
    19                                  _SHELL32_18@4                      @18
    20 ;   DoEnvironmentSubstA        = _DoEnvironmentSubstA@?             @20
    21                                  _SHELL32_25@8                      @25
    22                                  _SHELL32_29@4                      @29
    23                                  _SHELL32_30@8                      @30
    24                                  _SHELL32_31@4                      @31
    25                                  _SHELL32_32@4                      @32
    26                                  _SHELL32_33@4                      @33
    27                                  _SHELL32_34@4                      @34
    28                                  _SHELL32_35@4                      @35
    29 ;   DoEnvironmentSubstW        = _DoEnvironmentSubstW@?             @36
    30                                  _SHELL32_36@8                      @36
    31                                  _SHELL32_37@12                     @37
    32                                  _SHELL32_39@4                      @39
    33     DragAcceptFiles            = _DragAcceptFiles@8                 ; conflict! @39
    34     DragFinish                 = _DragFinish@4                      @40
    35     DragQueryFile              = _DragQueryFileA@16                 @42
    36                                  _SHELL32_43@4                      @43
    37                                  _SHELL32_45@4                      @45
    38     DragQueryFileA             = _DragQueryFileA@16                 @48
    39     DragQueryFileAorW          = _DragQueryFileAorW@16              ; conflict! @51
    40                                  _SHELL32_51@12                     @51
    41     DragQueryFileW             = _DragQueryFileW@16                 ; conflict! @52
    42                                  _SHELL32_52@4                      @52
    43                                  _SHELL32_55@4                      @55
    44                                  _SHELL32_56@4                      @56
    45                                  _SHELL32_58@16                     @58
    46                                  _SHELL32_59@0                      @59
    47                                  _SHELL32_62@16                     @62
    48                                  _SHELL32_63@28                     @63
    49                                  _SHELL32_68@12                     @68
    50                                  _SHELL32_71@8                      @71
    51                                  _SHELL32_72@12                     @72
    52     DragQueryPoint             = _DragQueryPoint@8                  @74
    53                                  _SHELL32_75@8                      @75
    54                                  _SHELL32_77@12                     @77
    55 ;   DuplicateIcon              = _DuplicateIcon@?                   @78
    56                                  _SHELL32_79@8                      @79
    57     ExtractAssociatedIconA     = _ExtractAssociatedIconA@12         @80
    58                                  _SHELL32_85@16                     @85
    59                                  _SHELL32_89@12                     @89
    60 ;   ExtractAssociatedIconExA   = _ExtractAssociatedIconExA@?        @99
    61    SetAppStartingCursor        = _SetAppStartingCursor@8            @99
    62                                  _SHELL32_100@4                     @100
    63                                  _SHELL32_102@20                    @102
    64                                  _SHELL32_119@4                     @119
    65 ;   ExtractAssociatedIconExW   = _ExtractAssociatedIconExW@?        @122
    66     ExtractAssociatedIconW     = _ExtractAssociatedIconW@12         @123
    67     ExtractIconA               = _ExtractIconA@12                   @131
    68     ExtractIconEx              = _ExtractIconExA@20                 @133
    69     ExtractIconExA             = _ExtractIconExA@20                 @136
    70     ExtractIconExW             = _ExtractIconExW@20                        ; NT4 doesn't use it!
    71                                  _SHELL32_145@8                     @145
    72 ;   ExtractIconResInfoA        = _ExtractIconResInfoA@?             @146
    73 ;   ExtractIconResInfoW        = _ExtractIconResInfoW@?             @148
    74                                  _SHELL32_152@4                     @152
    75                                  _SHELL32_155@4                     @155
    76                                  _SHELL32_158@12                    @158
    77                                  _SHELL32_162@4                     @162
    78                                  _SHELL32_165@8                     @165
    79                                  _SHELL32_175@16                    @175
    80     ExtractIconW               = _ExtractIconW@12                   @178
    81 ;   ExtractVersionResource16W  = _ExtractVersionResource16W@?       @180
    82                                  _SHELL32_181@8                     @181
    83     FindExecutableA            = _FindExecutableA@12                @184
    84     FindExecutableW            = _FindExecutableW@12                @185
    85 ;   FreeIconList               = _FreeIconList@?                    @186
    86 ;   InternalExtractIconListA   = _InternalExtractIconListA@?        @187
    87 ;   InternalExtractIconListW   = _InternalExtractIconListW@?        @188
    88 ;   OpenAs_RunDLL              = _OpenAs_RunDLL@?                   @189
    89 ;   PrintersGetCommand_RunDLL  = _PrintersGetCommand_RunDLL@?       @190
    90     RealShellExecuteA          = _RealShellExecuteA@24              @191
    91     RealShellExecuteExA        = _RealShellExecuteExA@4             @192
    92                                  _SHELL32_195@4                     @195
    93                                  _SHELL32_196@4                     @196
    94     RealShellExecuteExW        = _RealShellExecuteExW@4             @201
    95     RealShellExecuteW          = _RealShellExecuteW@24              @202
    96 ;   RegenerateUserEnvironment  = _RegenerateUserEnvironment@?       @203
    97     SHAddToRecentDocs          = _SHAddToRecentDocs@8               @204
    98 ;   SHAppBarMessage            = _SHAppBarMessage@?                 @205
    99     SHBrowseForFolder          = _SHBrowseForFolder@4               @206
    100     SHBrowseForFolderA         = _SHBrowseForFolder@4               @207
    101     SHChangeNotify             = _SHChangeNotify@16                 @208
    102     SHFileOperation            = _SHFileOperationA@4                @209
    103     SHFileOperationA           = _SHFileOperationA@4                @210
    104     SHFileOperationW           = _SHFileOperationW@4                       ; NT4 doesn't use it!
    105 ;   SHFormatDrive              = _SHFormatDrive@?                   @211
    106 ;   SHFreeNameMappings         = _SHFreeNameMappings@?              @212
    107 ;   SHGetDataFromIDListA       = _SHGetDataFromIDListA@?            @213
    108     SHGetDesktopFolder         = _SHGetDesktopFolder@4              @214
    109     SHGetFileInfo              = _SHGetFileInfoA@20                 @215
    110     SHGetFileInfoA             = _SHGetFileInfoA@20                 @216
    111     SHGetFileInfoW             = _SHGetFileInfoW@20                        ; NT4 doesn't use it!
    112 ;   SHGetInstanceExplorer      = _SHGetInstanceExplorer@?           @217
    113     SHGetMalloc                = _SHGetMalloc@4                     @218
    114     SHGetPathFromIDList        = _SHGetPathFromIDListA@8            @219
    115     SHGetPathFromIDListA       = _SHGetPathFromIDListA@8            @220
    116     SHGetSpecialFolderLocation = _SHGetSpecialFolderLocation@12     @221
    117 ;   SHHelpShortcuts_RunDLL     = _SHHelpShortcuts_RunDLL@?          @222
    118 ;   SHLoadInProc               = _SHLoadInProc@?                    @223
    119 ;   SheChangeDirA              = _SheChangeDirA@?                   @224
    120 ;   SheChangeDirExA            = _SheChangeDirExA@?                 @225
    121 ;   SheChangeDirExW            = _SheChangeDirExW@?                 @226
    122 ;   SheChangeDirW              = _SheChangeDirW@?                   @227
    123 ;   SheConvertPathW            = _SheConvertPathW@?                 @228
    124 ;   SheFullPathA               = _SheFullPathA@?                    @229
    125 ;   SheFullPathW               = _SheFullPathW@?                    @230
    126 ;   SheSetCurDrive             = _SheSetCurDrive@4                  @231
    127 ;   SheGetDirA                 = _SheGetDirA@?                      @232
    128 ;   SheGetDirExW               = _SheGetDirExW@?                    @233
    129 ;   SheGetDirW                 = _SheGetDirW@?                      @234
    130 ;   SheGetPathOffsetW          = _SheGetPathOffsetW@?               @235
    131 ;   SheRemoveQuotesA           = _SheRemoveQuotesA@?                @236
    132 ;   SheRemoveQuotesW           = _SheRemoveQuotesW@?                @237
    133 ;   SheSetCurDrive             = _SheSetCurDrive@?                  @238
    134 ;   SheShortenPathA            = _SheShortenPathA@?                 @239
    135 ;   SheShortenPathW            = _SheShortenPathW@?                 @240
    136     ShellAboutA                = _ShellAboutA@16                    @241
    137     ShellAboutW                = _ShellAboutW@16                    @242
    138     ShellExecuteA              = _ShellExecuteA@24                  @243
    139     ShellExecuteEx             = _ShellExecuteExA@4                 @244
    140     ShellExecuteExA            = _ShellExecuteExA@4                 @245
    141     ShellExecuteExW            = _ShellExecuteExW@4                        ; NT4 doesn't use it!
    142     ShellExecuteW              = _ShellExecuteW@24                  @246
    143     ShellExecute               = _ShellExecuteA@24                         ; NT4 doesn't use it!
    144     Shell_NotifyIcon           = _Shell_NotifyIconA@8               @247
    145     Shell_NotifyIconA          = _Shell_NotifyIconA@8               @248
    146     Shell_NotifyIconW          = _Shell_NotifyIconW@8                      ; NT4 doesn't use it!
    147 ;   Shl1632_ThunkData32        = _Shl1632_ThunkData32@?             @249
    148 ;   Shl3216_ThunkData32        = _Shl3216_ThunkData32@?             @250
    149 
    150     SHLockShared               = _SHLockShared@8                    @521
    151     SHUnlockShared             = _SHUnlockShared@4                  @522
    152     SHFreeShared               = _SHFreeShared@8                    @523
    153 
    154 
    155     ShellMessageBoxW         = _ShellMessageBoxW@24       @182
    156     ShellMessageBoxA         = _ShellMessageBoxA@24       @183
    157 
     10    SHChangeNotifyRegister            = _SHChangeNotifyRegister@24            @2
     11;   CheckEscapesA                     = _CheckEscapesA@8                      @3
     12    SHChangeNotifyDeregister          = _SHChangeNotifyDeregister@4           @4
     13;   SHChangeNotifyUpdateEntryList     = _SHChangeNotifyUpdateEntryList@16     @5
     14;   CheckEscapesW                     = _CheckEscapesW@8                      @6
     15    CommandLineToArgvW                = _CommandLineToArgvW@8                 @7
     16    Control_FillCache_RunDLL          = _Control_FillCache_RunDLL@16          @8
     17;   PifMgr_OpenProperties             = _PifMgr_OpenProperties@16             @9
     18;   PifMgr_GetProperties              = _PifMgr_GetProperties@20              @10
     19;   PifMgr_SetProperties              = _PifMgr_SetProperties@20              @11
     20;   Control_FillCache_RunDLLA         = _Control_FillCache_RunDLLA@16         @12
     21;   PifMgr_CloseProperties            = _PifMgr_CloseProperties@8             @13
     22;   Control_FillCache_RunDLLW         = _Control_FillCache_RunDLLW@16         @14
     23;   ILGetDisplayName                  = _ILGetDisplayName@8                   @15
     24    ILFindLastID                      = _ILFindLastID@4                       @16
     25;   ILRemoveLastID                    = _ILRemoveLastID@4                     @17
     26    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
     33    ILCombine                         = _ILCombine@8                          @25
     34;   ILLoadFromStream                  = _ILLoadFromStream@8                   @26
     35;   ILSaveToStream                    = _ILSaveToStream@8                     @27
     36;   SHILCreateFromPath                = _SHILCreateFromPath@12                @28
     37    PathIsRoot                        = _PathIsRootAW@4                       @29
     38    PathBuildRoot                     = _PathBuildRootAW@8                    @30
     39    PathFindExtension                 = _PathFindExtensionAW@4                @31
     40    PathAddBackslash                  = _PathAddBackslashAW@4                 @32
     41    PathRemoveBlanks                  = _PathRemoveBlanksAW@4                 @33
     42    PathFindFilename                  = _PathFindFilenameAW@4                 @34
     43    PathRemoveFileSpec                = _PathRemoveFileSpecA@4                @35
     44    PathAppend                        = _PathAppendA@8                        @36
     45    PathCombine                       = _PathCombineAW@12                     @37
     46;   PathStripPath                     = _PathStripPathAW@?                    @38
     47    PathIsUNC                         = _PathIsUNCAW@4                        @39
     48    PathIsRelative                    = _PathIsRelativeAW@4                   @40
     49;   Control_RunDLLA                   = _Control_RunDLLA@16                   @41
     50;   Control_RunDLLW                   = _Control_RunDLLW@16                   @42
     51    PathIsExe                         = _PathIsExeAW@4                        @43
     52;   DoEnvironmentSubstA               = _DoEnvironmentSubstA@8                @44
     53    PathFileExists                    = _PathFileExistsAW@4                   @45
     54    PathMatchSpec                     = _PathMatchSpecAW@8                    @46
     55;   PathMakeUniqueName                = _PathMakeUniqueNameAW@20              @47
     56    PathSetDlgItemPath                = _PathSetDlgItemPathAW@12              @48
     57    PathQualify                       = _PathQualifyAW@4                      @49
     58;   PathStripToRoot                   = _PathStripToRootAW@4                  @50
     59    PathResolve                       = _PathResolve@12                       @51
     60    PathGetArgs                       = _PathGetArgsAW@4                      @52
     61;   DoEnvironmentSubstW               = _DoEnvironmentSubstW@?                @53
     62    DragAcceptFiles                   = _DragAcceptFiles@8                    @54
     63    PathQuoteSpaces                   = _PathQuoteSpacesAW@4                  @55
     64    PathUnquoteSpaces                 = _PathUnquoteSpacesAW@4                @56
     65    PathGetDriveNumber                = _PathGetDriveNumber@4                 @57
     66    ParseField                        = _ParseFieldA@16                       @58
     67;   RestartDialog                     = _RestartDialog@12                     @59
     68    ExitWindowsDialog                 = _ExitWindowsDialog@4                  @60
     69    RunFileDlg                        = _RunFileDlg@24                        @61
     70    PickIconDlg                       = _PickIconDlg@16                       @62
     71    GetFileNameFromBrowse             = _GetFileNameFromBrowse@28             @63
     72    DriveType                         = _DriveType@4                          @64
     73;   InvalidateDriveType               = _InvalidateDriveType@?                @65
     74;   IsNetDrive                        = _IsNetDrive@?                         @66
     75;   Shell_MergeMenus                  = _Shell_MergeMenus@24                  @67
     76    SHGetSettings                     = _SHGetSettings@12                     @68
     77;   SHGetNetResource                  = _SHGetNetResource@?                   @69
     78;   SHCreateDefClassObject            = _SHCreateDefClassObject@?             @70
     79    Shell_GetImageList                = _Shell_GetImageList@8                 @71
     80    Shell_GetCachedImageIndex         = _Shell_GetCachedImageIndex@12         @72
     81    SHShellFolderView_Message         = _SHShellFolderView_Message@12         @73
     82;   SHCreateStdEnumFmtEtc             = _SHCreateStdEnumFmtEtc@?              @74
     83    PathYetAnotherMakeUniqueName      = _PathYetAnotherMakeUniqueNameA@8      @75
     84;   DragQueryInfo                     = _DragQueryInfo@?                      @76
     85    SHMapPIDLToSystemImageListIndex   = _SHMapPIDLToSystemImageListIndex@12   @77
     86    OleStrToStrN                      = _OleStrToStrN@16                      @78
     87    StrToOleStrN                      = _StrToOleStrN@16                      @79
     88    DragFinish                        = _DragFinish@4                         @80
     89    DragQueryFile                     = _DragQueryFileA@16                    @81
     90    DragQueryFileA                    = _DragQueryFileA@16                    @82
     91;   CIDLData_CreateFromIDArray        = _CIDLData_CreateFromIDArray@?         @83
     92;   SHIsBadInterfacePtr               = _SHIsBadInterfacePtr@?                @84
     93    OpenRegStream                     = _OpenRegStream@16                     @85
     94    SHRegisterDragDrop                = _SHRegisterDragDrop@8                 @86
     95    SHRevokeDragDrop                  = _SHRevokeDragDrop@4                   @87
     96;   SHDoDragDrop                      = _SHDoDragDrop@?                       @88
     97    SHCloneSpecialIDList              = _SHCloneSpecialIDList@12              @89
     98;   SHFindFiles                       = _SHFindFiles@?                        @90
     99;   SHFindComputer                    = _SHFindComputer@?                     @91
     100;   PathGetShortPath                  = _PathGetShortPathAW@?                 @92
     101;   Win32CreateDirectory              = _Win32CreateDirectory@?               @93
     102;   Win32RemoveDirectory              = _Win32RemoveDirectory@?               @94
     103;   SHLogILFromFSIL                   = _SHLogILFromFSIL@4                    @95
     104    StrRetToStrN                      = _StrRetToStrN@16                      @96
     105    SHWaitForFileToOpen               = _SHWaitForFileToOpen@12               @97
     106;   SHGetRealIDL                      = _SHGetRealIDL@12                      @98
     107    SetAppStartingCursor              = _SetAppStartingCursor@8               @99
     108    SHRestricted                      = _SHRestricted@4                       @100
     109    DragQueryFileAorW                 = _DragQueryFileAorW@16                 @101
     110    SHCoCreateInstance                = _SHCoCreateInstance@20                @102
     111    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
     129    SHFlushClipboard                  = _SHFlushClipboard@0                   @121
     130    RunDLL_CallEntry16                = _RunDLL_CallEntry16@20                @122
     131    SHFreeUnusedLibraries             = _SHFreeUnusedLibraries@0              @123
     132;   FileMenu_AppendFilesForPidl       = _FileMenu_AppendFilesForPidl@12       @124
     133;   FileMenu_AddFilesForPidl          = _FileMenu_AddFilesForPidl@28          @125
     134    SHOutOfMemoryMessageBox           = _SHOutOfMemoryMessageBox@12           @126
     135    SHWinHelp                         = _SHWinHelp@16                         @127
     136;   DllGetClassObject                 = _DllGetClassObject@?                  @128
     137;   DAD_AutoScroll                    = _DAD_AutoScroll@?                     @129
     138;   DAD_DragEnter                     = _DAD_DragEnter@?                      @130
     139;   DAD_DragEnterEx                   = _DAD_DragEnterEx@?                    @131
     140;   DAD_DragLeave                     = _DAD_DragLeave@?                      @132
     141    DragQueryFileW                    = _DragQueryFileW@16                    @133
     142;   DAD_DragMove                      = _DAD_DragMove@?                       @134
     143    DragQueryPoint                    = _DragQueryPoint@8                     @135
     144;   DAD_SetDragImage                  = _DAD_SetDragImage@?                   @136
     145    DAD_ShowDragImage                 = _DAD_ShowDragImage@4                  @137
     146;   DuplicateIcon                     = _DuplicateIcon@?                      @138
     147;   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
     153    PathFindOnPath                    = _PathFindOnPathAW@8                   @145
     154    RLBuildListOfPaths                = _RLBuildListOfPaths@0                 @146
     155;   SHCLSIDFromString                 = _SHCLSIDFromString@8                  @147
     156    ExtractAssociatedIconA            = _ExtractAssociatedIconA@12            @148
     157;   SHFind_InitMenuPopup              = _SHFind_InitMenuPopup@16              @149
     158;   ExtractAssociatedIconExA          = _ExtractAssociatedIconExA@?           @150
     159    SHLoadOLE                         = _SHLoadOLE@4                          @151
     160    ILGetSize                         = _ILGetSize@4                          @152
     161;   ILGetNext                         = _ILGetNext@4                          @153
     162;   ILAppend                          = _ILAppend@12                          @154
     163    ILFree                            = _ILFree@4                             @155
     164;   ILGlobalGree                      = _ILGlobalFree@4                       @156
     165;   ILCreateFromPath                  = _ILCreateFromPath@4                   @157
     166    PathGetExtension                  = _PathGetExtensionAW@12                @158
     167;   PathIsDirectory                   = _PathIsDirectoryAW@?                  @159
     168;   SHNetConnectionDialog             = _SHNetConnectionDialog@?              @160
     169    SHRunControlPanel                 = _SHRunControlPanel@8                  @161
     170    SHSimpleIDListFromPath            = _SHSimpleIDListFromPathAW@4           @162
     171    StrToOleStr                       = _StrToOleStr@8                        @163
     172;   Win32DeleteFile                   = _Win32DeleteFile@?                    @164
     173    SHCreateDirectory                 = _SHCreateDirectory@8                  @165
     174;   CallCPLEntry16                    = _CallCPLEntry16@?                     @166
     175;   SHAddFromPropSheetExtArray        = _SHAddFromPropSheetExtArray@?         @167
     176;   SHCreatePropSheetExtArray         = _SHCreatePropSheetExtArray@?          @168
     177;   SHDestroyPropSheetExtArray        = _SHDestroyPropSheetExtArray@?         @169
     178;   SHReplaceFromPropSheetExtArray    = _SHReplaceFromPropSheetExtArray@?     @170
     179;   PathCleanupSpec                   = _PathCleanupSpecAW@?                  @171
     180;   SHCreateLinks                     = _SHCreateLinks@?                      @172
     181    SHValidateUNC                     = _SHValidateUNC@12                     @173
     182    SHCreateShellFolderViewEx         = _SHCreateShellFolderViewEx@8          @174
     183    SHGetSpecialFolderPath            = _SHGetSpecialFolderPath@16            @175
     184    SHSetInstanceExplorer             = _SHSetInstanceExplorer@4              @176
     185;   DAD_SetDragImageFromListView      = _DAD_SetDragImageFromListView@?       @177
     186;   SHObjectProperties                = _SHObjectProperties@?                 @178
     187;   SHGetNewLinkInfoA                 = _SHGetNewLinkInfoA@?                  @179
     188;   SHGetNewLinkInfoW                 = _SHGetNewLinkInfoW@?                  @180
     189    RegisterShellHook                 = _RegisterShellHook@8                  @181
     190    ShellMessageBoxW                  = _ShellMessageBoxW                     @182 ;cdecl
     191    ShellMessageBoxA                  = _ShellMessageBoxA                     @183 ;cdecl
     192    ArrangeWindows                    = _ArrangeWindows@20                    @184
     193;   SHHandleDiskFull                  = _SHHandleDiskFull@?                   @185
     194;   ExtractAssociatedIconExW          = _ExtractAssociatedIconExW@?           @186
     195    ExtractAssociatedIconW            = _ExtractAssociatedIconW@12            @187
     196    ExtractIconA                      = _ExtractIconA@12                      @188
     197    ExtractIconEx                     = _ExtractIconExA@20                    @189
     198    ExtractIconExA                    = _ExtractIconExA@20                    @190
     199    ExtractIconExW                    = _ExtractIconExW@20                    @191
     200;   ExtractIconResInfoA               = _ExtractIconResInfoA@?                @192
     201;   ExtractIconResInfoW               = _ExtractIconResInfoW@?                @193
     202    ExtractIconW                      = _ExtractIconW@12                      @194
     203    SHFree                            = _SHFree@4                             @195
     204    SHAlloc                           = _SHAlloc@4                            @196
     205;   SHGlobalDefect                    = _SHGlobalDefect@?                     @197
     206    SHAbortInvokeCommand              = _SHAbortInvokeCommand@0               @198
     207;   SHGetFileIcon                     = _SHGetFileIcon@?                      @199
     208;   SHLocalAlloc                      = _SHLocalAlloc@?                       @200
     209;   SHLocalFree                       = _SHLocalFree@?                        @201
     210;   SHLocalReAlloc                    = _SHLocalReAlloc@?                     @202
     211;   AddCommasW                        = _AddCommasW@?                         @203
     212;   ShortSizeFormatW                  = _ShortSizeFormatW@?                   @204
     213;   Printer_LoadIconsW                = _Printer_LoadIconsW@?                 @205
     214;   Link_AddExtraDataSection          = _Link_AddExtraDataSection@?           @206
     215;   Link_ReadExtraDataSection         = _Link_ReadExtraDataSection@?          @207
     216;   Link_RemoveExtraDataSection       = _Link_RemoveExtraDataSection@?        @208
     217;   Int64ToString                     = _Int64ToString@?                      @209
     218;   LargeIntegerToString              = _LargeIntegerToString@?               @210
     219;   Printers_GetPidl                  = _Printers_GetPidl@?                   @211
     220;   Printer_AddPrinterPropPages       = _Printer_AddPrinterPropPages@?        @212
     221;   Printers_RegisterWindowW          = _Printers_RegisterWindowW@?           @213
     222;   Printers_UnregisterWindow         = _Printers_UnregisterWindow@?          @214
     223;   SHStartNetConnectionDialog        = _SHStartNetConnectionDialog@12        @215
     224;   ExtractVersionResource16W         = _ExtractVersionResource16W@?          @216
     225;   FindExeDlgProc                    = _FindExeDlgProc@?                     @217
     226    FindExecutableA                   = _FindExecutableA@12                   @218
     227    FindExecutableW                   = _FindExecutableW@12                   @219
     228;   FreeIconList                      = _FreeIconList@4                       @220
     229;   InternalExtractIconListA          = _InternalExtractIconListA@?           @221
     230;   InternalExtractIconListW          = _InternalExtractIconListW@?           @222
     231;   OpenAs_RunDLL                     = _OpenAs_RunDLL@?                      @223
     232;   OpenAs_RunDLLA                    = _OpenAs_RunDLLA@?                     @224
     233;   OpenAs_RunDLLW                    = _OpenAs_RunDLLW@?                     @225
     234;   PrintersGetCommand_RunDLL         = _PrintersGetCommand_RunDLL@?          @226
     235;   PrintersGetCommand_RunDLLA        = _PrintersGetCommand_RunDLLA@?         @227
     236;   PrintersGetCommand_RunDLLW        = _PrintersGetCommand_RunDLLW@?         @228
     237    RealShellExecuteA                 = _RealShellExecuteA@24                 @229
     238    RealShellExecuteExA               = _RealShellExecuteExA@4                @230
     239    RealShellExecuteExW               = _RealShellExecuteExW@4                @231
     240    RealShellExecuteW                 = _RealShellExecuteW@24                 @232
     241;   RegenerateUserEnvironment         = _RegenerateUserEnvironment@?          @233
     242    SHAddToRecentDocs                 = _SHAddToRecentDocs@8                  @234
     243;   SHAppBarMessage                   = _SHAppBarMessage@?                    @235
     244    SHBrowseForFolder                 = _SHBrowseForFolder@4                  @236
     245    SHBrowseForFolderA                = _SHBrowseForFolderA@4                 @237
     246    SHBrowseForFolderW                = _SHBrowseForFolderW@4                 @238
     247    SHChangeNotify                    = _SHChangeNotify@16                    @239
     248;   SHEmptyRecycleBinA                = _SHEmptyRecycleBinA@12                @240
     249;   SHEmptyRecycleBinW                = _SHEmptyRecycleBinW@12                @241
     250    SHFileOperation                   = _SHFileOperationAW@4                  @242
     251    SHFileOperationA                  = _SHFileOperationA@4                   @243
     252    SHFileOperationW                  = _SHFileOperationW@4                   @244
     253;   SHFormatDrive                     = _SHFormatDrive@?                      @245
     254;   SHFreeNameMappings                = _SHFreeNameMappings@?                 @246
     255;   SHGetDataFromIDListA              = _SHGetDataFromIDListA@?               @247
     256;   SHGetDataFromIDListW              = _SHGetDataFromIDListW@?               @248
     257;   PathParseIconLocation             = _PathParseIconLocationAW@4            @249
     258;   PathRemoveExtension               = _PathRemoveExtensionAW@4              @250
     259;   PathRemoveArgs                    = _PathRemoveArgsAW@4                   @251
     260    SHGetDesktopFolder                = _SHGetDesktopFolder@4                 @252
     261    SHGetFileInfo                     = _SHGetFileInfoA@20                    @253
     262    SHGetFileInfoA                    = _SHGetFileInfoA@20                    @254
     263    SHGetFileInfoW                    = _SHGetFileInfoW@20                    @255
     264    SHGetInstanceExplorer             = _SHGetInstanceExplorer@4              @256
     265    SHGetMalloc                       = _SHGetMalloc@4                        @257
     266;   SHGetNewLinkInfo                  = _SHGetNewLinkInfo@20                  @258
     267    SHGetPathFromIDList               = _SHGetPathFromIDListA@8               @259
     268    SHGetPathFromIDListA              = _SHGetPathFromIDListA@8               @260
     269    SHGetPathFromIDListW              = _SHGetPathFromIDListW@8               @261
     270    SHGetSpecialFolderLocation        = _SHGetSpecialFolderLocation@12        @262
     271;   SHHelpShortcuts_RunDLL            = _SHHelpShortcuts_RunDLL@16            @263
     272;   SHHelpShortcuts_RunDLLA           = _SHHelpShortcuts_RunDLLA@16           @264
     273;   SHHelpShortcuts_RunDLLW           = _SHHelpShortcuts_RunDLLW@16           @265
     274;   SHLoadInProc                      = _SHLoadInProc@4                       @266
     275;   SHQueryRecycleBinA                = _SHQueryRecycleBinA@8                 @267
     276;   SHQueryRecycleBinW                = _SHQueryRecycleBinW@8                 @268
     277;   SHUpdateRecycleBinIcon            = _SHUpdateRecycleBinIcon@0             @269
     278;   SheChangeDirA                     = _SheChangeDirA@4                      @270
     279;   SheChangeDirExA                   = _SheChangeDirExA@?                    @271
     280;   SheChangeDirExW                   = _SheChangeDirExW@?                    @272
     281    SheChangeDirW                     = _SheChangeDirW@4                      @273
     282;   SheConvertPathW                   = _SheConvertPathW@?                    @274
     283;   SheFullPathA                      = _SheFullPathA@?                       @275
     284;   SheFullPathW                      = _SheFullPathW@?                       @276
     285;   SheSetCurDrive                    = _SheSetCurDrive@4                     @277
     286;   SheGetDirA                        = _SheGetDirA@?                         @278
     287;   SheGetDirExW                      = _SheGetDirExW@?                       @279
     288    SheGetDirW                        = _SheGetDirW@8                         @280
     289;   SheGetPathOffsetW                 = _SheGetPathOffsetW@?                  @281
     290;   SheRemoveQuotesA                  = _SheRemoveQuotesA@?                   @282
     291;   SheRemoveQuotesW                  = _SheRemoveQuotesW@?                   @283
     292;   SheSetCurDrive                    = _SheSetCurDrive@?                     @284
     293;   SheShortenPathA                   = _SheShortenPathA@?                    @285
     294;   SheShortenPathW                   = _SheShortenPathW@?                    @286
     295    ShellAboutA                       = _ShellAboutA@16                       @287
     296    ShellAboutW                       = _ShellAboutW@16                       @288
     297    ShellExecuteA                     = _ShellExecuteA@24                     @289
     298    ShellExecuteEx                    = _ShellExecuteExA@4                    @290
     299    ShellExecuteExA                   = _ShellExecuteExA@4                    @291
     300    ShellExecuteExW                   = _ShellExecuteExW@4                    @292
     301    ShellExecuteW                     = _ShellExecuteW@24                     @293
     302    ShellExecute                      = _ShellExecuteA@24                     @294
     303;   ShellHookProc                     = _ShellHookProc@?                      @295
     304    Shell_NotifyIcon                  = _Shell_NotifyIconA@8                  @296
     305    Shell_NotifyIconA                 = _Shell_NotifyIconA@8                  @297
     306    Shell_NotifyIconW                 = _Shell_NotifyIconW@8                  @298
     307;   Shl1632_ThunkData32               = _Shl1632_ThunkData32@?                @299
     308;   Shl3216_ThunkData32               = _Shl3216_ThunkData32@?                @300
     309;   StrChrA                           = _StrChrA@?                            @301
     310;   StrChrIA                          = _StrChrIA@?                           @302
     311;   StrChrIW                          = _StrChrIW@?                           @303
     312    StrChrW                           = _StrChrW@8                            @304
     313;   StrCmpNA                          = _StrCmpNA@?                           @305
     314;   StrCmpNIA                         = _StrCmpNIA@?                          @306
     315    StrCmpNIW                         = _StrCmpNIW@12                         @307
     316;   StrCmpNW                          = _StrCmpNW@?                           @308
     317;   StrCpyNA                          = _StrCpyNA@?                           @309
     318;   StrCpyNW                          = _StrCpyNW@?                           @310
     319;   StrNCmpA                          = _StrNCmpA@?                           @311
     320;   StrNCmpIA                         = _StrNCmpIA@?                          @312
     321;   StrNCmpIW                         = _StrNCmpIW@?                          @313
     322;   StrNCmpW                          = _StrNCmpW@?                           @314
     323;   StrCpyA                           = _StrCpyA@?                            @315
     324;   StrCpyW                           = _StrCpyW@?                            @316
     325;   StrRChrA                          = _StrRChrA@?                           @317
     326;   StrRChrIA                         = _StrRChrIA@?                          @318
     327;   StrRChrIW                         = _StrRChrIW@?                          @319
     328;   StrRChrW                          = _StrRChrW@?                           @320
     329;   StrRStrA                          = _StrRStrA@?                           @321
     330;   StrRStrIA                         = _StrRStrIA@?                          @322
     331;   StrRStrIW                         = _StrRStrIW@?                          @323
     332;   StrRStrW                          = _StrRStrW@?                           @324
     333;   StrStrA                           = _StrStrA@?                            @325
     334;   StrStrIA                          = _StrStrIA@?                           @326
     335;   StrStrIW                          = _StrStrIW@?                           @327
     336;   StrStrW                           = _StrStrW@?                            @328
     337;   WOWShellExecute                   = _WOWShellExecute@?                    @329
     338    SHRegCloseKey                     = _SHRegCloseKey@4                      @505
     339    SHRegOpenKeyA                     = _SHRegOpenKeyA@12                     @506
     340    SHRegOpenKeyW                     = _SHRegOpenKeyW@12                     @507
     341    SHRegQueryValueA                  = _SHRegQueryValueA@16                  @508
     342    SHRegQueryValueExA                = _SHRegQueryValueExA@24                @509
     343    SHRegQueryValueExW                = _SHRegQueryValueExW@24                @510
     344    SHRegQueryValueW                  = _SHRegQueryValueW@16                  @511
     345;   SHRegDeleteKeyW                   = _SHRegDeleteKeyW@8                    @512
     346    SHAllocShared                     = _SHAllocShared@12                     @520
     347    SHLockShared                      = _SHLockShared@8                       @521
     348    SHUnlockShared                    = _SHUnlockShared@4                     @522
     349    SHFreeShared                      = _SHFreeShared@8                       @523
     350;   RealDriveType                     = _RealDriveType@8                      @524
     351;   RealDriveTypeFlags                = _RealDriveTypeFlags@8                 @525
     352    NTSHChangeNotifyRegister          = _NTSHChangeNotifyRegister@24          @640
     353    NTSHChangeNotifyDeregister        = _NTSHChangeNotifyDeregister@4         @641
     354;   SHChangeNotifyReceive             = _SHChangeNotifyReceive@16             @643
     355;   SHChangeNotification_Lock         = _SHChangeNotification_Lock@16         @644
     356;   SHChangeNotification_Unlock       = _SHChangeNotification_Unlock@16       @645
     357;   SHChangeRegistrationReceive       = _SHChangeRegistrationReceive@8        @646
     358;   ReceiveAddToRecentDocs            = _ReceiveAddToRecentDocs@8             @647
     359;   SHWaitOp_Operate                  = _SHWaitOp_Operate@8                   @648
     360;   PathIsSameRoot                    = _PathIsSameRootAW@8                   @650
     361    ReadCabinetState                  = _ReadCabinetState@8                   @651
     362    WriteCabinetState                 = _WriteCabinetState@4                  @652
     363    PathProcessCommand                = _PathProcessCommand@16                @653
     364                                        _SHELL32_654@8                        @654
     365    FileIconInit                      = _FileIconInit@4                       @660
     366    IsUserAdmin                       = _IsUserAdmin@0                        @680
     367
     368;   FOOBAR1217                        = _FOOBAR1217@?                         @1217
     369
     370

  • trunk/src/shell32/shell32.h

    r96 r183  
    1 /* $Id: shell32.h,v 1.3 1999-06-10 16:56:09 phaller Exp $ */
     1/* $Id: shell32.h,v 1.4 1999-06-24 19:27:49 phaller Exp $ */
    22
    33#ifndef __shell32_H__
    … …  
    6969
    7070typedef void *LPSHELLFOLDER;
     71
     72
     73/****************************************************************************
     74*  STRRET (temporary, move it away)
     75*/
     76#define STRRET_WSTR    0x0000
     77#define STRRET_OFFSETA 0x0001
     78#define STRRET_CSTRA   0x0002
     79#define STRRET_ASTR    0X0003
     80#define STRRET_OFFSETW 0X0004
     81#define STRRET_CSTRW   0X0005
     82
     83
     84typedef struct _STRRET
     85{ UINT uType;              /* STRRET_xxx */
     86  union
     87  {
     88    LPWSTR pOleStr;        /* OLESTR that will be freed */
     89    LPSTR  pStr;
     90    UINT   uOffset;        /* OffsetINT32o SHITEMID (ANSI) */
     91    char   cStr[MAX_PATH]; /* Buffer to fill in */
     92    WCHAR  cStrW[MAX_PATH];
     93  }u;
     94} STRRET,*LPSTRRET;
     95
     96
     97
     98/****************************************************************************
     99 * Prototypes                                                               *
     100 ****************************************************************************/
     101
     102HANDLE  WIN32API SHFreeShared(HANDLE hmem, DWORD  procID);
     103DWORD   WIN32API SHFree(LPVOID x);
     104LPVOID  WIN32API SHAlloc(DWORD len);
     105HRESULT WIN32API SHGetSpecialFolderLocation(HWND hwndOwner, int nFolder, LPITEMIDLIST *ppidl);
     106BOOL    WIN32API SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath);
     107BOOL    WIN32API SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR  pszPath);
     108LPSTR   WIN32API PathCombineA(LPSTR szDest, LPCSTR lpszDir, LPCSTR lpszFile);
    71109
    72110

  • trunk/src/shell32/unknown.cpp

    r170 r183  
    1 /* $Id: unknown.cpp,v 1.2 1999-06-23 22:28:52 phaller Exp $ */
     1/* $Id: unknown.cpp,v 1.3 1999-06-24 19:27:49 phaller Exp $ */
    22
    33/*
    … …  
    4141 * Variables :
    4242 * Result    :
    43  * Remark    :
     43 * Remark    : SHELL32.229
    4444 * Status    : UNTESTED UNKNOWN
    4545 *
    … …  
    7777 * Variables :
    7878 * Result    :
    79  * Remark    :
     79 * Remark    : SHELL32.232
    8080 * Status    : UNTESTED UNKNOWN
    8181 *
    … …  
    126126 * Variables :
    127127 * Result    :
    128  * Remark    :
     128 * Remark    : SHELL32.230
    129129 * Status    : UNTESTED STUB UNKNOWN
    130130 *
    … …  
    147147 * Variables :
    148148 * Result    :
    149  * Remark    :
     149 * Remark    : SHELL32.231
    150150 * Status    : UNTESTED STUB UNKNOWN
    151151 *
    … …  
    160160  return (0);
    161161}
    162 
Note: See TracChangeset for help on using the changeset viewer.