Changeset 4032 for trunk/src


Ignore:
Timestamp:
Aug 18, 2000, 4:01:27 AM (25 years ago)
Author:
phaller
Message:

Synchronized shell32 with wine

Location:
trunk/src/shell32
Files:
8 added
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shell32/brsfolder.cpp

    r3243 r4032  
    1 /* $Id: brsfolder.cpp,v 1.4 2000-03-26 16:34:38 cbratschi Exp $ */
     1/* $Id: brsfolder.cpp,v 1.5 2000-08-18 02:01:14 phaller Exp $ */
    22
    33/*
    … …  
    4646#include "shell32_main.h"
    4747#include "shellapi.h"
     48#include "shlguid.h"
    4849
    4950#include <misc.h>

  • trunk/src/shell32/iconcache.cpp

    r3551 r4032  
    1 /* $Id: iconcache.cpp,v 1.8 2000-05-18 14:16:02 sandervl Exp $ */
     1/* $Id: iconcache.cpp,v 1.9 2000-08-18 02:01:15 phaller Exp $ */
    22
    33/*
    … …  
    3636
    3737#include "shellapi.h"
     38#include "shlguid.h"
     39#include "shlwapi.h"
    3840#include "pidl.h"
    3941#include "shell32_main.h"
     42#include "wine/undocshell.h"
    4043
    4144#include <heapstring.h>
    … …  
    765768 *
    766769 */
    767 BOOL PidlToSicIndex (IShellFolder * sh, LPITEMIDLIST pidl, BOOL bBigIcon, UINT * pIndex)
     770BOOL PidlToSicIndex (IShellFolder * sh,
     771                     LPITEMIDLIST pidl,
     772                     BOOL bBigIcon,
     773                     UINT uFlags,
     774                     UINT * pIndex)
    768775{
    769776   IExtractIcon   *ei;
    … …  
    777784   if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconA, 0, (void **)&ei)))
    778785   {
    779      if (NOERROR==IExtractIconA_GetIconLocation(ei, 0, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags))
     786     if (NOERROR==IExtractIconA_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags))
    780787     { *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex);
    781788       ret = TRUE;
    … …  
    801808 */
    802809
    803 ODINFUNCTION3(UINT,SHMapPIDLToSystemImageListIndex,LPSHELLFOLDER, sh,
    804                                                    LPITEMIDLIST,  pidl,
    805                                                    UINT*,         pIndex)
     810ODINFUNCTION3(int,SHMapPIDLToSystemImageListIndex,
     811              LPSHELLFOLDER, sh,
     812              LPITEMIDLIST,  pidl,
     813              UINT*,         pIndex)
    806814{
    807815   UINT  Index;
    … …  
    810818
    811819   if (pIndex)
    812      PidlToSicIndex ( sh, pidl, 1, pIndex);
    813    PidlToSicIndex ( sh, pidl, 0, &Index);
     820     PidlToSicIndex ( sh, pidl, 1, 0, pIndex);
     821   PidlToSicIndex ( sh, pidl, 0, 0, &Index);
    814822   return Index;
    815823}

  • trunk/src/shell32/makefile

    r3864 r4032  
    1 # $Id: makefile,v 1.26 2000-07-19 19:05:22 sandervl Exp $
     1# $Id: makefile,v 1.27 2000-08-18 02:01:16 phaller Exp $
    22
    33#
    … …  
    2727$(OBJDIR)\initterm.obj \
    2828$(OBJDIR)\brsfolder.obj \
     29$(OBJDIR)\changenotify.obj \
    2930$(OBJDIR)\classes.obj \
     31$(OBJDIR)\clipboard.obj \
    3032$(OBJDIR)\contmenu.obj \
    3133$(OBJDIR)\dataobject.obj \
     34$(OBJDIR)\dialogs.obj \
    3235$(OBJDIR)\enumidlist.obj \
    3336$(OBJDIR)\folders.obj \
    … …  
    4245$(OBJDIR)\shellpath.obj \
    4346$(OBJDIR)\shellole.obj \
     47$(OBJDIR)\shellreg.obj \
     48$(OBJDIR)\shellstring.obj \
    4449$(OBJDIR)\shellstub.obj \
    4550$(OBJDIR)\shellord.obj \
    46 $(OBJDIR)\shv_bg_cmenu.obj \
     51$(OBJDIR)\shlfileop.obj \
    4752$(OBJDIR)\shlfolder.obj \
    4853$(OBJDIR)\shlview.obj \
    4954$(OBJDIR)\shell.obj \
     55$(OBJDIR)\shv_bg_cmenu.obj \
     56$(OBJDIR)\shv_item_cmenu.obj \
    5057$(OBJDIR)\unknown.obj \
    5158$(OBJDIR)\misc.obj \

  • trunk/src/shell32/misc.cpp

    r3561 r4032  
    1 /* $Id: misc.cpp,v 1.7 2000-05-19 12:09:24 sandervl Exp $ */
     1/* $Id: misc.cpp,v 1.8 2000-08-18 02:01:16 phaller Exp $ */
    22
    33/*
    … …  
    2828#include <winnls.h>
    2929#include "shell32_main.h"
     30#include "wine/undocshell.h"
    3031#include <misc.h>
    3132//#include <string.h>

  • trunk/src/shell32/pidl.cpp

    r3469 r4032  
    1 /* $Id: pidl.cpp,v 1.8 2000-05-01 01:33:25 phaller Exp $ */
     1/* $Id: pidl.cpp,v 1.9 2000-08-18 02:01:17 phaller Exp $ */
    22
    33/*
    … …  
    748748     return FALSE;
    749749
    750    return SHFree(pidl);
     750  SHFree(pidl);
     751  return TRUE;
    751752}
    752753/*************************************************************************
    … …  
    755756 */
    756757
    757 ODINFUNCTION1(DWORD,ILGlobalFree,LPITEMIDLIST, pidl)
     758ODINPROCEDURE1(ILGlobalFree,
     759               LPITEMIDLIST, pidl)
    758760{
    759761   TRACE_(pidl)("%p\n",pidl);
    760762
    761    if (!pidl)
    762      return FALSE;
    763 
    764    return pCOMCTL32_Free (pidl);
     763   if (pidl)
     764     pCOMCTL32_Free (pidl);
    765765}
    766766/*************************************************************************
    … …  
    803803 */
    804804
    805 ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathA,LPSTR, lpszPath)
     805ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathA,LPCSTR, lpszPath)
    806806{
    807807   LPITEMIDLIST   pidl=NULL;
    … …  
    828828}
    829829
    830 ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathW,LPWSTR, lpszPath)
     830ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathW,LPCWSTR, lpszPath)
    831831{
    832832   char  lpszTemp[MAX_PATH];
    833833
    834    WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
     834   WideCharToLocal(lpszTemp, (LPWSTR)lpszPath, MAX_PATH);
    835835
    836836   return SHSimpleIDListFromPathA (lpszTemp);
    837837}
    838838
    839 ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathAW,LPVOID, lpszPath)
     839ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathAW,LPCVOID, lpszPath)
    840840{
    841841   if ( VERSION_OsIsUnicode())
    … …  
    18781878    WORD wAttrib = 0;
    18791879    int i;
    1880 
     1880 
     1881    if (! pData) return 0;
     1882 
    18811883    switch(pData->type)
    18821884    {
    … …  
    18881890            break;
    18891891    }
     1892 
    18901893    if(uOutSize >= 6)
    18911894    {
    … …  
    19161919}
    19171920
     1921
     1922/*************************************************************************
     1923* ILFreeaPidl
     1924*
     1925* free a aPidl struct
     1926*/
     1927ODINPROCEDURE2(_ILFreeaPidl,
     1928               LPITEMIDLIST *, apidl,
     1929               UINT, cidl)
     1930{
     1931        int   i;
     1932
     1933        if(apidl)
     1934        {
     1935          for(i = 0; i < cidl; i++) SHFree(apidl[i]);
     1936          SHFree(apidl);
     1937        }
     1938}
     1939
     1940/*************************************************************************
     1941* ILCopyaPidl
     1942*
     1943* copys a aPidl struct
     1944*/
     1945ODINFUNCTION2(LPITEMIDLIST *,_ILCopyaPidl,
     1946              LPITEMIDLIST *,apidlsrc,
     1947              UINT,          cidl)
     1948{
     1949        int i;
     1950        LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
     1951        if(!apidlsrc) return NULL;
     1952
     1953        for(i = 0; i < cidl; i++)
     1954          apidldest[i] = ILClone(apidlsrc[i]);
     1955
     1956        return apidldest;
     1957}
     1958
     1959/*************************************************************************
     1960* _ILCopyCidaToaPidl
     1961*
     1962* creates aPidl from CIDA
     1963*/
     1964ODINFUNCTION2(LPITEMIDLIST*, _ILCopyCidaToaPidl,
     1965              LPITEMIDLIST*, pidl,
     1966              LPCIDA,        cida)
     1967{
     1968        int i;
     1969        LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
     1970
     1971        if(!dst) return NULL;
     1972
     1973        if (pidl)
     1974          *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
     1975
     1976        for(i = 0; i < cida->cidl; i++)
     1977          dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
     1978
     1979        return dst;
     1980}

  • trunk/src/shell32/pidl.h

    r3257 r4032  
    1 /* $Id: pidl.h,v 1.4 2000-03-28 15:28:45 cbratschi Exp $ */
     1/* $Id: pidl.h,v 1.5 2000-08-18 02:01:18 phaller Exp $ */
    22
    33/*
    … …  
    190190BOOL pcheck (LPCITEMIDLIST pidl);
    191191
     192/*
     193 * aPidl helper
     194 */
     195void WINAPI _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl);
     196LPITEMIDLIST * WINAPI _ILCopyaPidl(LPITEMIDLIST * apidlsrc, UINT cidl);
     197LPITEMIDLIST * WINAPI _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPCIDA cida);
     198
    192199#endif

  • trunk/src/shell32/sh.cpp

    r1353 r4032  
    1 /* $Id: sh.cpp,v 1.10 1999-10-19 10:23:26 phaller Exp $ */
     1/* $Id: sh.cpp,v 1.11 2000-08-18 02:01:18 phaller Exp $ */
    22
    33/*
    … …  
    322322
    323323/*****************************************************************************
    324  * Name      : HRESULT SHRegDeleteKeyW
    325  * Purpose   :
    326  * Parameters:
    327  * Variables :
    328  * Result    :
    329  * Remark    : SHELL32.512
    330  * Status    : UNTESTED STUB
    331  *
    332  * Author    : Patrick Haller [Tue, 1999/06/09 20:02]
    333  *****************************************************************************/
    334 
    335 ODINFUNCTION2(HRESULT, SHRegDeleteKeyW,
    336               HKEY,    hkey,
    337               LPWSTR,  lpszKey)
    338 {
    339   return RegDeleteKeyW(hkey,
    340                        lpszKey);
    341 }
    342 
    343 
    344 /*****************************************************************************
    345324 * Name      : HRESULT SHRegDeleteKeyA
    346325 * Purpose   :

  • trunk/src/shell32/shell32.def

    r3561 r4032  
    1 ; $Id: shell32.def,v 1.26 2000-05-19 12:09:25 sandervl Exp $
     1; $Id: shell32.def,v 1.27 2000-08-18 02:01:19 phaller Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    9797    SHRegisterDragDrop                = _SHRegisterDragDrop@8                 @86
    9898    SHRevokeDragDrop                  = _SHRevokeDragDrop@4                   @87
    99     SHDoDragDrop                      = _SHDoDragDrop@24                      @88
     99    SHDoDragDrop                      = _SHDoDragDrop@20                      @88
    100100    SHCloneSpecialIDList              = _SHCloneSpecialIDList@12              @89
    101101    SHFindFiles                       = _SHFindFiles@8                        @90
    … …  
    349349    SHRegDeleteKeyA                   = _SHRegDeleteKeyA@8                    @513 ;?
    350350    SHAllocShared                     = _SHAllocShared@12                     @520
     351    SHInitRestricted                  = _SHInitRestricted@8
    351352    SHLockShared                      = _SHLockShared@8                       @521
    352353    SHUnlockShared                    = _SHUnlockShared@4                     @522

  • trunk/src/shell32/shell32_main.cpp

    r3551 r4032  
    1 /* $Id: shell32_main.cpp,v 1.11 2000-05-18 14:16:03 sandervl Exp $ */
     1/* $Id: shell32_main.cpp,v 1.12 2000-08-18 02:01:19 phaller Exp $ */
    22
    33/*
    … …  
    4949#include "wine/undocshell.h"
    5050#include "shpolicy.h"
     51#include "shlwapi.h"
    5152
    5253#include <heapstring.h>
    … …  
    148149   DWORD ret = TRUE, dwAttributes = 0;
    149150   IShellFolder * psfParent = NULL;
    150    IExtractIcon * pei = NULL;
     151   IExtractIconA * pei = NULL;
    151152   LPITEMIDLIST   pidlLast = NULL, pidl = NULL;
    152153   HRESULT hr = S_OK;
    … …  
    160161   if ((flags & SHGFI_USEFILEATTRIBUTES) && (flags & (SHGFI_ATTRIBUTES|SHGFI_EXETYPE|SHGFI_PIDL)))
    161162     return FALSE;
    162 
     163 
     164   /* windows initializes this values regardless of the flags */
     165   psfi->szDisplayName[0] = '\0';
     166   psfi->szTypeName[0] = '\0';
     167   psfi->iIcon = 0;
     168 
    163169   /* translate the path into a pidl only when SHGFI_USEFILEATTRIBUTES in not specified
    164170      the pidl functions fail on not existing file names */
    … …  
    236242     if (SUCCEEDED(hr))
    237243     {
    238        hr = IExtractIconA_GetIconLocation(pei, 0, szLoaction, MAX_PATH, &iIndex, &uFlags);
     244       hr = IExtractIconA_GetIconLocation(pei, (flags & SHGFI_OPENICON) ? GIL_OPENICON : 0, szLoaction, MAX_PATH, &iIndex, &uFlags);
    239245       /* fixme what to do with the index? */
    240246
    … …  
    278284     else
    279285     {
    280        if (!(PidlToSicIndex(psfParent, pidlLast, (flags && SHGFI_LARGEICON), (PUINT)&(psfi->iIcon))))
     286       if (!(PidlToSicIndex(psfParent, pidlLast, (flags && SHGFI_LARGEICON),
     287                            (flags & SHGFI_OPENICON) ? GIL_OPENICON : 0, (PUINT)&(psfi->iIcon))))
    281288       {
    282289         ret = FALSE;
    … …  
    285292     if (ret)
    286293     {
    287        ret = (DWORD) ((flags && SHGFI_LARGEICON) ? ShellBigIconList : ShellSmallIconList);
     294       ret = (DWORD) ((flags & SHGFI_LARGEICON) ? ShellBigIconList : ShellSmallIconList);
    288295     }
    289296   }
    … …  
    512519 */
    513520
    514 ODINFUNCTION1(DWORD, SHLoadInProc, DWORD, dwArg1)
    515 {
    516   CLSID *id;
    517 
     521ODINFUNCTION1(DWORD, SHLoadInProc, REFCLSID, rclsid)
     522{
    518523  dprintf(("SHELL32: SHLoadInProc\n"));
    519 
    520   CLSIDFromString((LPCOLESTR) dwArg1, id);
    521   if (S_OK==SHCoCreateInstance( (LPSTR) dwArg1, id, NULL, &IID_IUnknown, NULL) )
    522         return NOERROR;
     524 
     525  IUnknown *pUnk = NULL;
     526  CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (LPVOID*)pUnk);
     527  if (pUnk)
     528  {
     529    IUnknown_Release(pUnk);
     530    return NOERROR;
     531  }
    523532  return DISP_E_MEMBERNOTFOUND;
    524533}
    … …  
    949958HICON (WINAPI *pCreateIconFromResourceEx)(LPBYTE bits,UINT cbSize, BOOL bIcon, DWORD dwVersion, INT width, INT height,UINT cFlag);
    950959
    951 /* ole2 */
    952 HRESULT (WINAPI* pOleInitialize)(LPVOID reserved);
    953 void (WINAPI* pOleUninitialize)(void);
    954 HRESULT (WINAPI* pDoDragDrop)(IDataObject* pDataObject, IDropSource * pDropSource, DWORD dwOKEffect, DWORD *pdwEffect);
    955 HRESULT (WINAPI* pRegisterDragDrop)(HWND hwnd, IDropTarget* pDropTarget);
    956 HRESULT (WINAPI* pRevokeDragDrop)(HWND hwnd);
    957960
    958961static HINSTANCE  hComctl32;
    … …  
    960963static INT     shell32_RefCount = 0;
    961964
    962 INT      shell32_ObjCount = 0;
     965LONG        shell32_ObjCount = 0;
    963966HINSTANCE   shell32_hInstance = 0;
     967HMODULE     huser32 = 0;
    964968HIMAGELIST  ShellSmallIconList = 0;
    965969HIMAGELIST  ShellBigIconList = 0;

  • trunk/src/shell32/shell32_main.h

    r3243 r4032  
    1 /* $Id: shell32_main.h,v 1.3 2000-03-26 16:34:50 cbratschi Exp $ */
     1/* $Id: shell32_main.h,v 1.4 2000-08-18 02:01:20 phaller Exp $ */
    22
    33/*
    … …  
    4646*  global SHELL32.DLL variables
    4747*/
    48 extern HINSTANCE shell32_hInstance;
    49 extern INT        shell32_ObjCount;
     48extern HMODULE          huser32;
     49extern HINSTANCE        shell32_hInstance;
     50extern LONG             shell32_ObjCount;
    5051extern HIMAGELIST       ShellSmallIconList;
    5152extern HIMAGELIST       ShellBigIconList;
    … …  
    8182/* ole2 */
    8283extern HRESULT (WINAPI* pOleInitialize)(LPVOID reserved);
    83 extern void (WINAPI* pOleUninitialize)(void);
    84 extern HRESULT (WINAPI* pDoDragDrop)(IDataObject* pDataObject, IDropSource * pDropSource, DWORD dwOKEffect, DWORD * pdwEffect);
     84extern void    (WINAPI* pOleUninitialize)(void);
    8585extern HRESULT (WINAPI* pRegisterDragDrop)(HWND hwnd, IDropTarget* pDropTarget);
    8686extern HRESULT (WINAPI* pRevokeDragDrop)(HWND hwnd);
    87 
     87extern HRESULT (WINAPI* pDoDragDrop)(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
     88extern void (WINAPI* pReleaseStgMedium)(STGMEDIUM* pmedium);
     89extern HRESULT (WINAPI* pOleSetClipboard)(IDataObject* pDataObj);
     90extern HRESULT (WINAPI* pOleGetClipboard)(IDataObject** ppDataObj);
     91
     92   
    8893BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList);
    8994
    … …  
    96101BOOL SIC_Initialize(void);
    97102void SIC_Destroy(void);
    98 BOOL PidlToSicIndex (IShellFolder * sh, LPITEMIDLIST pidl, BOOL bBigIcon, UINT * pIndex);
     103BOOL PidlToSicIndex (IShellFolder * sh, LPITEMIDLIST pidl, BOOL bBigIcon, UINT uFlags, UINT * pIndex);
    99104
    100105/* Classes Root */
    … …  
    107112DWORD   WINAPI ParseFieldA(LPCSTR src,DWORD field,LPSTR dst,DWORD len);
    108113
    109 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID);
    110 LPVOID  WINAPI SHLockShared(HANDLE hmem, DWORD procID);
    111 BOOL    WINAPI SHUnlockShared(HANDLE pmem);
    112 HANDLE  WINAPI SHFreeShared(HANDLE hmem, DWORD procID);
    113 
    114114/****************************************************************************
    115115 * Class constructors
    … …  
    119119
    120120LPCLASSFACTORY  IClassFactory_Constructor(REFCLSID);
    121 IContextMenu *  IContextMenu_Constructor(LPSHELLFOLDER pSFParent, LPCITEMIDLIST pidl, LPCITEMIDLIST *aPidls, UINT uItemCount);
    122 IContextMenu *  ISvBgCm_Constructor(void);
     121IContextMenu *  ISvItemCm_Constructor(LPSHELLFOLDER pSFParent, LPCITEMIDLIST pidl, LPCITEMIDLIST *aPidls, UINT uItemCount);
     122IContextMenu *  ISvBgCm_Constructor(LPSHELLFOLDER pSFParent);
    123123LPSHELLVIEW     IShellView_Constructor(LPSHELLFOLDER);
    124124LPSHELLLINK     IShellLink_Constructor(BOOL);
    … …  
    139139HRESULT WINAPI  SHELL32_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv);
    140140HRESULT WINAPI  SHELL32_DllCanUnloadNow(void);
    141 LRESULT WINAPI SHCoCreateInstance(LPSTR,REFCLSID,LPUNKNOWN,REFIID,LPVOID *);
    142141
    143142/* fixme: move away */
    … …  
    166165/* Systray */
    167166BOOL SYSTRAY_Init(void);
    168 
     167   
     168/* Clipboard */
     169void InitShellOle(void);
     170void FreeShellOle(void);
     171BOOL GetShellOle(void);
     172   
     173/* PH: This creates an auto variable just in any importer...
     174HRESULT (WINAPI* pOleInitialize)(LPVOID reserved);
     175void    (WINAPI* pOleUninitialize)(void);
     176HRESULT (WINAPI* pRegisterDragDrop)(HWND hwnd, IDropTarget* pDropTarget);
     177HRESULT (WINAPI* pRevokeDragDrop)(HWND hwnd);
     178HRESULT (WINAPI* pDoDragDrop)(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
     179void (WINAPI* pReleaseStgMedium)(STGMEDIUM* pmedium);
     180HRESULT (WINAPI* pOleSetClipboard)(IDataObject* pDataObj);
     181HRESULT (WINAPI* pOleGetClipboard)(IDataObject** ppDataObj);
     182*/
     183   
     184HGLOBAL RenderHDROP(LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     185HGLOBAL RenderSHELLIDLIST (LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     186HGLOBAL RenderSHELLIDLISTOFFSET (LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     187HGLOBAL RenderFILECONTENTS (LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     188HGLOBAL RenderFILEDESCRIPTOR (LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     189HGLOBAL RenderFILENAME (LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl);
     190HGLOBAL RenderPREFEREDDROPEFFECT (DWORD dwFlags);
     191
     192/* Change Notification */
     193void InitChangeNotifications(void);
     194void FreeChangeNotifications(void);
     195
     196/* file operation */
     197BOOL SHELL_DeleteDirectoryA(LPCSTR pszDir, BOOL bShowUI);
     198
     199inline static BOOL SHELL_OsIsUnicode(void)
     200{
     201/* if high-bit of version is 0, we are emulating NT */
     202  return !(GetVersion() & 0x80000000);
     203}
     204   
    169205#ifdef __cplusplus
    170206  }
    171207#endif /* defined(__cplusplus) */
    172208
    173 
    174 
    175209#endif

  • trunk/src/shell32/shellguid.cpp

    r1214 r4032  
    1 /* $Id: shellguid.cpp,v 1.1 1999-10-09 11:13:24 sandervl Exp $ */
     1/* $Id: shellguid.cpp,v 1.2 2000-08-18 02:01:21 phaller Exp $ */
    22
    33/*
    … …  
    4343#include <wine/obj_extracticon.h>
    4444#include <wine/obj_shellextinit.h>
     45#include "shellfolder.h"
    4546#include <docobj.h>
    4647

  • trunk/src/shell32/shelllink.cpp

    r3243 r4032  
    1 /* $Id: shelllink.cpp,v 1.3 2000-03-26 16:34:50 cbratschi Exp $ */
     1/* $Id: shelllink.cpp,v 1.4 2000-08-18 02:01:21 phaller Exp $ */
    22/*
    33 *
    … …  
    7979typedef struct
    8080{
    81         ICOM_VTABLE(IShellLink)*        lpvtbl;
     81        ICOM_VTABLE(IShellLinkA)*       lpvtbl;
    8282        DWORD                           ref;
    8383
    … …  
    121121        TRACE("(%p)\n",This);
    122122
    123         return IShellLink_QueryInterface((IShellLink*)This, riid, ppvObj);
     123        return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObj);
    124124}
    125125
    … …  
    133133        TRACE("(%p)->(count=%lu)\n",This,This->ref);
    134134
    135         return IShellLink_AddRef((IShellLink*)This);
     135        return IShellLinkA_AddRef((IShellLinkA*)This);
    136136}
    137137/******************************************************************************
    … …  
    144144        TRACE("(%p)->(count=%lu)\n",This,This->ref);
    145145
    146         return IShellLink_Release((IShellLink*)This);
     146        return IShellLinkA_Release((IShellLinkA*)This);
    147147}
    148148
    … …  
    229229        TRACE("(%p)\n",This);
    230230
    231         return IShellLink_QueryInterface((IShellLink*)This, riid, ppvoid);
     231        return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvoid);
    232232}
    233233
    … …  
    242242        TRACE("(%p)\n",This);
    243243
    244         return IShellLink_Release((IShellLink*)This);
     244        return IShellLinkA_Release((IShellLinkA*)This);
    245245}
    246246
    … …  
    255255        TRACE("(%p)\n",This);
    256256
    257         return IShellLink_AddRef((IShellLink*)This);
     257        return IShellLinkA_AddRef((IShellLinkA*)This);
    258258}
    259259
    … …  
    409409 *  IShellLink_QueryInterface
    410410 */
    411 static HRESULT WINAPI IShellLink_fnQueryInterface( IShellLink * iface, REFIID riid,  LPVOID *ppvObj)
     411static HRESULT WINAPI IShellLinkA_fnQueryInterface( IShellLinkA * iface, REFIID riid,  LPVOID *ppvObj)
    412412{
    413413        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    420420
    421421        if(IsEqualIID(riid, &IID_IUnknown) ||
    422            IsEqualIID(riid, &IID_IShellLink))
     422           IsEqualIID(riid, &IID_IShellLinkA))
    423423        {
    424424          *ppvObj = This;
    … …  
    447447}
    448448/******************************************************************************
    449  * IShellLink_AddRef
    450  */
    451 static ULONG WINAPI IShellLink_fnAddRef(IShellLink * iface)
     449 * IShellLinkA_AddRef
     450 */
     451static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA * iface)
    452452{
    453453        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    459459}
    460460/******************************************************************************
    461  *      IShellLink_Release
    462  */
    463 static ULONG WINAPI IShellLink_fnRelease(IShellLink * iface)
     461 *      IShellLinkA_Release
     462 */
     463static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA * iface)
    464464{
    465465        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    486486}
    487487
    488 static HRESULT WINAPI IShellLink_fnGetPath(IShellLink * iface, LPSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags)
     488static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA * iface, LPSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags)
    489489{
    490490        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    499499        return NOERROR;
    500500}
    501 static HRESULT WINAPI IShellLink_fnGetIDList(IShellLink * iface, LPITEMIDLIST * ppidl)
     501static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA * iface, LPITEMIDLIST * ppidl)
    502502{
    503503        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    508508        return NOERROR;
    509509}
    510 static HRESULT WINAPI IShellLink_fnSetIDList(IShellLink * iface, LPCITEMIDLIST pidl)
     510static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA * iface, LPCITEMIDLIST pidl)
    511511{
    512512        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    519519        return NOERROR;
    520520}
    521 static HRESULT WINAPI IShellLink_fnGetDescription(IShellLink * iface, LPSTR pszName,INT cchMaxName)
     521static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA * iface, LPSTR pszName,INT cchMaxName)
    522522{
    523523        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    527527        return NOERROR;
    528528}
    529 static HRESULT WINAPI IShellLink_fnSetDescription(IShellLink * iface, LPCSTR pszName)
     529static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA * iface, LPCSTR pszName)
    530530{
    531531        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    534534        return NOERROR;
    535535}
    536 static HRESULT WINAPI IShellLink_fnGetWorkingDirectory(IShellLink * iface, LPSTR pszDir,INT cchMaxPath)
     536static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA * iface, LPSTR pszDir,INT cchMaxPath)
    537537{
    538538        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    542542        return NOERROR;
    543543}
    544 static HRESULT WINAPI IShellLink_fnSetWorkingDirectory(IShellLink * iface, LPCSTR pszDir)
     544static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA * iface, LPCSTR pszDir)
    545545{
    546546        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    549549        return NOERROR;
    550550}
    551 static HRESULT WINAPI IShellLink_fnGetArguments(IShellLink * iface, LPSTR pszArgs,INT cchMaxPath)
     551static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA * iface, LPSTR pszArgs,INT cchMaxPath)
    552552{
    553553        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    557557        return NOERROR;
    558558}
    559 static HRESULT WINAPI IShellLink_fnSetArguments(IShellLink * iface, LPCSTR pszArgs)
     559static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA * iface, LPCSTR pszArgs)
    560560{
    561561        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    565565        return NOERROR;
    566566}
    567 static HRESULT WINAPI IShellLink_fnGetHotkey(IShellLink * iface, WORD *pwHotkey)
     567static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA * iface, WORD *pwHotkey)
    568568{
    569569        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    575575        return NOERROR;
    576576}
    577 static HRESULT WINAPI IShellLink_fnSetHotkey(IShellLink * iface, WORD wHotkey)
     577static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA * iface, WORD wHotkey)
    578578{
    579579        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    585585        return NOERROR;
    586586}
    587 static HRESULT WINAPI IShellLink_fnGetShowCmd(IShellLink * iface, INT *piShowCmd)
     587static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA * iface, INT *piShowCmd)
    588588{
    589589        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    593593        return NOERROR;
    594594}
    595 static HRESULT WINAPI IShellLink_fnSetShowCmd(IShellLink * iface, INT iShowCmd)
     595static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA * iface, INT iShowCmd)
    596596{
    597597        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    600600        return NOERROR;
    601601}
    602 static HRESULT WINAPI IShellLink_fnGetIconLocation(IShellLink * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
     602static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
    603603{
    604604        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    609609        return NOERROR;
    610610}
    611 static HRESULT WINAPI IShellLink_fnSetIconLocation(IShellLink * iface, LPCSTR pszIconPath,INT iIcon)
     611static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA * iface, LPCSTR pszIconPath,INT iIcon)
    612612{
    613613        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    616616        return NOERROR;
    617617}
    618 static HRESULT WINAPI IShellLink_fnSetRelativePath(IShellLink * iface, LPCSTR pszPathRel, DWORD dwReserved)
     618static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA * iface, LPCSTR pszPathRel, DWORD dwReserved)
    619619{
    620620        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    623623        return NOERROR;
    624624}
    625 static HRESULT WINAPI IShellLink_fnResolve(IShellLink * iface, HWND hwnd, DWORD fFlags)
     625static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA * iface, HWND hwnd, DWORD fFlags)
    626626{
    627627        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    630630        return NOERROR;
    631631}
    632 static HRESULT WINAPI IShellLink_fnSetPath(IShellLink * iface, LPCSTR pszFile)
     632static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA * iface, LPCSTR pszFile)
    633633{
    634634        ICOM_THIS(IShellLinkImpl, iface);
    … …  
    642642*/
    643643
    644 static ICOM_VTABLE(IShellLink) slvt =
     644static ICOM_VTABLE(IShellLinkA) slvt =
    645645{
    646646        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    647         IShellLink_fnQueryInterface,
    648         IShellLink_fnAddRef,
    649         IShellLink_fnRelease,
    650         IShellLink_fnGetPath,
    651         IShellLink_fnGetIDList,
    652         IShellLink_fnSetIDList,
    653         IShellLink_fnGetDescription,
    654         IShellLink_fnSetDescription,
    655         IShellLink_fnGetWorkingDirectory,
    656         IShellLink_fnSetWorkingDirectory,
    657         IShellLink_fnGetArguments,
    658         IShellLink_fnSetArguments,
    659         IShellLink_fnGetHotkey,
    660         IShellLink_fnSetHotkey,
    661         IShellLink_fnGetShowCmd,
    662         IShellLink_fnSetShowCmd,
    663         IShellLink_fnGetIconLocation,
    664         IShellLink_fnSetIconLocation,
    665         IShellLink_fnSetRelativePath,
    666         IShellLink_fnResolve,
    667         IShellLink_fnSetPath
     647        IShellLinkA_fnQueryInterface,
     648        IShellLinkA_fnAddRef,
     649        IShellLinkA_fnRelease,
     650        IShellLinkA_fnGetPath,
     651        IShellLinkA_fnGetIDList,
     652        IShellLinkA_fnSetIDList,
     653        IShellLinkA_fnGetDescription,
     654        IShellLinkA_fnSetDescription,
     655        IShellLinkA_fnGetWorkingDirectory,
     656        IShellLinkA_fnSetWorkingDirectory,
     657        IShellLinkA_fnGetArguments,
     658        IShellLinkA_fnSetArguments,
     659        IShellLinkA_fnGetHotkey,
     660        IShellLinkA_fnSetHotkey,
     661        IShellLinkA_fnGetShowCmd,
     662        IShellLinkA_fnSetShowCmd,
     663        IShellLinkA_fnGetIconLocation,
     664        IShellLinkA_fnSetIconLocation,
     665        IShellLinkA_fnSetRelativePath,
     666        IShellLinkA_fnResolve,
     667        IShellLinkA_fnSetPath
    668668};
    669669
    … …  
    677677        _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
    678678
    679         return IShellLink_QueryInterface((IShellLink*)This, riid, ppvObj);
     679        return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObj);
    680680}
    681681
    … …  
    689689        TRACE("(%p)->(count=%lu)\n",This,This->ref);
    690690
    691         return IShellLink_AddRef((IShellLink*)This);
     691        return IShellLinkA_AddRef((IShellLinkA*)This);
    692692}
    693693/******************************************************************************
    … …  
    701701        TRACE("(%p)->(count=%lu)\n",This,This->ref);
    702702
    703         return IShellLink_Release((IShellLink*)This);
     703        return IShellLinkA_Release((IShellLinkA*)This);
    704704}
    705705
    … …  
    888888
    889889/**************************************************************************
    890  *        IShellLink_Constructor
    891  */
    892 IShellLink * IShellLink_Constructor(BOOL bUnicode)
     890 *        IShellLinkA_Constructor
     891 */
     892IShellLinkA * IShellLink_Constructor(BOOL bUnicode)
    893893{       IShellLinkImpl * sl;
    894894
    … …  
    902902        TRACE("(%p)->()\n",sl);
    903903        shell32_ObjCount++;
    904         return bUnicode ? (IShellLink *) &(sl->lpvtblw) : (IShellLink *)sl;
    905 }
    906 
    907 
     904        return bUnicode ? (IShellLinkA *) &(sl->lpvtblw) : (IShellLinkA *)sl;
     905}
     906
     907

  • trunk/src/shell32/shellord.cpp

    r3935 r4032  
    1 /* $Id: shellord.cpp,v 1.9 2000-08-02 17:53:33 bird Exp $ */
     1/* $Id: shellord.cpp,v 1.10 2000-08-18 02:01:22 phaller Exp $ */
    22/*
    33 * The parameters of many functions changes between different OS versions
    … …  
    4949ODINDEBUGCHANNEL(shell32-shellord)
    5050
    51 
    52 /*************************************************************************
    53  * SHChangeNotifyRegister                       [SHELL32.2]
    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 DWORD WINAPI
    60 SHChangeNotifyRegister(
    61     HWND hwnd,
    62     LONG events1,
    63     LONG events2,
    64     DWORD msg,
    65     int count,
    66     IDSTRUCT *idlist)
    67 {
    68         FIXME("SHChangeNotifyRegister: (0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
    69                 hwnd,events1,events2,msg,count,idlist);
    70         return 0;
    71 }
    72 /*************************************************************************
    73  * SHChangeNotifyDeregister                     [SHELL32.4]
    74  */
    75 DWORD WINAPI
    76 SHChangeNotifyDeregister(LONG x1)
    77 {       FIXME("(0x%08lx):stub.\n",x1);
    78         return 0;
    79 }
    80 /*************************************************************************
    81  * NTSHChangeNotifyRegister                     [SHELL32.640]
    82  * NOTES
    83  *   Idlist is an array of structures and Count specifies how many items in the array
    84  *   (usually just one I think).
    85  */
    86 DWORD WINAPI NTSHChangeNotifyRegister(
    87     HWND hwnd,
    88     LONG events1,
    89     LONG events2,
    90     DWORD msg,
    91     int count,
    92     IDSTRUCT *idlist)
    93 {       FIXME("(0x%04x,0x%08lx,0x%08lx,0x%08lx,0x%08x,%p):stub.\n",
    94                 hwnd,events1,events2,msg,count,idlist);
    95         return 0;
    96 }
    97 /*************************************************************************
    98  * NTSHChangeNotifyDeregister                   [SHELL32.641]
    99  */
    100 DWORD WINAPI NTSHChangeNotifyDeregister(LONG x1)
    101 {       FIXME("(0x%08lx):stub.\n",x1);
    102         return 0;
    103 }
    10451
    10552/*************************************************************************
    … …  
    13077}
    13178
    132 /*************************************************************************
    133  * PickIconDlg                                  [SHELL32.62]
    134  *
    135  */
    136 DWORD WINAPI PickIconDlg(DWORD x,DWORD y,DWORD z,DWORD a)
    137 {       FIXME("PickIconDlg(%08lx,%08lx,%08lx,%08lx):stub.\n",x,y,z,a);
    138         return 0xffffffff;
    139 }
    14079
    14180/*************************************************************************
    … …  
    14382 *
    14483 */
    145 DWORD WINAPI GetFileNameFromBrowse(HWND howner, LPSTR targetbuf, DWORD len, DWORD x, LPCSTR suffix, LPCSTR y, LPCSTR cmd)
    146 {       FIXME("(%04x,%p,%ld,%08lx,%s,%s,%s):stub.\n",
    147             howner,targetbuf,len,x,suffix,y,cmd);
     84ODINFUNCTION7(BOOL,   GetFileNameFromBrowse,
     85              HWND,   hwndOwner,
     86              LPSTR,  lpstrFile,
     87              DWORD,  nMaxFile,
     88              LPCSTR, lpstrInitialDir,
     89              LPCSTR, lpstrDefExt,
     90              LPCSTR, lpstrFIlter,
     91              LPCSTR, lpstrTitle)
     92{
     93  dprintf(("SHELL32: GetFileNameFromBrowse not implemented"));
     94
    14895    /* puts up a Open Dialog and requests input into targetbuf */
    14996    /* OFN_HIDEREADONLY|OFN_NOCHANGEDIR|OFN_FILEMUSTEXIST|OFN_unknown */
    150     lstrcpyA(targetbuf,"x:\\dummy.exe");
    151     return 1;
     97  lstrcpynA(lpstrFile,
     98            "x:\\dummy.exe",
     99            nMaxFile);
     100  return 1;
    152101}
    153102
    … …  
    223172 *    that was clicked.
    224173 */
    225 int WINAPI SHShellFolderView_Message(HWND hwndCabinet,UINT uMsg,LPARAM lParam)
    226 { FIXME("%04x %08ux %08lx stub\n",hwndCabinet,uMsg,lParam);
     174ODINFUNCTION3(int, SHShellFolderView_Message,
     175              HWND, hwndCabinet,
     176              DWORD, dwMessage,
     177              DWORD, dwParam)
     178{
     179  dprintf(("SHELL32: SHShellFolderView_Message not implemented"));
    227180  return 0;
    228181}
    229182
    230 /*************************************************************************
    231  * OleStrToStrN                                 [SHELL32.78]
    232  */
    233 BOOL WINAPI OleStrToStrNA (LPSTR lpStr, INT nStr, LPCWSTR lpOle, INT nOle)
    234 {
    235         TRACE("%p %x %s %x\n", lpStr, nStr, debugstr_w(lpOle), nOle);
    236         return WideCharToMultiByte (0, 0, lpOle, nOle, lpStr, nStr, NULL, NULL);
    237 }
    238 
    239 BOOL WINAPI OleStrToStrNW (LPWSTR lpwStr, INT nwStr, LPCWSTR lpOle, INT nOle)
    240 {
    241         TRACE("%p %x %s %x\n", lpwStr, nwStr, debugstr_w(lpOle), nOle);
    242 
    243         if (lstrcpynW ( lpwStr, lpOle, nwStr))
    244         { return lstrlenW (lpwStr);
    245         }
    246         return 0;
    247 }
    248 
    249 BOOL WINAPI OleStrToStrNAW (LPVOID lpOut, INT nOut, LPCVOID lpIn, INT nIn)
    250 {
    251         if (VERSION_OsIsUnicode())
    252           return OleStrToStrNW ((LPWSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
    253         return OleStrToStrNA ((LPSTR)lpOut, nOut, (LPCWSTR)lpIn, nIn);
    254 }
    255 
    256 /*************************************************************************
    257  * StrToOleStrN                                 [SHELL32.79]
    258  *  lpMulti, nMulti, nWide [IN]
    259  *  lpWide [OUT]
    260  */
    261 BOOL WINAPI StrToOleStrNA (LPWSTR lpWide, INT nWide, LPCSTR lpStrA, INT nStr)
    262 {
    263         TRACE("%p %x %s %x\n", lpWide, nWide, lpStrA, nStr);
    264         return MultiByteToWideChar (0, 0, lpStrA, nStr, lpWide, nWide);
    265 }
    266 BOOL WINAPI StrToOleStrNW (LPWSTR lpWide, INT nWide, LPCWSTR lpStrW, INT nStr)
    267 {
    268         TRACE("%p %x %s %x\n", lpWide, nWide, debugstr_w(lpStrW), nStr);
    269 
    270         if (lstrcpynW (lpWide, lpStrW, nWide))
    271         { return lstrlenW (lpWide);
    272         }
    273         return 0;
    274 }
    275 
    276 BOOL WINAPI StrToOleStrNAW (LPWSTR lpWide, INT nWide, LPCVOID lpStr, INT nStr)
    277 {
    278         if (VERSION_OsIsUnicode())
    279           return StrToOleStrNW (lpWide, nWide, (LPWSTR)lpStr, nStr);
    280         return StrToOleStrNA (lpWide, nWide, (LPSTR)lpStr, nStr);
    281 }
    282183
    283184/*************************************************************************
    … …  
    291192 *     exported by ordinal
    292193 */
    293 void WINAPI RegisterShellHook(HWND hwnd, DWORD y) {
    294     FIXME("(0x%08x,0x%08lx):stub.\n",hwnd,y);
     194ODINFUNCTION2(BOOL,  RegisterShellHook,
     195              HWND,  hWnd,
     196              DWORD, dwType)
     197{
     198  dprintf(("SHELL32: RegisterShellHook not implemented"));
     199  return FALSE;
    295200}
    296201/*************************************************************************
    … …  
    358263}
    359264
    360 /*************************************************************************
    361  * SHRestricted                         [SHELL32.100]
    362  *
    363  * walks through policy table, queries <app> key, <type> value, returns
    364  * queried (DWORD) value, and caches it between called to SHInitRestricted
    365  * to prevent unnecessary registry access.
    366  *
    367  * NOTES
    368  *     exported by ordinal
    369  *
    370  * REFERENCES:
    371  *     MS System Policy Editor
    372  *     98Lite 2.0 (which uses many of these policy keys) http://www.98lite.net/
    373  *     "The Windows 95 Registry", by John Woram, 1996 MIS: Press
    374  */
    375 DWORD WINAPI SHRestricted (DWORD pol) {
    376         char regstr[256];
    377         HKEY    xhkey;
    378         DWORD   retval, polidx, i, datsize = 4;
    379 
    380         TRACE("(%08lx)\n",pol);
    381 
    382         polidx = -1;
    383 
    384         /* scan to see if we know this policy ID */
    385         for (i = 0; i < SHELL_MAX_POLICIES; i++)
    386         {
    387              if (pol == sh32_policy_table[i].polflags)
    388              {
    389                  polidx = i;
    390                  break;
    391              }
    392         }
    393 
    394         if (polidx == -1)
    395         {
    396             /* we don't know this policy, return 0 */
    397             TRACE("unknown policy: (%08lx)\n", pol);
    398                 return 0;
    399         }
    400 
    401         /* we have a known policy */
    402         lstrcpyA(regstr, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\");
    403         lstrcatA(regstr, sh32_policy_table[polidx].appstr);
    404 
    405         /* first check if this policy has been cached, return it if so */
    406         if (sh32_policy_table[polidx].cache != SHELL_NO_POLICY)
    407         {
    408             return sh32_policy_table[polidx].cache;
    409         }
    410 
    411         /* return 0 and don't set the cache if any registry errors occur */
    412         retval = 0;
    413         if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
    414         {
    415             if (RegQueryValueExA(xhkey, sh32_policy_table[polidx].keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
    416             {
    417                 sh32_policy_table[polidx].cache = retval;
    418             }
    419 
    420         RegCloseKey(xhkey);
    421 }
    422 
    423         return retval;
    424 }
    425 
    426 /*************************************************************************
    427  *      SHInitRestricted                         [SHELL32.244]
    428  *
    429  * Win98+ by-ordinal only routine called by Explorer and MSIE 4 and 5.
    430  * Inits the policy cache used by SHRestricted to avoid excess
    431  * registry access.
    432  *
    433  * INPUTS
    434  * Two inputs: one is a string or NULL.  If non-NULL the pointer
    435  * should point to a string containing the following exact text:
    436  * "Software\Microsoft\Windows\CurrentVersion\Policies".
    437  * The other input is unused.
    438  *
    439  * NOTES
    440  * If the input is non-NULL and does not point to a string containing
    441  * that exact text the routine will do nothing.
    442  *
    443  * If the text does match or the pointer is NULL, then the routine
    444  * will init SHRestricted()'s policy cache to all 0xffffffff and
    445  * returns 0xffffffff as well.
    446  *
    447  * I haven't yet run into anything calling this with inputs other than
    448  * (NULL, NULL), so I may have the inputs reversed.
    449  */
    450 
    451 BOOL WINAPI SHInitRestricted(LPSTR inpRegKey, LPSTR parm2)
    452 {
    453      int i;
    454 
    455      dprintf(("SHELL32:SHELLORD:SHInitRestricted(%p, %p)\n", inpRegKey, parm2));
    456 
    457      /* first check - if input is non-NULL and points to the secret
    458         key string, then pass.  Otherwise return 0.
    459      */
    460 
    461      if (inpRegKey != (LPSTR)NULL)
    462      {
    463          if (lstrcmpiA(inpRegKey, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies"))
    464          {
    465              /* doesn't match, fail */
    466              return 0;
    467          }
    468      }
    469 
    470      /* check passed, init all policy cache entries with SHELL_NO_POLICY */
    471      for (i = 0; i < SHELL_MAX_POLICIES; i++)
    472      {
    473           sh32_policy_table[i].cache = SHELL_NO_POLICY;
    474      }
    475 
    476      return SHELL_NO_POLICY;
    477 }
    478 
    479 /*************************************************************************
    480  * SHCreateDirectory                            [SHELL32.165]
    481  *
    482  * NOTES
    483  *  exported by ordinal
    484  *  not sure about LPSECURITY_ATTRIBUTES
    485  */
    486 DWORD WINAPI SHCreateDirectory(LPSECURITY_ATTRIBUTES sec,LPCSTR path) {
    487         TRACE("(%p,%s):stub.\n",sec,path);
    488         if (CreateDirectoryA(path,sec))
    489                 return TRUE;
    490         /* SHChangeNotify(8,1,path,0); */
    491         return FALSE;
    492 #if 0
    493         if (SHELL32_79(path,(LPVOID)x))
    494                 return 0;
    495         FIXME("(%08lx,%s):stub.\n",x,path);
    496         return 0;
    497 #endif
    498 }
    499265
    500266/*************************************************************************
    … …  
    506272 */
    507273#define MEM_DEBUG 0
    508 DWORD WINAPI SHFree(LPVOID x)
     274void WINAPI SHFree(LPVOID x)
    509275{
    510276#if MEM_DEBUG
    511         WORD len = *(LPWORD)(x-2);
    512 
    513         if ( *(LPWORD)(x+len) != 0x7384)
    514           ERR("MAGIC2!\n");
    515 
    516         if ( (*(LPWORD)(x-4)) != 0x8271)
    517           ERR("MAGIC1!\n");
    518         else
    519           memset(x-4, 0xde, len+6);
    520 
    521         TRACE("%p len=%u\n",x, len);
    522 
    523         x -= 4;
     277  WORD len = *(LPWORD)(x-2);
     278
     279  if ( *(LPWORD)(x+len) != 0x7384)
     280    ERR("MAGIC2!\n");
     281
     282  if ( (*(LPWORD)(x-4)) != 0x8271)
     283    ERR("MAGIC1!\n");
     284  else
     285    memset(x-4, 0xde, len+6);
     286
     287  TRACE("%p len=%u\n",x, len);
     288
     289  x -= 4;
    524290#else
    525         TRACE("%p\n",x);
     291  TRACE("%p\n",x);
    526292#endif
    527         return HeapFree(GetProcessHeap(), 0, x);
     293 
     294  HeapFree(GetProcessHeap(), 0, x);
    528295}
    529296
    … …  
    562329 *     exported by ordinal
    563330 */
    564 DWORD WINAPI SHRegisterDragDrop(HWND hWnd,IDropTarget * pDropTarget)
    565 {
    566         FIXME("(0x%08x,%p):stub.\n", hWnd, pDropTarget);
    567         return     RegisterDragDrop(hWnd, pDropTarget);
     331ODINFUNCTION2(HRESULT,      SHRegisterDragDrop,
     332              HWND,         hWnd,
     333              LPDROPTARGET, lpDropTarget)
     334{
     335  dprintf(("SHELL32: SHRegisterDragDrop not correctly implemented"));
     336  return     RegisterDragDrop(hWnd, lpDropTarget);
    568337}
    569338
    … …  
    574343 *     exported by ordinal
    575344 */
    576 DWORD WINAPI SHRevokeDragDrop(DWORD x) {
    577     FIXME("(0x%08lx):stub.\n",x);
    578     return 0;
     345ODINFUNCTION1(HRESULT, SHRevokeDragDrop,
     346              HWND,    hWnd)
     347{
     348  dprintf(("SHELL32: SHRevokeDragDrop not implemented"));
     349  return 0;
    579350}
    580351
    … …  
    585356 *     exported by ordinal
    586357 */
    587 DWORD WINAPI SHDoDragDrop(DWORD u, DWORD v, DWORD w, DWORD x, DWORD y, DWORD z) {
    588     FIXME("(0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx 0x%08lx):stub.\n",u,v,w,x,y,z);
    589     return 0;
    590 }
    591 
    592 /*************************************************************************
    593  * RunFileDlg                                   [SHELL32.61]
    594  *
    595  * NOTES
    596  *     Original name: RunFileDlg (exported by ordinal)
    597  */
    598 DWORD WINAPI
    599 RunFileDlg (HWND hwndOwner, DWORD dwParam1, DWORD dwParam2,
    600             LPSTR lpszTitle, LPSTR lpszPrompt, UINT uFlags)
    601 {
    602     FIXME("(0x%08x 0x%lx 0x%lx \"%s\" \"%s\" 0x%x):stub.\n",
    603            hwndOwner, dwParam1, dwParam2, lpszTitle, lpszPrompt, uFlags);
    604     return 0;
    605 }
    606 
    607 /*************************************************************************
    608  * ExitWindowsDialog                            [SHELL32.60]
    609  *
    610  * NOTES
    611  *     exported by ordinal
    612  */
    613 void WINAPI ExitWindowsDialog (HWND hWndOwner)
    614 {
    615         TRACE("(0x%08x)\n", hWndOwner);
    616         if (MessageBoxA( hWndOwner, "Do you want to exit Odin?", "Shutdown", MB_YESNO|MB_ICONQUESTION) == IDYES)
    617         { SendMessageA ( hWndOwner, WM_QUIT, 0, 0);
    618         }
    619 }
     358ODINFUNCTION5(HRESULT,      SHDoDragDrop,
     359              HWND,         hWnd,
     360              LPDATAOBJECT, lpDataObject,
     361              LPDROPSOURCE, lpDropSource,
     362              DWORD,        dwOKEffect,
     363              LPDWORD,      pdwEffect)
     364{
     365  dprintf(("SHELL32: SHDoDragDrop not implemented"));
     366  return 0;
     367}
     368
    620369
    621370/*************************************************************************
    … …  
    623372 *
    624373 */
    625 DWORD WINAPI
    626 ArrangeWindows (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3,
    627                 DWORD dwParam4, DWORD dwParam5)
    628 {
    629     FIXME("(0x%lx 0x%lx 0x%lx 0x%lx 0x%lx):stub.\n",
    630            dwParam1, dwParam2, dwParam3, dwParam4, dwParam5);
    631     return 0;
     374ODINFUNCTION5(WORD,        ArrangeWindows,
     375              HWND,        hwndParent,
     376              DWORD,       dwReserved,
     377              LPCRECT,     lpRect,
     378              WORD,        cKids,
     379              CONST HWND*, lpKids)
     380{
     381  dprintf(("SHELL32: ArrangeWindows not implemented"));
     382  return 0;
    632383}
    633384
    … …  
    664415        }
    665416  return 0;
    666 }
    667 /*************************************************************************
    668  * SHFileOperation                              [SHELL32.242]
    669  *
    670  */
    671 DWORD WINAPI SHFileOperationAW(DWORD x)
    672 {       FIXME("0x%08lx stub\n",x);
    673         return 0;
    674 
    675 }
    676 
    677 /*************************************************************************
    678  * SHFileOperationA                             [SHELL32.243]
    679  *
    680  * NOTES
    681  *     exported by name
    682  */
    683 DWORD WINAPI SHFileOperationA (LPSHFILEOPSTRUCTA lpFileOp)
    684 { FIXME("(%p):stub.\n", lpFileOp);
    685   return 1;
    686 }
    687 /*************************************************************************
    688  * SHFileOperationW                             [SHELL32.244]
    689  *
    690  * NOTES
    691  *     exported by name
    692  */
    693 DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp)
    694 { FIXME("(%p):stub.\n", lpFileOp);
    695   return 1;
    696417}
    697418
    … …  
    716437 *  see IShellFolder::CreateViewObject
    717438 */
    718 HRESULT WINAPI SHCreateShellFolderViewEx(
    719   LPSHELLVIEWDATA psvcbi, /*[in ] shelltemplate struct*/
    720   LPVOID* ppv)            /*[out] IShellView pointer*/
    721 {
    722         IShellView * psf;
    723         HRESULT hRes;
    724 
    725         TRACE("sf=%p pidl=%p cb=%p mode=0x%08lx parm=0x%08lx\n",
    726           psvcbi->pShellFolder, psvcbi->pidl, psvcbi->pCallBack, psvcbi->viewmode, psvcbi->dwUserParam);
    727 
    728         psf = IShellView_Constructor(psvcbi->pShellFolder);
    729 
    730         if (!psf)
    731           return E_OUTOFMEMORY;
    732 
    733         IShellView_AddRef(psf);
    734         hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
    735         IShellView_Release(psf);
    736 
    737         return hRes;
     439ODINFUNCTION2(HRESULT, SHCreateShellFolderViewEx,
     440              LPCSHELLFOLDERVIEWINFO, pshfvi,
     441              LPSHELLVIEW*, ppshv)
     442{
     443  IShellView * psf;
     444  HRESULT hRes;
     445
     446  psf = IShellView_Constructor(pshfvi->pshf);
     447
     448  if (!psf)
     449    return E_OUTOFMEMORY;
     450
     451  IShellView_AddRef(psf);
     452  hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppshv);
     453  IShellView_Release(psf);
     454
     455  return hRes;
    738456}
    739457/*************************************************************************
    … …  
    831549              pv = SHLockShared(hmem,0);
    832550              sprintf(szPidl,":%p",pv );
    833               SHUnlockShared((HANDLE)pv);
     551              SHUnlockShared(pv);
    834552
    835553              gap = strlen(szPidl);
    … …  
    947665 *  exported by name
    948666 */
    949 HRESULT WINAPI SHFreeUnusedLibraries (void)
    950 {       FIXME("stub\n");
    951         return TRUE;
     667ODINPROCEDURE0(SHFreeUnusedLibraries)
     668{
     669  dprintf(("SHELL32: SHFreeUnusedLibraries not implemented"));
    952670}
    953671/*************************************************************************
    … …  
    957675 *  exported by name
    958676 */
    959 HRESULT WINAPI DAD_SetDragImage (DWORD u, DWORD v)
    960 { FIXME("0x%08lx 0x%08lx stub\n",u, v);
     677ODINFUNCTION2(BOOL, DAD_SetDragImage,
     678              HIMAGELIST, himlTrack,
     679              LPPOINT, lppt)
     680{
     681  dprintf(("SHELL32: DAD_SetDragImage not implemented"));
    961682  return 0;
    962683}
    … …  
    967688 *  exported by name
    968689 */
    969 HRESULT WINAPI DAD_ShowDragImage (DWORD u)
    970 { FIXME("0x%08lx stub\n",u);
     690ODINFUNCTION1(BOOL, DAD_ShowDragImage,
     691              BOOL, bShow)
     692{
     693  dprintf(("SHELL32: DAD_ShowDragImage not implemented"));
    971694  return 0;
    972 }
    973 /*************************************************************************
    974  * SHRegCloseKey                        [NT4.0:SHELL32.505]
    975  *
    976  */
    977 HRESULT WINAPI SHRegCloseKey (HKEY hkey)
    978 {       TRACE("0x%04x\n",hkey);
    979         return RegCloseKey( hkey );
    980 }
    981 /*************************************************************************
    982  * SHRegOpenKeyA                                [SHELL32.506]
    983  *
    984  */
    985 HRESULT WINAPI SHRegOpenKeyA(HKEY hKey, LPSTR lpSubKey, LPHKEY phkResult)
    986 {
    987         TRACE("(0x%08x, %s, %p)\n", hKey, debugstr_a(lpSubKey), phkResult);
    988         return RegOpenKeyA(hKey, lpSubKey, phkResult);
    989 }
    990 
    991 /*************************************************************************
    992  * SHRegOpenKeyW                                [NT4.0:SHELL32.507]
    993  *
    994  */
    995 HRESULT WINAPI SHRegOpenKeyW (HKEY hkey, LPCWSTR lpszSubKey, LPHKEY retkey)
    996 {       WARN("0x%04x %s %p\n",hkey,debugstr_w(lpszSubKey),retkey);
    997         return RegOpenKeyW( hkey, lpszSubKey, retkey );
    998 }
    999 /*************************************************************************
    1000  * SHRegQueryValueExA                           [SHELL32.509]
    1001  *
    1002  */
    1003 HRESULT WINAPI SHRegQueryValueExA(
    1004         HKEY hkey,
    1005         LPSTR lpValueName,
    1006         LPDWORD lpReserved,
    1007         LPDWORD lpType,
    1008         LPBYTE lpData,
    1009         LPDWORD lpcbData)
    1010 {
    1011         TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
    1012         return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
    1013 }
    1014 /*************************************************************************
    1015  * SHRegQueryValueW                             [NT4.0:SHELL32.510]
    1016  *
    1017  */
    1018 HRESULT WINAPI SHRegQueryValueW (HKEY hkey, LPWSTR lpszSubKey,
    1019                                  LPWSTR lpszData, LPDWORD lpcbData )
    1020 {       WARN("0x%04x %s %p %p semi-stub\n",
    1021                 hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
    1022         return RegQueryValueW( hkey, lpszSubKey, lpszData, (LPLONG)lpcbData );
    1023 }
    1024 
    1025 /*************************************************************************
    1026  * SHRegQueryValueExW                           [NT4.0:SHELL32.511]
    1027  *
    1028  * FIXME
    1029  *  if the datatype REG_EXPAND_SZ then expand the string and change
    1030  *  *pdwType to REG_SZ.
    1031  */
    1032 HRESULT WINAPI SHRegQueryValueExW (HKEY hkey, LPWSTR pszValue, LPDWORD pdwReserved,
    1033                  LPDWORD pdwType, LPVOID pvData, LPDWORD pcbData)
    1034 {       DWORD ret;
    1035         WARN("0x%04x %s %p %p %p %p semi-stub\n",
    1036                 hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
    1037         ret = RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, (LPBYTE)pvData, pcbData);
    1038         return ret;
    1039695}
    1040696
    … …  
    1084740}
    1085741
    1086 HRESULT WINAPI StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    1087 {
    1088         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    1089 
    1090         switch (src->uType)
    1091         {
    1092           case STRRET_WSTR:
    1093             WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
    1094             SHFree(src->u.pOleStr);
    1095             break;
    1096 
    1097           case STRRET_CSTRA:
    1098             lstrcpynA((LPSTR)dest, src->u.cStr, len);
    1099             break;
    1100 
    1101           case STRRET_OFFSETA:
    1102             lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
    1103             break;
    1104 
    1105           default:
    1106             FIXME("unknown type!\n");
    1107             if (len)
    1108             {
    1109               *(LPSTR)dest = '\0';
    1110             }
    1111             return(FALSE);
    1112         }
    1113         return S_OK;
    1114 }
    1115 
    1116742HRESULT WINAPI StrRetToBufW (LPSTRRET src, LPITEMIDLIST pidl, LPWSTR dest, DWORD len)
    1117743{
    … …  
    1119745}
    1120746
    1121 HRESULT WINAPI StrRetToStrNW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    1122 {
    1123         TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
    1124 
    1125         switch (src->uType)
    1126         {
    1127           case STRRET_WSTR:
    1128             lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
    1129             SHFree(src->u.pOleStr);
    1130             break;
    1131 
    1132           case STRRET_CSTRA:
    1133             lstrcpynAtoW((LPWSTR)dest, src->u.cStr, len);
    1134             break;
    1135 
    1136           case STRRET_OFFSETA:
    1137             if (pidl)
    1138             {
    1139               lstrcpynAtoW((LPWSTR)dest, ((LPSTR)&pidl->mkid)+src->u.uOffset, len);
    1140             }
    1141             break;
    1142 
    1143           default:
    1144             FIXME("unknown type!\n");
    1145             if (len)
    1146             { *(LPSTR)dest = '\0';
    1147             }
    1148             return(FALSE);
    1149         }
    1150         return S_OK;
    1151 }
    1152 HRESULT WINAPI StrRetToStrNAW (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
    1153 {
    1154         if(VERSION_OsIsUnicode())
    1155           return StrRetToStrNW (dest, len, src, pidl);
    1156         return StrRetToStrNA (dest, len, src, pidl);
    1157 }
    1158747
    1159748/*************************************************************************
    … …  
    1257846 *  parameter1 is return value from SHLockShared
    1258847 */
    1259 BOOL WINAPI SHUnlockShared(HANDLE pmem)
    1260 {       TRACE("handle=0x%04x\n",pmem);
    1261         return GlobalUnlock(pmem);
     848ODINFUNCTION1(BOOL, SHUnlockShared,
     849              LPVOID, pv)
     850{       
     851  TRACE("handle=0x%08x\n",pv);
     852  //@@@PH rather VirtualUnlock ?
     853  return GlobalUnlock((HANDLE)pv);
    1262854}
    1263855/*************************************************************************
    … …  
    1309901 *
    1310902 */
    1311 HRESULT WINAPI SHOutOfMemoryMessageBox(DWORD u, DWORD v, DWORD w)
    1312 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
    1313         return 0;
     903ODINFUNCTION3(int,    SHOutOfMemoryMessageBox,
     904              HWND,   hwndOwner,
     905              LPCSTR, lpCaption,
     906              UINT,   uType)
     907{
     908  dprintf(("SHELL32: SHOutOfMemoryMessageBox not implemented."));
     909  return 0;
    1314910}
    1315911/*************************************************************************
    … …  
    14081004 *
    14091005 */
    1410 HRESULT WINAPI SHWaitForFileToOpen(DWORD u, DWORD v, DWORD w)
    1411 {       FIXME("0x%04lx 0x%04lx 0x%04lx stub\n",u,v,w);
    1412         return 0;
     1006ODINFUNCTION3(BOOL, SHWaitForFileToOpen,
     1007              LPCITEMIDLIST, pidl,
     1008              DWORD, dwFlags,
     1009              DWORD, dwTimeout)
     1010{
     1011  dprintf(("SHELL32: SHWaitForFileToOpen not implemented"));
     1012  return 0;
    14131013}
    14141014/*************************************************************************
    … …  
    14521052        return 0;
    14531053}
    1454 /************************************************************************
    1455  *      StrToOleStr                     [SHELL32.163]
    1456  *
    1457  */
    1458 int WINAPI StrToOleStrA (LPWSTR lpWideCharStr, LPCSTR lpMultiByteString)
    1459 {
    1460         TRACE("%p %p(%s)\n",
    1461         lpWideCharStr, lpMultiByteString, lpMultiByteString);
    1462 
    1463         return MultiByteToWideChar(0, 0, lpMultiByteString, -1, lpWideCharStr, MAX_PATH);
    1464 
    1465 }
    1466 int WINAPI StrToOleStrW (LPWSTR lpWideCharStr, LPCWSTR lpWString)
    1467 {
    1468         TRACE("%p %p(%s)\n",
    1469         lpWideCharStr, lpWString, debugstr_w(lpWString));
    1470 
    1471         if (lstrcpyW (lpWideCharStr, lpWString ))
    1472         { return lstrlenW (lpWideCharStr);
    1473         }
    1474         return 0;
    1475 }
    1476 
    1477 BOOL WINAPI StrToOleStrAW (LPWSTR lpWideCharStr, LPCVOID lpString)
    1478 {
    1479         if (VERSION_OsIsUnicode())
    1480           return StrToOleStrW (lpWideCharStr, (LPCWSTR)lpString);
    1481         return StrToOleStrA (lpWideCharStr, (LPCSTR)lpString);
    1482 }
    14831054
    14841055/************************************************************************
    … …  
    15261097{
    15271098  return FALSE;
    1528 }
    1529 
    1530 /************************************************************************
    1531  *      Win32DeleteFile                         [SHELL32.164]
    1532  *
    1533  * Deletes a file.  Also triggers a change notify if one exists, but
    1534  * that mechanism doesn't yet exist in Wine's SHELL32.
    1535  *
    1536  * FIXME:
    1537  * Verified on Win98 / IE 5 (SHELL32 4.72, March 1999 build) to be
    1538  * ANSI.  Is this Unicode on NT?
    1539  *
    1540  */
    1541 
    1542 BOOL WINAPI Win32DeleteFile(LPSTR fName)
    1543 {
    1544   dprintf(("SHELL32:SHELLORD:Win32DeleteFile %p(%s): partial stub\n", fName, fName));
    1545 
    1546   DeleteFileA(fName);
    1547 
    1548   return TRUE;
    15491099}
    15501100

  • trunk/src/shell32/shellpath.cpp

    r3551 r4032  
    1 /* $Id: shellpath.cpp,v 1.10 2000-05-18 14:16:04 sandervl Exp $ */
     1/* $Id: shellpath.cpp,v 1.11 2000-08-18 02:01:23 phaller Exp $ */
    22
    33/*
    … …  
    4848ODINDEBUGCHANNEL(SHELL32-SHELLPATH)
    4949
    50 /*************************************************************************
    51  * SheGetDirW [SHELL32.281]
    52  *
    53  */
    54 ODINFUNCTION2(HRESULT, SheGetDirW,
    55               LPWSTR, u,
    56               LPWSTR, v)
    57 {  FIXME("%p %p stub\n",u,v);
    58    return 0;
    59 }
    60 
    61 /*************************************************************************
    62  * SheChangeDirW [SHELL32.274]
    63  *
    64  */
    65 ODINFUNCTION1(HRESULT, SheChangeDirW,
    66               LPWSTR, u)
    67 {  FIXME("(%s),stub\n",debugstr_w(u));
    68    return 0;
    69 }

  • trunk/src/shell32/shlfolder.cpp

    r3646 r4032  
    1 /* $Id: shlfolder.cpp,v 1.14 2000-06-01 14:01:10 sandervl Exp $ */
     1/* $Id: shlfolder.cpp,v 1.15 2000-08-18 02:01:23 phaller Exp $ */
    22/*
    33 * Shell Folder stuff
    … …  
    3232#include "shresdef.h"
    3333#include "shlwapi.h"
     34
     35#include "initguid.h"
     36#include "shellfolder.h"
    3437
    3538#include <heapstring.h>
    … …  
    286289
    287290   ICOM_VTABLE(IShellFolder2)*           lpvtblShellFolder;
    288    ICOM_VTABLE(IPersistFolder)*          lpvtblPersistFolder;
     291   ICOM_VTABLE(IPersistFolder2)*         lpvtblPersistFolder2;
    289292   ICOM_VTABLE(IDropTarget)*             lpvtblDropTarget;
     293   ICOM_VTABLE(ISFHelper)*               lpvtblSFHelper;
    290294
    291295   IUnknown                     *pUnkOuter;     /* used for aggregation */
    … …  
    302306extern struct ICOM_VTABLE(IUnknown) unkvt;
    303307extern struct ICOM_VTABLE(IShellFolder2) sfvt;
    304 extern struct ICOM_VTABLE(IPersistFolder) psfvt;
     308extern struct ICOM_VTABLE(IPersistFolder2) psfvt;
    305309extern struct ICOM_VTABLE(IDropTarget) dtvt;
     310extern struct ICOM_VTABLE(ISFHelper) shvt;
    306311
    307312static IShellFolder * ISF_MyComputer_Constructor(void);
    … …  
    310315#define _ICOM_THIS_From_IShellFolder2(class, name) class* This = (class*)(((char*)name)-_IShellFolder2_Offset);
    311316
    312 #define _IPersistFolder_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblPersistFolder)))
    313 #define _ICOM_THIS_From_IPersistFolder(class, name) class* This = (class*)(((char*)name)-_IPersistFolder_Offset);
     317#define _IPersistFolder_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblPersistFolder2)))
     318#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder_Offset);
    314319
    315320#define _IDropTarget_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblDropTarget)))
    316321#define _ICOM_THIS_From_IDropTarget(class, name) class* This = (class*)(((char*)name)-_IDropTarget_Offset);
    317322
     323#define _ISFHelper_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblSFHelper)))
     324#define _ICOM_THIS_From_ISFHelper(class, name) class* This = (class*)(((char*)name)-_ISFHelper_Offset);
    318325/*
    319326  converts This to a interface pointer
    … …  
    322329#define _IShellFolder_(This)    (IShellFolder*)&(This->lpvtblShellFolder)
    323330#define _IShellFolder2_(This)   (IShellFolder2*)&(This->lpvtblShellFolder)
    324 #define _IPersist_(This)        (IPersist*)&(This->lpvtblPersistFolder)
    325 #define _IPersistFolder_(This)  (IPersistFolder*)&(This->lpvtblPersistFolder)
     331#define _IPersist_(This)        (IPersist*)&(This->lpvtblPersistFolder2)
     332#define _IPersistFolder_(This)  (IPersistFolder*)&(This->lpvtblPersistFolder2)
     333#define _IPersistFolder2_(This)  (IPersistFolder2*)&(This->lpvtblPersistFolder2)
    326334#define _IDropTarget_(This)     (IDropTarget*)&(This->lpvtblDropTarget)
     335#define _ISFHelper_(This)       (ISFHelper*)&(This->lpvtblSFHelper)
    327336
    328337/**************************************************************************
    … …  
    363372        else if(IsEqualIID(riid, &IID_IPersist))        *ppvObj = _IPersist_(This);
    364373        else if(IsEqualIID(riid, &IID_IPersistFolder))  *ppvObj = _IPersistFolder_(This);
     374        else if(IsEqualIID(riid, &IID_IPersistFolder2)) *ppvObj = _IPersistFolder2_(This);
     375        else if(IsEqualIID(riid, &IID_ISFHelper))       *ppvObj = _ISFHelper_(This);
    365376        else if(IsEqualIID(riid, &IID_IDropTarget))
    366377        {
    … …  
    467478            ICOM_VTBL(sf)=&unkvt;
    468479            sf->lpvtblShellFolder=&sfvt;
    469             sf->lpvtblPersistFolder=&psfvt;
     480            sf->lpvtblPersistFolder2=&psfvt;
    470481            sf->lpvtblDropTarget=&dtvt;
    471482            sf->pclsid = (CLSID*)&CLSID_SFFile;
    … …  
    504515   ICOM_VTBL(sf)=&unkvt;
    505516   sf->lpvtblShellFolder=&sfvt;
    506    sf->lpvtblPersistFolder=&psfvt;
     517   sf->lpvtblPersistFolder2=&psfvt;
    507518   sf->lpvtblDropTarget=&dtvt;
    508519   sf->pclsid = (CLSID*)&CLSID_SFFile;
    … …  
    539550
    540551       len = strlen(sf->sMyPath);
    541        _ILSimpleGetText(pidl, sf->sMyPath + len, dwSize - len + 1);
     552       _ILSimpleGetText(pidl, sf->sMyPath + len, dwSize - len + 2);
    542553     }
    543554
    … …  
    668679       else
    669680       {
    670           hr = S_OK;
     681         hr = S_OK;
     682         
     683         if (pdwAttributes && *pdwAttributes)
     684         {
     685           SHELL32_GetItemAttributes(_IShellFolder_(This), pidlTemp, pdwAttributes);
     686         }
    671687       }
    672688     }
    … …  
    761777       }
    762778   }
    763    else
     779   else if(_ILIsFolder(pidl))
    764780   {
    765781     LPITEMIDLIST pidltemp = ILCloneFirst(pidl);
    766782     pShellFolder = IShellFolder_Constructor(iface, pidltemp);
    767783     ILFree(pidltemp);
     784   }
     785   else
     786   {
     787     ERR("can't bind to a file\n");
     788     return E_FAIL;
    768789   }
    769790
    … …  
    10531074     if(IsEqualIID(riid, &IID_IContextMenu) && (cidl >= 1))
    10541075     {
    1055        pObj  = (LPUNKNOWN)IContextMenu_Constructor((IShellFolder *)iface, This->absPidl, apidl, cidl);
     1076       pObj  = (LPUNKNOWN)ISvItemCm_Constructor((IShellFolder *)iface, This->absPidl, apidl, cidl);
    10561077       hr = S_OK;
    10571078     }
    … …  
    11711192   LPCITEMIDLIST pidl, /*simple pidl*/
    11721193   LPCOLESTR lpName,
    1173    DWORD dw,
     1194   DWORD dwFlags,
    11741195   LPITEMIDLIST *pPidlOut)
    11751196{
    11761197   _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
    1177 
    1178    FIXME("(%p)->(%u,pidl=%p,%s,%lu,%p),stub!\n",
    1179    This,hwndOwner,pidl,debugstr_w(lpName),dw,pPidlOut);
    1180 
    1181    return E_NOTIMPL;
     1198 
     1199        char szSrc[MAX_PATH], szDest[MAX_PATH];
     1200        int len;
     1201        BOOL bIsFolder = _ILIsFolder(ILFindLastID(pidl));
     1202
     1203        TRACE("(%p)->(%u,pidl=%p,%s,%lu,%p)\n",
     1204          This,hwndOwner,pidl,debugstr_w(lpName),dwFlags,pPidlOut);
     1205
     1206        /* build source path */
     1207        if (dwFlags & SHGDN_INFOLDER)
     1208        {
     1209          strcpy(szSrc, This->sMyPath);
     1210          PathAddBackslashA(szSrc);
     1211          len = strlen (szSrc);
     1212          _ILSimpleGetText(pidl, szSrc+len, MAX_PATH-len);
     1213        }
     1214        else
     1215        {
     1216          SHGetPathFromIDListA(pidl, szSrc);
     1217        }
     1218
     1219        /* build destination path */
     1220        strcpy(szDest, This->sMyPath);
     1221        PathAddBackslashA(szDest);
     1222        len = strlen (szDest);
     1223        lstrcpynWtoA(szDest+len, lpName, MAX_PATH-len);
     1224       
     1225        TRACE("src=%s dest=%s\n", szSrc, szDest);
     1226        if ( MoveFileA(szSrc, szDest) )
     1227        {
     1228          if (pPidlOut) *pPidlOut = SHSimpleIDListFromPathA(szDest);
     1229          SHChangeNotifyA( bIsFolder?SHCNE_RENAMEFOLDER:SHCNE_RENAMEITEM, SHCNF_PATHA, szSrc, szDest);
     1230          return S_OK;
     1231        }
     1232        return E_FAIL; 
    11821233}
    11831234
    … …  
    13471398};
    13481399
     1400
     1401/****************************************************************************
     1402 * ISFHelper for IShellFolder implementation
     1403 */
     1404
     1405static HRESULT WINAPI ISFHelper_fnQueryInterface(
     1406        ISFHelper *iface,
     1407        REFIID riid,
     1408        LPVOID *ppvObj)
     1409{
     1410        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
     1411
     1412        TRACE("(%p)\n", This);
     1413
     1414        return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
     1415}
     1416
     1417static ULONG WINAPI ISFHelper_fnAddRef(
     1418        ISFHelper *iface)
     1419{
     1420        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
     1421
     1422        TRACE("(%p)\n", This);
     1423
     1424        return IUnknown_AddRef(This->pUnkOuter);
     1425}
     1426
     1427static ULONG WINAPI ISFHelper_fnRelease(
     1428        ISFHelper *iface)
     1429{
     1430        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
     1431
     1432        TRACE("(%p)\n", This);
     1433
     1434        return IUnknown_Release(This->pUnkOuter);
     1435}
     1436
     1437
     1438/****************************************************************************
     1439 * ISFHelper_fnAddFolder
     1440 *
     1441 * creates a unique folder name
     1442 */
     1443
     1444static HRESULT WINAPI ISFHelper_fnGetUniqueName(
     1445        ISFHelper *iface,
     1446        LPSTR lpName,
     1447        UINT uLen)
     1448{
     1449        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
     1450        IEnumIDList * penum;
     1451        HRESULT hr;
     1452        char szText[MAX_PATH];
     1453        char * szNewFolder = "New Folder";
     1454       
     1455        TRACE("(%p)(%s %u)\n", This, lpName, uLen);
     1456
     1457        if (uLen < strlen(szNewFolder) + 4) return E_POINTER;
     1458       
     1459        strcpy(lpName, szNewFolder);
     1460       
     1461        hr = IShellFolder_fnEnumObjects(_IShellFolder2_(This), 0, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penum);
     1462        if (penum)
     1463        {
     1464          LPITEMIDLIST pidl;
     1465          DWORD dwFetched;
     1466          int i=1;
     1467         
     1468next:     IEnumIDList_Reset(penum);
     1469          while(S_OK == IEnumIDList_Next(penum, 1, &pidl, &dwFetched) && dwFetched)
     1470          {
     1471            _ILSimpleGetText(pidl, szText, MAX_PATH);
     1472            if (0 == strcmp(szText, lpName))
     1473            {
     1474              sprintf(lpName, "%s %d", szNewFolder, i++);
     1475              if (i > 99)
     1476              {
     1477                hr = E_FAIL;
     1478                break;
     1479              }
     1480              goto next;
     1481            }
     1482          }
     1483
     1484          IEnumIDList_Release(penum);
     1485        }
     1486        return hr;
     1487}
     1488       
     1489/****************************************************************************
     1490 * ISFHelper_fnAddFolder
     1491 *
     1492 * adds a new folder.
     1493 */
     1494
     1495static HRESULT WINAPI ISFHelper_fnAddFolder(
     1496        ISFHelper *iface,
     1497        HWND hwnd,
     1498        LPCSTR lpName,
     1499        LPITEMIDLIST* ppidlOut)
     1500{
     1501        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
     1502        char lpstrNewDir[MAX_PATH];
     1503        DWORD bRes;
     1504        HRESULT hres = E_FAIL;
     1505       
     1506        TRACE("(%p)(%s %p)\n", This, lpName, ppidlOut);
     1507
     1508        strcpy(lpstrNewDir, This->sMyPath);
     1509        PathAddBackslashA(lpstrNewDir);
     1510        strcat(lpstrNewDir, lpName);
     1511
     1512        bRes = CreateDirectoryA(lpstrNewDir, NULL);
     1513
     1514        if (bRes)
     1515        {
     1516          LPITEMIDLIST pidl, pidlitem;
     1517
     1518          pidlitem = SHSimpleIDListFromPathA(lpstrNewDir);
     1519
     1520          pidl = ILCombine(This->absPidl, pidlitem);
     1521          SHChangeNotifyA(SHCNE_MKDIR, SHCNF_IDLIST, pidl, NULL);
     1522          SHFree(pidl);
     1523
     1524          if (ppidlOut) *ppidlOut = pidlitem;
     1525          hres = S_OK;
     1526        }
     1527        else
     1528        {
     1529          char lpstrText[128+MAX_PATH];
     1530          char lpstrTempText[128];
     1531          char lpstrCaption[256];
     1532
     1533          /* Cannot Create folder because of permissions */
     1534          LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_DENIED, lpstrTempText, sizeof(lpstrTempText));
     1535          LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_CAPTION, lpstrCaption, sizeof(lpstrCaption));
     1536          sprintf(lpstrText,lpstrTempText, lpstrNewDir);
     1537          MessageBoxA(hwnd,lpstrText, lpstrCaption, MB_OK | MB_ICONEXCLAMATION);
     1538        }
     1539
     1540        return hres;
     1541}
     1542
     1543/****************************************************************************
     1544 * ISFHelper_fnDeleteItems
     1545 *
     1546 * deletes items in folder
     1547 */
     1548static HRESULT WINAPI ISFHelper_fnDeleteItems(
     1549        ISFHelper *iface,
     1550        UINT cidl,
     1551        LPCITEMIDLIST* apidl)
     1552{
     1553        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
     1554        int i;
     1555        char szPath[MAX_PATH];
     1556
     1557        TRACE("(%p)(%u %p)\n", This, cidl, apidl);
     1558       
     1559        for(i=0; i< cidl; i++)
     1560        {
     1561          strcpy(szPath, This->sMyPath);
     1562          PathAddBackslashA(szPath);
     1563          _ILSimpleGetText(apidl[i], szPath+strlen(szPath), MAX_PATH);
     1564
     1565          if (_ILIsFolder(apidl[i]))
     1566          {
     1567            LPITEMIDLIST pidl;
     1568
     1569            MESSAGE("delete %s\n", szPath);
     1570            if (! SHELL_DeleteDirectoryA(szPath, TRUE)) return E_FAIL;
     1571            pidl = ILCombine(This->absPidl, apidl[i]);
     1572            SHChangeNotifyA(SHCNE_RMDIR, SHCNF_IDLIST, pidl, NULL);
     1573            SHFree(pidl);
     1574          }
     1575          else if (_ILIsValue(apidl[i]))
     1576          {
     1577            LPITEMIDLIST pidl;
     1578
     1579            MESSAGE("delete %s\n", szPath);
     1580            if (! DeleteFileA(szPath)) return E_FAIL;
     1581            pidl = ILCombine(This->absPidl, apidl[i]);
     1582            SHChangeNotifyA(SHCNE_DELETE, SHCNF_IDLIST, pidl, NULL);
     1583            SHFree(pidl);
     1584          }
     1585
     1586        }
     1587        return S_OK;
     1588}
     1589
     1590/****************************************************************************
     1591 * ISFHelper_fnCopyItems
     1592 *
     1593 * copys items to this folder
     1594 */
     1595static HRESULT WINAPI ISFHelper_fnCopyItems(
     1596        ISFHelper *iface,
     1597        IShellFolder* pSFFrom,
     1598        UINT cidl,
     1599        LPCITEMIDLIST *apidl)
     1600{
     1601        int i;
     1602        IPersistFolder2 * ppf2=NULL;
     1603        char szSrcPath[MAX_PATH], szDstPath[MAX_PATH];
     1604        _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
     1605
     1606        TRACE("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
     1607
     1608        IShellFolder_QueryInterface(pSFFrom, &IID_IPersistFolder2, (LPVOID*)&ppf2);
     1609        if (ppf2)
     1610        {
     1611          LPITEMIDLIST pidl;
     1612          if (SUCCEEDED(IPersistFolder2_GetCurFolder(ppf2, &pidl)))
     1613          {
     1614            for (i=0; i<cidl; i++)
     1615            {
     1616              SHGetPathFromIDListA(pidl, szSrcPath);
     1617              PathAddBackslashA(szSrcPath);
     1618              _ILSimpleGetText(apidl[i], szSrcPath+strlen(szSrcPath), MAX_PATH);
     1619
     1620              strcpy(szDstPath, This->sMyPath);
     1621              PathAddBackslashA(szDstPath);
     1622              _ILSimpleGetText(apidl[i], szDstPath+strlen(szDstPath), MAX_PATH);
     1623              MESSAGE("would copy %s to %s\n", szSrcPath, szDstPath);
     1624            }
     1625            SHFree(pidl);
     1626          }
     1627          IPersistFolder2_Release(ppf2);
     1628        }
     1629        return S_OK;
     1630}
     1631
     1632ICOM_VTABLE(ISFHelper) shvt =
     1633{
     1634        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
     1635        ISFHelper_fnQueryInterface,
     1636        ISFHelper_fnAddRef,
     1637        ISFHelper_fnRelease,
     1638        ISFHelper_fnGetUniqueName,
     1639        ISFHelper_fnAddFolder,
     1640        ISFHelper_fnDeleteItems,
     1641        ISFHelper_fnCopyItems,
     1642};
     1643
    13491644/***********************************************************************
    13501645*  [Desktopfolder]                       IShellFolder implementation
    … …  
    14641759   {
    14651760     hr = S_OK;
     1761     
     1762     if (pdwAttributes && *pdwAttributes)
     1763     {
     1764       SHELL32_GetItemAttributes(_IShellFolder_(This), pidlTemp, pdwAttributes);
     1765     }
    14661766   }
    14671767
    … …  
    18832183   ICOM_VTBL(sf)=&unkvt;
    18842184   sf->lpvtblShellFolder=&sfmcvt;
    1885    sf->lpvtblPersistFolder = &psfvt;
     2185   sf->lpvtblPersistFolder2 = &psfvt;
    18862186   sf->pclsid = (CLSID*)&CLSID_SFMyComp;
    18872187   sf->absPidl=_ILCreateMyComputer();    /* my qualified pidl */
    … …  
    23672667 *
    23682668 */
    2369 static HRESULT WINAPI ISFPersistFolder_QueryInterface(
    2370    IPersistFolder *                      iface,
     2669static HRESULT WINAPI ISFPersistFolder2_QueryInterface(
     2670   IPersistFolder2 *                      iface,
    23712671   REFIID         iid,
    23722672   LPVOID*        ppvObj)
    23732673{
    2374    _ICOM_THIS_From_IPersistFolder(IGenericSFImpl, iface);
     2674   _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
    23752675
    23762676   TRACE("(%p)\n", This);
    … …  
    23832683 *
    23842684 */
    2385 static ULONG WINAPI ISFPersistFolder_AddRef(
    2386    IPersistFolder *                      iface)
    2387 {
    2388   _ICOM_THIS_From_IPersistFolder(IGenericSFImpl, iface);
     2685static ULONG WINAPI ISFPersistFolder2_AddRef(
     2686   IPersistFolder2 *                      iface)
     2687{
     2688  _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
    23892689
    23902690  TRACE("(%p)\n", This);
    … …  
    23972697 *
    23982698 */
    2399 static ULONG WINAPI ISFPersistFolder_Release(
    2400    IPersistFolder *                      iface)
    2401 {
    2402    _ICOM_THIS_From_IPersistFolder(IGenericSFImpl, iface);
     2699static ULONG WINAPI ISFPersistFolder2_Release(
     2700   IPersistFolder2 *                      iface)
     2701{
     2702   _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
    24032703
    24042704   TRACE("(%p)\n", This);
    … …  
    24102710 * ISFPersistFolder_GetClassID (IPersist)
    24112711 */
    2412 static HRESULT WINAPI ISFPersistFolder_GetClassID(
    2413    IPersistFolder *                      iface,
     2712static HRESULT WINAPI ISFPersistFolder2_GetClassID(
     2713   IPersistFolder2 *                      iface,
    24142714   CLSID *        lpClassId)
    24152715{
    2416    _ICOM_THIS_From_IPersistFolder(IGenericSFImpl, iface);
     2716   _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
    24172717
    24182718   TRACE("(%p)\n", This);
    … …  
    24302730 *  sMyPath is not set. Don't know how to handle in a non rooted environment.
    24312731 */
    2432 static HRESULT WINAPI ISFPersistFolder_Initialize(
    2433    IPersistFolder *                      iface,
     2732static HRESULT WINAPI ISFPersistFolder2_Initialize(
     2733   IPersistFolder2 *                     iface,
    24342734   LPCITEMIDLIST                         pidl)
    24352735{
    24362736   char sTemp[MAX_PATH];
    2437    _ICOM_THIS_From_IPersistFolder(IGenericSFImpl, iface);
     2737   _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
    24382738
    24392739  TRACE("(%p)->(%p)\n", This, pidl);
    … …  
    24662766}
    24672767
    2468 ICOM_VTABLE(IPersistFolder) psfvt =
     2768/**************************************************************************
     2769*  IPersistFolder2_fnGetCurFolder
     2770*/
     2771static HRESULT WINAPI ISFPersistFolder2_fnGetCurFolder(
     2772        IPersistFolder2 *       iface,
     2773        LPITEMIDLIST * pidl)
     2774{
     2775        _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
     2776       
     2777        TRACE("(%p)->(%p)\n",This, pidl);
     2778
     2779        if (!pidl) return E_POINTER;
     2780
     2781        *pidl = ILClone(This->absPidl);
     2782
     2783        return S_OK;
     2784}
     2785
     2786ICOM_VTABLE(IPersistFolder2) psfvt =
    24692787{
    24702788   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    2471    ISFPersistFolder_QueryInterface,
    2472    ISFPersistFolder_AddRef,
    2473    ISFPersistFolder_Release,
    2474    ISFPersistFolder_GetClassID,
    2475    ISFPersistFolder_Initialize
     2789   ISFPersistFolder2_QueryInterface,
     2790   ISFPersistFolder2_AddRef,
     2791   ISFPersistFolder2_Release,
     2792   ISFPersistFolder2_GetClassID,
     2793   ISFPersistFolder2_Initialize,
     2794   ISFPersistFolder2_fnGetCurFolder
    24762795};
    24772796
    … …  
    26092928   ISFDropTarget_Drop
    26102929};
    2611 

  • trunk/src/shell32/shlmenu.cpp

    r3243 r4032  
    1 /* $Id: shlmenu.cpp,v 1.5 2000-03-26 16:34:53 cbratschi Exp $ */
     1/* $Id: shlmenu.cpp,v 1.6 2000-08-18 02:01:25 phaller Exp $ */
    22
    33/*
    … …  
    4343#include "winversion.h"
    4444#include "shell32_main.h"
     45#include "shlguid.h"
    4546
    4647#include "pidl.h"
    … …  
    143144static int FM_InitMenuPopup(HMENU hmenu, LPITEMIDLIST pAlternatePidl)
    144145{  IShellFolder   *lpsf, *lpsf2;
    145    ULONG    ulItemAttr;
     146   ULONG    ulItemAttr = SFGAO_FOLDER;
    146147   UINT     uID, uFlags, uEnumFlags;
    147148   LPFNFMCALLBACK lpfnCallback;
    … …  
    196197      {
    197198        ILGetDisplayName( pidlTemp, sTemp);
    198         if (! (PidlToSicIndex(lpsf, pidlTemp, FALSE, (UINT*)&iIcon)))
     199        if (! (PidlToSicIndex(lpsf, pidlTemp, FALSE, 0, (UINT*)&iIcon)))
    199200          iIcon = FM_BLANK_ICON;
    200201        if ( SFGAO_FOLDER & ulItemAttr)
    … …  
    473474 * FileMenu_AppendFilesForPidl                 [SHELL32.124]
    474475 */
    475 ODINFUNCTION3(HMENU, FileMenu_AppendFilesForPidl,
     476ODINFUNCTION3(int,  FileMenu_AppendFilesForPidl,
    476477              HMENU, hmenu,
    477478              LPCITEMIDLIST, pidl,
    … …  
    519520 * FileMenu_TrackPopupMenuEx                   [SHELL32.116]
    520521 */
    521 ODINFUNCTION6(HRESULT, FileMenu_TrackPopupMenuEx,
     522ODINFUNCTION6(BOOL,    FileMenu_TrackPopupMenuEx,
    522523              HMENU, hMenu,
    523524              UINT, uFlags,

  • trunk/src/shell32/shlview.cpp

    r3792 r4032  
    1 /* $Id: shlview.cpp,v 1.14 2000-07-02 15:00:18 sandervl Exp $ */
     1/* $Id: shlview.cpp,v 1.15 2000-08-18 02:01:25 phaller Exp $ */
    22/*
    33 * ShellView
    … …  
    811811     hMenu = CreatePopupMenu();
    812812
    813      pCM = ISvBgCm_Constructor();
     813     pCM = ISvBgCm_Constructor(This->pSFParent);
    814814     IContextMenu_QueryContextMenu(pCM, hMenu, 0, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST, 0);
    815815
    … …  
    17571757   {
    17581758     case SVGIO_BACKGROUND:
    1759        *ppvOut = ISvBgCm_Constructor();
     1759       *ppvOut = ISvBgCm_Constructor(This->pSFParent);
    17601760       break;
    17611761

  • trunk/src/shell32/shpolicy.cpp

    r3243 r4032  
    1 /* $Id: shpolicy.cpp,v 1.2 2000-03-26 16:34:55 cbratschi Exp $ */
     1/* $Id: shpolicy.cpp,v 1.3 2000-08-18 02:01:26 phaller Exp $ */
    22
    33/*
    … …  
    3535#include <string.h>
    3636
     37#include "windef.h"
     38#include "wingdi.h"
     39#include "winerror.h"
     40#include "winreg.h"
     41#include "debugtools.h"
    3742#include "wine/winuser16.h"
    38 #include "shpolicy.h"
     43
     44#define SHELL_MAX_POLICIES 57
     45
     46#define SHELL_NO_POLICY 0xffffffff
     47
     48typedef struct tagPOLICYDAT
     49{
     50  DWORD polflags;        /* flags value passed to SHRestricted */
     51  LPSTR appstr;          /* application str such as "Explorer" */
     52  LPSTR keystr;          /* name of the actual registry key / policy */
     53  DWORD cache;           /* cached value or 0xffffffff for invalid */
     54} POLICYDATA, *LPPOLICYDATA;
     55
     56// #include "shpolicy.h" PH: Strange ... ?
    3957
    4058/* application strings */
    … …  
    451469  }
    452470};
     471
     472/*************************************************************************
     473 * SHRestricted                         [SHELL32.100]
     474 *
     475 * walks through policy table, queries <app> key, <type> value, returns
     476 * queried (DWORD) value, and caches it between called to SHInitRestricted
     477 * to prevent unnecessary registry access.
     478 *
     479 * NOTES
     480 *     exported by ordinal
     481 *
     482 * REFERENCES:
     483 *     MS System Policy Editor
     484 *     98Lite 2.0 (which uses many of these policy keys) http://www.98lite.net/
     485 *     "The Windows 95 Registry", by John Woram, 1996 MIS: Press
     486 */
     487DWORD WINAPI SHRestricted (DWORD pol) {
     488        char regstr[256];
     489        HKEY    xhkey;
     490        DWORD   retval, polidx, i, datsize = 4;
     491
     492        TRACE("(%08lx)\n",pol);
     493
     494        polidx = -1;
     495
     496        /* scan to see if we know this policy ID */
     497        for (i = 0; i < SHELL_MAX_POLICIES; i++)
     498        {
     499             if (pol == sh32_policy_table[i].polflags)
     500             {
     501                 polidx = i;
     502                 break;
     503             }
     504        }
     505
     506        if (polidx == -1)
     507        {
     508            /* we don't know this policy, return 0 */
     509            TRACE("unknown policy: (%08lx)\n", pol);
     510                return 0;
     511        }
     512
     513        /* we have a known policy */
     514        strcpy(regstr, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\");
     515        strcat(regstr, sh32_policy_table[polidx].appstr);
     516
     517        /* first check if this policy has been cached, return it if so */
     518        if (sh32_policy_table[polidx].cache != SHELL_NO_POLICY)
     519        {
     520            return sh32_policy_table[polidx].cache;
     521        }
     522
     523        /* return 0 and don't set the cache if any registry errors occur */
     524        retval = 0;
     525        if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
     526        {
     527            if (RegQueryValueExA(xhkey, sh32_policy_table[polidx].keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
     528            {
     529                sh32_policy_table[polidx].cache = retval;
     530            }
     531
     532        RegCloseKey(xhkey);
     533}
     534
     535        return retval;
     536}
     537
     538/*************************************************************************
     539 *      SHInitRestricted                         [SHELL32.244]
     540 *
     541 * Win98+ by-ordinal only routine called by Explorer and MSIE 4 and 5.
     542 * Inits the policy cache used by SHRestricted to avoid excess
     543 * registry access.
     544 *
     545 * INPUTS
     546 * Two inputs: one is a string or NULL.  If non-NULL the pointer
     547 * should point to a string containing the following exact text:
     548 * "Software\Microsoft\Windows\CurrentVersion\Policies".
     549 * The other input is unused.
     550 *
     551 * NOTES
     552 * If the input is non-NULL and does not point to a string containing
     553 * that exact text the routine will do nothing.
     554 *
     555 * If the text does match or the pointer is NULL, then the routine
     556 * will init SHRestricted()'s policy cache to all 0xffffffff and
     557 * returns 0xffffffff as well.
     558 *
     559 * I haven't yet run into anything calling this with inputs other than
     560 * (NULL, NULL), so I may have the inputs reversed.
     561 */
     562
     563BOOL WINAPI SHInitRestricted(LPSTR inpRegKey, LPSTR parm2)
     564{
     565     int i;
     566
     567     TRACE("(%p, %p)\n", inpRegKey, parm2);
     568
     569     /* first check - if input is non-NULL and points to the secret
     570        key string, then pass.  Otherwise return 0.
     571     */
     572
     573     if (inpRegKey != (LPSTR)NULL)
     574     {
     575         if (lstrcmpiA(inpRegKey, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies"))
     576         {
     577             /* doesn't match, fail */
     578             return 0;
     579         }
     580     }                               
     581
     582     /* check passed, init all policy cache entries with SHELL_NO_POLICY */
     583     for (i = 0; i < SHELL_MAX_POLICIES; i++)
     584     {
     585          sh32_policy_table[i].cache = SHELL_NO_POLICY;
     586     }
     587
     588     return SHELL_NO_POLICY;
     589}

  • trunk/src/shell32/shresdef.h

    r3257 r4032  
    1 /* $Id: shresdef.h,v 1.5 2000-03-28 15:28:54 cbratschi Exp $ */
     1/* $Id: shresdef.h,v 1.6 2000-08-18 02:01:27 phaller Exp $ */
    22
    33/*
    … …  
    3737#define IDS_VIEW_DETAILS        27
    3838
     39#define IDS_CREATEFOLDER_DENIED 30
     40#define IDS_CREATEFOLDER_CAPTION 31
     41#define IDS_DELETEFOLDER_TEXT   32
     42#define IDS_DELETEFOLDER_CAPTION 33
     43
    3944#define IDS_SHV_INVALID_FILENAME_TITLE 28
    4045#define IDS_SHV_INVALID_FILENAME       29

  • trunk/src/shell32/shv_bg_cmenu.cpp

    r3243 r4032  
    1 /* $Id: shv_bg_cmenu.cpp,v 1.3 2000-03-26 16:34:56 cbratschi Exp $ */
     1/* $Id: shv_bg_cmenu.cpp,v 1.4 2000-08-18 02:01:27 phaller Exp $ */
    22
    33/*
    … …  
    3131
    3232#include "pidl.h"
     33#include "shlguid.h"
    3334#include "wine/obj_base.h"
    3435#include "wine/obj_contextmenu.h"
    3536#include "wine/obj_shellbrowser.h"
    36 #include "wine/obj_shellextinit.h"
    3737
    3838#include "shell32_main.h"
     39#include "shellfolder.h"
     40#include "shell.h"
     41#include "wine/undocshell.h"
    3942
    4043#include <misc.h>
    … …  
    4851typedef struct
    4952{  ICOM_VTABLE(IContextMenu)* lpvtbl;
     53   IShellFolder* pSFParent;
    5054   DWORD    ref;
    5155} BgCmImpl;
    … …  
    119123           This));
    120124
    121    shell32_ObjCount--;
    122 
    123125   if (!--(This->ref))
    124    { TRACE(" destroying IContextMenu(%p)\n",This);
    125 
     126   {
     127     TRACE(" destroying IContextMenu(%p)\n",This);
     128     
     129     if(This->pSFParent)
     130       IShellFolder_Release(This->pSFParent);
     131     
    126132     HeapFree(GetProcessHeap(),0,This);
    127133     return 0;
    128134   }
     135 
     136   shell32_ObjCount--;
     137 
    129138   return This->ref;
    130139}
    … …  
    165174
    166175/**************************************************************************
     176* DoNewFolder
     177*/
     178static void DoNewFolder(
     179                        IContextMenu *iface,
     180                        IShellView *psv)
     181{
     182  ICOM_THIS(BgCmImpl, iface);
     183  ISFHelper * psfhlp;
     184  char szName[MAX_PATH];
     185 
     186  IShellFolder_QueryInterface(This->pSFParent, &IID_ISFHelper, (LPVOID*)&psfhlp);
     187  if (psfhlp)
     188  {
     189    LPITEMIDLIST pidl;
     190    ISFHelper_GetUniqueName(psfhlp, szName, MAX_PATH);
     191    ISFHelper_AddFolder(psfhlp, 0, szName, &pidl);
     192   
     193    if(psv)
     194    {
     195    /* if we are in a shellview do labeledit */
     196      IShellView_SelectItem(psv,
     197                            pidl,(SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE
     198                                  |SVSI_FOCUSED|SVSI_SELECT));
     199    }
     200    SHFree(pidl);
     201   
     202    ISFHelper_Release(psfhlp);
     203  }
     204}
     205
     206/**************************************************************************
     207* DoPaste
     208*/
     209static BOOL DoPaste(
     210                    IContextMenu *iface)
     211{
     212  ICOM_THIS(BgCmImpl, iface);
     213  BOOL bSuccess = FALSE;
     214  IDataObject * pda;
     215 
     216  TRACE("\n");
     217 
     218  if(SUCCEEDED(pOleGetClipboard(&pda)));
     219  {
     220    STGMEDIUM medium;
     221    FORMATETC formatetc;
     222   
     223    TRACE("pda=%p\n", pda);
     224   
     225    /* Set the FORMATETC structure*/
     226    InitFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
     227   
     228    /* Get the pidls from IDataObject */
     229    if(SUCCEEDED(IDataObject_GetData(pda,&formatetc,&medium)))
     230    {
     231      LPITEMIDLIST * apidl;
     232      LPITEMIDLIST pidl;
     233      IShellFolder *psfFrom = NULL, *psfDesktop;
     234     
     235      LPCIDA lpcida = (LPCIDA)GlobalLock(medium.u.hGlobal);
     236      TRACE("cida=%p\n", lpcida);
     237     
     238      apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
     239     
     240      /* bind to the source shellfolder */
     241      SHGetDesktopFolder(&psfDesktop);
     242      if(psfDesktop)
     243      {
     244        IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (LPVOID*)&psfFrom);
     245        IShellFolder_Release(psfDesktop);
     246      }
     247     
     248      if (psfFrom)
     249      {
     250      /* get source and destination shellfolder */
     251        ISFHelper *psfhlpdst, *psfhlpsrc;
     252        IShellFolder_QueryInterface(This->pSFParent, &IID_ISFHelper, (LPVOID*)&psfhlpdst);
     253        IShellFolder_QueryInterface(psfFrom, &IID_ISFHelper, (LPVOID*)&psfhlpsrc);
     254       
     255        /* do the copy/move */
     256        if (psfhlpdst && psfhlpsrc)
     257        {
     258          ISFHelper_CopyItems(psfhlpdst, psfFrom, lpcida->cidl, apidl);
     259          /* fixme handle move
     260          ISFHelper_DeleteItems(psfhlpsrc, lpcida->cidl, apidl);
     261          */
     262        }
     263        if(psfhlpdst) ISFHelper_Release(psfhlpdst);
     264        if(psfhlpsrc) ISFHelper_Release(psfhlpsrc);
     265        IShellFolder_Release(psfFrom);
     266      }
     267     
     268      _ILFreeaPidl(apidl, lpcida->cidl);
     269      SHFree(pidl);
     270     
     271      /* release the medium*/
     272      pReleaseStgMedium(&medium);
     273    }
     274    IDataObject_Release(pda);
     275  }
     276#if 0
     277  HGLOBAL  hMem;
     278 
     279  OpenClipboard(NULL);
     280  hMem = GetClipboardData(CF_HDROP);
     281 
     282  if(hMem)
     283  {
     284    char * pDropFiles = (char *)GlobalLock(hMem);
     285    if(pDropFiles)
     286    {
     287      int len, offset = sizeof(DROPFILESTRUCT);
     288     
     289      while( pDropFiles[offset] != 0)
     290      {
     291        len = strlen(pDropFiles + offset);
     292        TRACE("%s\n", pDropFiles + offset);
     293        offset += len+1;
     294      }
     295    }
     296    GlobalUnlock(hMem);
     297  }
     298  CloseClipboard();
     299#endif
     300  return bSuccess;
     301}
     302
     303
     304/**************************************************************************
    167305* ISVBgCm_fnInvokeCommand()
    168306*/
    … …  
    184322
    185323   /* get the active IShellView */
    186    lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER,0,0);
    187    IShellBrowser_QueryActiveShellView(lpSB, &lpSV);
    188    IShellView_GetWindow(lpSV, &hWndSV);
    189 
    190    if(HIWORD(lpcmi->lpVerb))
    191    {
    192      TRACE("%s\n",lpcmi->lpVerb);
    193 
    194      if (! strcmp(lpcmi->lpVerb,CMDSTR_NEWFOLDERA))
    195      {
    196        FIXME("%s not implemented\n",lpcmi->lpVerb);
    197      }
    198      else if (! strcmp(lpcmi->lpVerb,CMDSTR_VIEWLISTA))
    199      {
    200        SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(FCIDM_SHVIEW_LISTVIEW,0),0 );
    201      }
    202      else if (! strcmp(lpcmi->lpVerb,CMDSTR_VIEWDETAILSA))
    203      {
    204        SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(FCIDM_SHVIEW_REPORTVIEW,0),0 );
    205      }
    206      else
    207      {
    208        FIXME("please report: unknown verb %s\n",lpcmi->lpVerb);
    209      }
    210    }
    211    else
    212    {
    213      /* if it's a id just pass it to the parent shv */
    214      SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(LOWORD(lpcmi->lpVerb), 0),0 );
    215    }
    216 
    217    IShellView_Release(lpSV);             /* QueryActiveShellView does AddRef*/
    218    return NOERROR;
     324  if((lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER,0,0)))
     325  {
     326    if(SUCCEEDED(IShellBrowser_QueryActiveShellView(lpSB, &lpSV)))
     327    {
     328      IShellView_GetWindow(lpSV, &hWndSV);
     329    }
     330  }
     331
     332  if(lpSV)
     333  {
     334    if(HIWORD(lpcmi->lpVerb))
     335    {
     336      TRACE("%s\n",lpcmi->lpVerb);
     337
     338      if (! strcmp(lpcmi->lpVerb,CMDSTR_NEWFOLDERA))
     339      {
     340        DoNewFolder(iface, lpSV);
     341      }
     342      else if (! strcmp(lpcmi->lpVerb,CMDSTR_VIEWLISTA))
     343      {
     344        if(hWndSV) SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(FCIDM_SHVIEW_LISTVIEW,0),0 );
     345      }
     346      else if (! strcmp(lpcmi->lpVerb,CMDSTR_VIEWDETAILSA))
     347      {
     348        if(hWndSV) SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(FCIDM_SHVIEW_REPORTVIEW,0),0 );
     349      }
     350      else
     351      {
     352        FIXME("please report: unknown verb %s\n",lpcmi->lpVerb);
     353      }
     354    }
     355    else
     356    {
     357      switch(LOWORD(lpcmi->lpVerb))
     358      {
     359      case FCIDM_SHVIEW_NEWFOLDER:
     360        DoNewFolder(iface, lpSV);
     361        break;
     362      case FCIDM_SHVIEW_INSERT:
     363        DoPaste(iface);
     364        break;
     365      default:
     366      /* if it's a id just pass it to the parent shv */
     367        SendMessageA(hWndSV, WM_COMMAND, MAKEWPARAM(LOWORD(lpcmi->lpVerb), 0),0 );
     368        break;
     369      }
     370    }
     371
     372    IShellView_Release(lpSV);             /* QueryActiveShellView does AddRef*/
     373  }
     374  return NOERROR;
    219375}
    220376
    … …  
    300456*   ISVBgCm_Constructor()
    301457*/
    302 IContextMenu *ISvBgCm_Constructor(void)
     458IContextMenu *ISvBgCm_Constructor(IShellFolder* pSFParent)
    303459{
    304460   BgCmImpl* cm;
    … …  
    307463   cm->lpvtbl=&cmvt;
    308464   cm->ref = 1;
     465   cm->pSFParent = pSFParent;
    309466
    310467  dprintf(("SHELL32:shv_bg_cmenu: ISVBgCm_Constructor(%p)\n",
Note: See TracChangeset for help on using the changeset viewer.