git.oblomov.eu Git - wine/blob - dlls/shell32/shlfolder.c

   1 /*
   2  *      Shell Folder stuff
   3  *
   4  *      Copyright 1997  Marcus Meissner
   5  *      Copyright 1998, 1999    Juergen Schmied
   6  *
   7  *      IShellFolder2 and related interfaces
   8  *
   9  */
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <stdio.h>
  14
  15 #include "debugtools.h"
  16 #include "winerror.h"
  17
  18 #include "oleidl.h"
  19 #include "shlguid.h"
  20
  21 #include "pidl.h"
  22 #include "wine/obj_base.h"
  23 #include "wine/obj_dragdrop.h"
  24 #include "wine/obj_shellfolder.h"
  25 #include "wine/undocshell.h"
  26 #include "shell32_main.h"
  27 #include "shresdef.h"
  28 #include "shlwapi.h"
  29
  30 #define INITGUID
  31 #include "initguid.h"
  32 #include "shellfolder.h"
  33
  34
  35 DEFAULT_DEBUG_CHANNEL(shell)
  36
  37
  38 /***************************************************************************
  39  * debughelper: print out the return adress
  40  *  helps especially to track down unbalanced AddRef/Release
  41  */
  42 #define MEM_DEBUG 0
  43
  44 #if MEM_DEBUG
  45 #define _CALL_TRACE TRACE("called from: 0x%08x\n", *( ((UINT*)&iface)-1 ));
  46 #else
  47 #define _CALL_TRACE
  48 #endif
  49
  50 typedef struct
  51 {
  52         int     colnameid;
  53         int     pcsFlags;
  54         int     fmt;
  55         int     cxChar;
  56
  57 } shvheader;
  58
  59 /***************************************************************************
  60  *  GetNextElement (internal function)
  61  *
  62  * gets a part of a string till the first backslash
  63  *
  64  * PARAMETERS
  65  *  pszNext [IN] string to get the element from
  66  *  pszOut  [IN] pointer to buffer whitch receives string
  67  *  dwOut   [IN] length of pszOut
  68  *
  69  *  RETURNS
  70  *    LPSTR pointer to first, not yet parsed char
  71  */
  72
  73 static LPCWSTR GetNextElementW(LPCWSTR pszNext,LPWSTR pszOut,DWORD dwOut)
  74 {       LPCWSTR   pszTail = pszNext;
  75         DWORD dwCopy;
  76         TRACE("(%s %p 0x%08lx)\n",debugstr_w(pszNext),pszOut,dwOut);
  77
  78         *pszOut=0x0000;
  79
  80         if(!pszNext || !*pszNext)
  81           return NULL;
  82
  83         while(*pszTail && (*pszTail != (WCHAR)'\\'))
  84           pszTail++;
  85
  86         dwCopy = (WCHAR*)pszTail - (WCHAR*)pszNext + 1;
  87         lstrcpynW(pszOut, pszNext, (dwOut<dwCopy)? dwOut : dwCopy);
  88
  89         if(*pszTail)
  90            pszTail++;
  91         else
  92            pszTail = NULL;
  93
  94         TRACE("--(%s %s 0x%08lx %p)\n",debugstr_w(pszNext),debugstr_w(pszOut),dwOut,pszTail);
  95         return pszTail;
  96 }
  97
  98 static HRESULT SHELL32_ParseNextElement(
  99         HWND hwndOwner,
 100         IShellFolder2 * psf,
 101         LPITEMIDLIST * pidlInOut,
 102         LPOLESTR szNext,
 103         DWORD *pEaten,
 104         DWORD *pdwAttributes)
 105 {
 106         HRESULT         hr = E_OUTOFMEMORY;
 107         LPITEMIDLIST    pidlOut, pidlTemp = NULL;
 108         IShellFolder    *psfChild;
 109
 110         TRACE("(%p, %p, %s)\n",psf, pidlInOut ? *pidlInOut : NULL, debugstr_w(szNext));
 111
 112
 113         /* get the shellfolder for the child pidl and let it analyse further */
 114         hr = IShellFolder_BindToObject(psf, *pidlInOut, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 115
 116         if (psfChild)
 117         {
 118           hr = IShellFolder_ParseDisplayName(psfChild, hwndOwner, NULL, szNext, pEaten, &pidlOut, pdwAttributes);
 119           IShellFolder_Release(psfChild);
 120
 121           pidlTemp = ILCombine(*pidlInOut, pidlOut);
 122
 123           if (pidlOut)
 124             ILFree(pidlOut);
 125         }
 126
 127         ILFree(*pidlInOut);
 128         *pidlInOut = pidlTemp;
 129
 130         TRACE("-- pidl=%p ret=0x%08lx\n", pidlInOut? *pidlInOut: NULL, hr);
 131         return hr;
 132 }
 133
 134 /***********************************************************************
 135  *      SHELL32_CoCreateInitSF
 136  *
 137  *      creates a initialized shell folder
 138  */
 139 static HRESULT SHELL32_CoCreateInitSF (
 140         LPITEMIDLIST pidlRoot,
 141         LPITEMIDLIST pidlChild,
 142         REFCLSID clsid,
 143         REFIID iid,
 144         LPVOID * ppvOut)
 145 {
 146         HRESULT hr;
 147         LPITEMIDLIST    absPidl;
 148         IShellFolder2   *pShellFolder;
 149         IPersistFolder  *pPersistFolder;
 150
 151         TRACE("%p %p\n", pidlRoot, pidlChild);
 152
 153         *ppvOut = NULL;
 154
 155         /* we have to ask first for IPersistFolder, some special folders are expecting this */
 156         hr = SHCoCreateInstance(NULL, clsid, NULL, &IID_IPersistFolder, (LPVOID*)&pPersistFolder);
 157         if (SUCCEEDED(hr))
 158         {
 159           hr = IPersistFolder_QueryInterface(pPersistFolder, iid, (LPVOID*)&pShellFolder);
 160           if (SUCCEEDED(hr))
 161           {
 162             absPidl = ILCombine (pidlRoot, pidlChild);
 163             hr = IPersistFolder_Initialize(pPersistFolder, absPidl);
 164             IPersistFolder_Release(pPersistFolder);
 165             SHFree(absPidl);
 166             *ppvOut = pShellFolder;
 167           }
 168         }
 169
 170         TRACE("-- ret=0x%08lx\n", hr);
 171         return hr;
 172 }
 173
 174 static HRESULT SHELL32_GetDisplayNameOfChild(
 175         IShellFolder2 * psf,
 176         LPCITEMIDLIST pidl,
 177         DWORD dwFlags,
 178         LPSTR szOut,
 179         DWORD dwOutLen)
 180 {
 181         LPITEMIDLIST    pidlFirst, pidlNext;
 182         IShellFolder2 * psfChild;
 183         HRESULT         hr = E_OUTOFMEMORY;
 184         STRRET strTemp;
 185
 186         TRACE("(%p)->(pidl=%p 0x%08lx %p 0x%08lx)\n",psf,pidl,dwFlags,szOut, dwOutLen);
 187         pdump(pidl);
 188
 189         if ((pidlFirst = ILCloneFirst(pidl)))
 190         {
 191           hr = IShellFolder_BindToObject(psf, pidlFirst, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 192           if (SUCCEEDED(hr))
 193           {
 194             pidlNext = ILGetNext(pidl);
 195
 196             hr = IShellFolder_GetDisplayNameOf(psfChild, pidlNext, dwFlags | SHGDN_INFOLDER, &strTemp);
 197             if (SUCCEEDED(hr))
 198             {
 199               hr = StrRetToStrNA(szOut, dwOutLen, &strTemp, pidlNext);
 200             }
 201
 202             IShellFolder_Release(psfChild);
 203           }
 204           ILFree(pidlFirst);
 205         }
 206
 207         TRACE("-- ret=0x%08lx %s\n", hr, szOut);
 208
 209         return hr;
 210 }
 211
 212 /***********************************************************************
 213  *  SHELL32_GetItemAttributes
 214  *
 215  * NOTES
 216  * observerd values:
 217  *  folder:     0xE0000177      FILESYSTEM | HASSUBFOLDER | FOLDER
 218  *  file:       0x40000177      FILESYSTEM
 219  *  drive:      0xf0000144      FILESYSTEM | HASSUBFOLDER | FOLDER | FILESYSANCESTOR
 220  *  mycomputer: 0xb0000154      HASSUBFOLDER | FOLDER | FILESYSANCESTOR
 221  *  (seems to be default for shell extensions if no registry entry exists)
 222  *
 223  * This functions does not set flags!! It only resets flags when nessesary.
 224  */
 225 static HRESULT SHELL32_GetItemAttributes(
 226         IShellFolder * psf,
 227         LPITEMIDLIST pidl,
 228         LPDWORD pdwAttributes)
 229 {
 230         GUID const * clsid;
 231         DWORD dwAttributes;
 232
 233         TRACE("0x%08lx\n", *pdwAttributes);
 234
 235         if (*pdwAttributes & (0xcff3fe88))
 236           WARN("attribute 0x%08lx not implemented\n", *pdwAttributes);
 237         *pdwAttributes &= ~SFGAO_LINK; /* FIXME: for native filedialogs */
 238
 239         if (_ILIsDrive(pidl))
 240         {
 241           *pdwAttributes &= 0xf0000144;
 242         }
 243         else if ((clsid=_ILGetGUIDPointer(pidl)))
 244         {
 245           if (HCR_GetFolderAttributes(clsid, &dwAttributes))
 246           {
 247             *pdwAttributes &= dwAttributes;
 248           }
 249           else
 250           {
 251             *pdwAttributes &= 0xb0000154;
 252           }
 253         }
 254         else if (_ILGetDataPointer(pidl))
 255         {
 256           dwAttributes = _ILGetFileAttributes(pidl, NULL, 0);
 257           *pdwAttributes &= ~SFGAO_FILESYSANCESTOR;
 258
 259           if(( SFGAO_FOLDER & *pdwAttributes) && !(dwAttributes & FILE_ATTRIBUTE_DIRECTORY))
 260               *pdwAttributes &= ~(SFGAO_FOLDER|SFGAO_HASSUBFOLDER);
 261
 262           if(( SFGAO_HIDDEN & *pdwAttributes) && !(dwAttributes & FILE_ATTRIBUTE_HIDDEN))
 263               *pdwAttributes &= ~SFGAO_HIDDEN;
 264
 265           if(( SFGAO_READONLY & *pdwAttributes) && !(dwAttributes & FILE_ATTRIBUTE_READONLY))
 266               *pdwAttributes &= ~SFGAO_READONLY;
 267         }
 268         else
 269         {
 270           *pdwAttributes &= 0xb0000154;
 271         }
 272         TRACE("-- 0x%08lx\n", *pdwAttributes);
 273         return S_OK;
 274 }
 275
 276 /***********************************************************************
 277 *   IShellFolder implementation
 278 */
 279
 280 typedef struct
 281 {
 282         ICOM_VFIELD(IUnknown);
 283         DWORD                           ref;
 284         ICOM_VTABLE(IShellFolder2)*     lpvtblShellFolder;
 285         ICOM_VTABLE(IPersistFolder2)*   lpvtblPersistFolder2;
 286         ICOM_VTABLE(IDropTarget)*       lpvtblDropTarget;
 287         ICOM_VTABLE(ISFHelper)*         lpvtblSFHelper;
 288
 289         IUnknown                        *pUnkOuter;     /* used for aggregation */
 290
 291         CLSID*                          pclsid;
 292
 293         LPSTR                           sMyPath;
 294         LPITEMIDLIST                    absPidl;        /* complete pidl */
 295
 296         UINT            cfShellIDList;                  /* clipboardformat for IDropTarget */
 297         BOOL            fAcceptFmt;                     /* flag for pending Drop */
 298 } IGenericSFImpl;
 299
 300 static struct ICOM_VTABLE(IUnknown) unkvt;
 301 static struct ICOM_VTABLE(IShellFolder2) sfvt;
 302 static struct ICOM_VTABLE(IPersistFolder2) psfvt;
 303 static struct ICOM_VTABLE(IDropTarget) dtvt;
 304 static struct ICOM_VTABLE(ISFHelper) shvt;
 305
 306 static IShellFolder * ISF_MyComputer_Constructor(void);
 307
 308 #define _IShellFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblShellFolder)))
 309 #define _ICOM_THIS_From_IShellFolder2(class, name) class* This = (class*)(((char*)name)-_IShellFolder2_Offset);
 310
 311 #define _IPersistFolder_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblPersistFolder2)))
 312 #define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder_Offset);
 313
 314 #define _IDropTarget_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblDropTarget)))
 315 #define _ICOM_THIS_From_IDropTarget(class, name) class* This = (class*)(((char*)name)-_IDropTarget_Offset);
 316
 317 #define _ISFHelper_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblSFHelper)))
 318 #define _ICOM_THIS_From_ISFHelper(class, name) class* This = (class*)(((char*)name)-_ISFHelper_Offset);
 319 /*
 320   converts This to a interface pointer
 321 */
 322 #define _IUnknown_(This)        (IUnknown*)&(This->lpVtbl)
 323 #define _IShellFolder_(This)    (IShellFolder*)&(This->lpvtblShellFolder)
 324 #define _IShellFolder2_(This)   (IShellFolder2*)&(This->lpvtblShellFolder)
 325 #define _IPersist_(This)        (IPersist*)&(This->lpvtblPersistFolder2)
 326 #define _IPersistFolder_(This)  (IPersistFolder*)&(This->lpvtblPersistFolder2)
 327 #define _IPersistFolder2_(This) (IPersistFolder2*)&(This->lpvtblPersistFolder2)
 328 #define _IDropTarget_(This)     (IDropTarget*)&(This->lpvtblDropTarget)
 329 #define _ISFHelper_(This)       (ISFHelper*)&(This->lpvtblSFHelper)
 330 /**************************************************************************
 331 *       registers clipboardformat once
 332 */
 333 static void SF_RegisterClipFmt (IGenericSFImpl * This)
 334 {
 335         TRACE("(%p)\n", This);
 336
 337         if (!This->cfShellIDList)
 338         {
 339           This->cfShellIDList = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
 340         }
 341 }
 342
 343 /**************************************************************************
 344 *       we need a seperate IUnknown to handle aggregation
 345 *       (inner IUnknown)
 346 */
 347 static HRESULT WINAPI IUnknown_fnQueryInterface(
 348         IUnknown * iface,
 349         REFIID riid,
 350         LPVOID *ppvObj)
 351 {
 352         ICOM_THIS(IGenericSFImpl, iface);
 353
 354         _CALL_TRACE
 355         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
 356
 357         *ppvObj = NULL;
 358
 359         if(IsEqualIID(riid, &IID_IUnknown))             *ppvObj = _IUnknown_(This);
 360         else if(IsEqualIID(riid, &IID_IShellFolder))    *ppvObj = _IShellFolder_(This);
 361         else if(IsEqualIID(riid, &IID_IShellFolder2))   *ppvObj = _IShellFolder_(This);
 362         else if(IsEqualIID(riid, &IID_IPersist))        *ppvObj = _IPersist_(This);
 363         else if(IsEqualIID(riid, &IID_IPersistFolder))  *ppvObj = _IPersistFolder_(This);
 364         else if(IsEqualIID(riid, &IID_IPersistFolder2)) *ppvObj = _IPersistFolder2_(This);
 365         else if(IsEqualIID(riid, &IID_ISFHelper))       *ppvObj = _ISFHelper_(This);
 366         else if(IsEqualIID(riid, &IID_IDropTarget))
 367         {
 368           *ppvObj = _IDropTarget_(This);
 369           SF_RegisterClipFmt(This);
 370         }
 371
 372         if(*ppvObj)
 373         {
 374           IUnknown_AddRef((IUnknown*)(*ppvObj));
 375           TRACE("-- Interface = %p\n", *ppvObj);
 376           return S_OK;
 377         }
 378         TRACE("-- Interface: E_NOINTERFACE\n");
 379         return E_NOINTERFACE;
 380 }
 381
 382 static ULONG WINAPI IUnknown_fnAddRef(IUnknown * iface)
 383 {
 384         ICOM_THIS(IGenericSFImpl, iface);
 385
 386         _CALL_TRACE
 387         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 388
 389         shell32_ObjCount++;
 390         return ++(This->ref);
 391 }
 392
 393 static ULONG WINAPI IUnknown_fnRelease(IUnknown * iface)
 394 {
 395         ICOM_THIS(IGenericSFImpl, iface);
 396
 397         _CALL_TRACE
 398         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 399
 400         shell32_ObjCount--;
 401         if (!--(This->ref))
 402         {
 403           TRACE("-- destroying IShellFolder(%p)\n",This);
 404
 405           if (pdesktopfolder == _IShellFolder_(This))
 406           {
 407             pdesktopfolder=NULL;
 408             TRACE("-- destroyed IShellFolder(%p) was Desktopfolder\n",This);
 409           }
 410           if(This->absPidl) SHFree(This->absPidl);
 411           if(This->sMyPath) SHFree(This->sMyPath);
 412           HeapFree(GetProcessHeap(),0,This);
 413           return 0;
 414         }
 415         return This->ref;
 416 }
 417
 418 static ICOM_VTABLE(IUnknown) unkvt =
 419 {
 420         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 421         IUnknown_fnQueryInterface,
 422         IUnknown_fnAddRef,
 423         IUnknown_fnRelease,
 424 };
 425
 426 static shvheader GenericSFHeader [] =
 427 {
 428  { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
 429  { IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
 430  { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
 431  { IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12 },
 432  { IDS_SHV_COLUMN5, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 5 }
 433 };
 434 #define GENERICSHELLVIEWCOLUMNS 5
 435
 436 /**************************************************************************
 437 *       IShellFolder_Constructor
 438 *
 439 * NOTES
 440 *  creating undocumented ShellFS_Folder as part of an aggregation
 441 *  {F3364BA0-65B9-11CE-A9BA-00AA004AE837}
 442 *
 443 * FIXME
 444 *       when pUnkOuter = 0 then rrid = IID_IShellFolder is returned
 445 */
 446 HRESULT IFSFolder_Constructor(
 447         IUnknown * pUnkOuter,
 448         REFIID riid,
 449         LPVOID * ppv)
 450 {
 451         IGenericSFImpl *        sf;
 452         HRESULT hr = S_OK;
 453
 454         TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));
 455
 456         if(pUnkOuter && ! IsEqualIID(riid, &IID_IUnknown))
 457         {
 458           hr = CLASS_E_NOAGGREGATION;   /* forbidden by definition */
 459         }
 460         else
 461         {
 462           sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
 463           if (sf)
 464           {
 465             sf->ref=1;
 466             ICOM_VTBL(sf)=&unkvt;
 467             sf->lpvtblShellFolder=&sfvt;
 468             sf->lpvtblPersistFolder2=&psfvt;
 469             sf->lpvtblDropTarget=&dtvt;
 470             sf->lpvtblSFHelper=&shvt;
 471
 472             sf->pclsid = (CLSID*)&CLSID_SFFile;
 473             sf->pUnkOuter = pUnkOuter ? pUnkOuter : _IUnknown_(sf);
 474             *ppv = _IUnknown_(sf);
 475             hr = S_OK;
 476             shell32_ObjCount++;
 477           }
 478           else
 479           {
 480             hr = E_OUTOFMEMORY;
 481           }
 482         }
 483         return hr;
 484 }
 485 /**************************************************************************
 486 *         IShellFolder_Constructor
 487 *
 488 * NOTES
 489 *       THIS points to the parent folder
 490 */
 491
 492 IShellFolder * IShellFolder_Constructor(
 493         IShellFolder2 * iface,
 494         LPITEMIDLIST pidl)
 495 {
 496         IGenericSFImpl *        sf;
 497         DWORD                   dwSize=0;
 498
 499         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 500
 501         sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
 502         sf->ref=1;
 503
 504         ICOM_VTBL(sf)=&unkvt;
 505         sf->lpvtblShellFolder=&sfvt;
 506         sf->lpvtblPersistFolder2=&psfvt;
 507         sf->lpvtblDropTarget=&dtvt;
 508         sf->lpvtblSFHelper=&shvt;
 509
 510         sf->pclsid = (CLSID*)&CLSID_SFFile;
 511         sf->pUnkOuter = _IUnknown_(sf);
 512
 513         TRACE("(%p)->(parent=%p, pidl=%p)\n",sf,This, pidl);
 514         pdump(pidl);
 515
 516         if(pidl && iface)                               /* do we have a pidl? */
 517         {
 518           int len;
 519
 520           sf->absPidl = ILCombine(This->absPidl, pidl); /* build a absolute pidl */
 521
 522           if (!_ILIsSpecialFolder(pidl))                                /* only file system paths */
 523           {
 524             if(This->sMyPath)                           /* get the size of the parents path */
 525             {
 526               dwSize += strlen(This->sMyPath) ;
 527               TRACE("-- (%p)->(parent's path=%s)\n",sf, debugstr_a(This->sMyPath));
 528             }
 529
 530             dwSize += _ILSimpleGetText(pidl,NULL,0);            /* add the size of our name*/
 531             sf->sMyPath = SHAlloc(dwSize + 2);                  /* '\0' and backslash */
 532
 533             if(!sf->sMyPath) return NULL;
 534             *(sf->sMyPath)=0x00;
 535
 536             if(This->sMyPath)                           /* if the parent has a path, get it*/
 537             {
 538               strcpy(sf->sMyPath, This->sMyPath);
 539               PathAddBackslashA (sf->sMyPath);
 540             }
 541
 542             len = strlen(sf->sMyPath);
 543             _ILSimpleGetText(pidl, sf->sMyPath + len, dwSize+2 - len);
 544           }
 545
 546           TRACE("-- (%p)->(my pidl=%p, my path=%s)\n",sf, sf->absPidl,debugstr_a(sf->sMyPath));
 547
 548           pdump (sf->absPidl);
 549         }
 550
 551         shell32_ObjCount++;
 552         return _IShellFolder_(sf);
 553 }
 554
 555 /**************************************************************************
 556  *  IShellFolder_fnQueryInterface
 557  *
 558  * PARAMETERS
 559  *  REFIID riid         [in ] Requested InterfaceID
 560  *  LPVOID* ppvObject   [out] Interface* to hold the result
 561  */
 562 static HRESULT WINAPI IShellFolder_fnQueryInterface(
 563         IShellFolder2 * iface,
 564         REFIID riid,
 565         LPVOID *ppvObj)
 566 {
 567         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 568
 569         _CALL_TRACE
 570         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
 571
 572         return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
 573 }
 574
 575 /**************************************************************************
 576 *  IShellFolder_AddRef
 577 */
 578
 579 static ULONG WINAPI IShellFolder_fnAddRef(IShellFolder2 * iface)
 580 {
 581         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 582
 583         _CALL_TRACE
 584         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 585
 586         return IUnknown_AddRef(This->pUnkOuter);
 587 }
 588
 589 /**************************************************************************
 590  *  IShellFolder_fnRelease
 591  */
 592 static ULONG WINAPI IShellFolder_fnRelease(IShellFolder2 * iface)
 593 {
 594         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 595
 596         _CALL_TRACE
 597         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 598
 599         return IUnknown_Release(This->pUnkOuter);
 600 }
 601
 602 /**************************************************************************
 603 *               IShellFolder_fnParseDisplayName
 604 * PARAMETERS
 605 *  HWND          hwndOwner,      //[in ] Parent window for any message's
 606 *  LPBC          pbc,            //[in ] reserved
 607 *  LPOLESTR      lpszDisplayName,//[in ] "Unicode" displayname.
 608 *  ULONG*        pchEaten,       //[out] (unicode) characters processed
 609 *  LPITEMIDLIST* ppidl,          //[out] complex pidl to item
 610 *  ULONG*        pdwAttributes   //[out] items attributes
 611 *
 612 * NOTES
 613 *  every folder trys to parse only it's own (the leftmost) pidl and creates a
 614 *  subfolder to evaluate the remaining parts
 615 *  now we can parse into namespaces implemented by shell extensions
 616 *
 617 *  behaviour on win98:  lpszDisplayName=NULL -> chrash
 618 *                       lpszDisplayName="" -> returns mycoputer-pidl
 619 *
 620 * FIXME:
 621 *    pdwAttributes: not set
 622 *    pchEaten: not set like in windows
 623 */
 624 static HRESULT WINAPI IShellFolder_fnParseDisplayName(
 625         IShellFolder2 * iface,
 626         HWND hwndOwner,
 627         LPBC pbcReserved,
 628         LPOLESTR lpszDisplayName,
 629         DWORD *pchEaten,
 630         LPITEMIDLIST *ppidl,
 631         DWORD *pdwAttributes)
 632 {
 633         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 634
 635         HRESULT         hr = E_OUTOFMEMORY;
 636         LPCWSTR         szNext=NULL;
 637         WCHAR           szElement[MAX_PATH];
 638         CHAR            szTempA[MAX_PATH], szPath[MAX_PATH];
 639         LPITEMIDLIST    pidlTemp=NULL;
 640
 641         TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
 642         This,hwndOwner,pbcReserved,lpszDisplayName,
 643         debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
 644
 645         if (!lpszDisplayName || !ppidl) return E_INVALIDARG;
 646
 647         if (pchEaten) *pchEaten = 0;    /* strange but like the original */
 648
 649         if (*lpszDisplayName)
 650         {
 651           /* get the next element */
 652           szNext = GetNextElementW(lpszDisplayName, szElement, MAX_PATH);
 653
 654           /* build the full pathname to the element */
 655           lstrcpynWtoA(szTempA, szElement, lstrlenW(szElement) + 1);
 656           strcpy(szPath, This->sMyPath);
 657           PathAddBackslashA(szPath);
 658           strcat(szPath, szTempA);
 659
 660           /* get the pidl */
 661           pidlTemp = SHSimpleIDListFromPathA(szPath);
 662
 663           if (pidlTemp)
 664           {
 665             /* try to analyse the next element */
 666             if (szNext && *szNext)
 667             {
 668               hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
 669             }
 670             else
 671             {
 672                if (pdwAttributes && *pdwAttributes)
 673                {
 674                  SHELL32_GetItemAttributes(_IShellFolder_(This), pidlTemp, pdwAttributes);
 675 /*               WIN32_FIND_DATAA fd;
 676                  SHGetDataFromIDListA(_IShellFolder_(This), pidlTemp, SHGDFIL_FINDDATA, &fd, sizeof(fd));
 677                  if (!(FILE_ATTRIBUTE_DIRECTORY & fd.dwFileAttributes))
 678                    *pdwAttributes &= ~SFGAO_FOLDER;
 679                  if (FILE_ATTRIBUTE_READONLY  & fd.dwFileAttributes)
 680                    *pdwAttributes &= ~(SFGAO_CANDELETE|SFGAO_CANMOVE|SFGAO_CANRENAME );
 681 */
 682                }
 683                hr = S_OK;
 684             }
 685           }
 686         }
 687
 688         *ppidl = pidlTemp;
 689
 690         TRACE("(%p)->(-- pidl=%p ret=0x%08lx)\n", This, ppidl? *ppidl:0, hr);
 691
 692         return hr;
 693 }
 694
 695 /**************************************************************************
 696 *               IShellFolder_fnEnumObjects
 697 * PARAMETERS
 698 *  HWND          hwndOwner,    //[in ] Parent Window
 699 *  DWORD         grfFlags,     //[in ] SHCONTF enumeration mask
 700 *  LPENUMIDLIST* ppenumIDList  //[out] IEnumIDList interface
 701 */
 702 static HRESULT WINAPI IShellFolder_fnEnumObjects(
 703         IShellFolder2 * iface,
 704         HWND hwndOwner,
 705         DWORD dwFlags,
 706         LPENUMIDLIST* ppEnumIDList)
 707 {
 708         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 709
 710         TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
 711
 712         *ppEnumIDList = NULL;
 713         *ppEnumIDList = IEnumIDList_Constructor (This->sMyPath, dwFlags, EIDL_FILE);
 714
 715         TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
 716
 717         if(!*ppEnumIDList) return E_OUTOFMEMORY;
 718
 719         return S_OK;
 720 }
 721
 722 /**************************************************************************
 723 *               IShellFolder_fnBindToObject
 724 * PARAMETERS
 725 *  LPCITEMIDLIST pidl,       //[in ] relative pidl to open
 726 *  LPBC          pbc,        //[in ] reserved
 727 *  REFIID        riid,       //[in ] Initial Interface
 728 *  LPVOID*       ppvObject   //[out] Interface*
 729 */
 730 static HRESULT WINAPI IShellFolder_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
 731                         LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
 732 {
 733         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 734         GUID            const * iid;
 735         IShellFolder    *pShellFolder, *pSubFolder;
 736         IPersistFolder  *pPersistFolder;
 737         LPITEMIDLIST    absPidl;
 738
 739         TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
 740
 741         if(!pidl || !ppvOut) return E_INVALIDARG;
 742
 743         *ppvOut = NULL;
 744
 745         if ((iid=_ILGetGUIDPointer(pidl)))
 746         {
 747           /* we have to create a alien folder */
 748           if (  SUCCEEDED(SHCoCreateInstance(NULL, iid, NULL, riid, (LPVOID*)&pShellFolder))
 749              && SUCCEEDED(IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder, (LPVOID*)&pPersistFolder)))
 750             {
 751               absPidl = ILCombine (This->absPidl, pidl);
 752               IPersistFolder_Initialize(pPersistFolder, absPidl);
 753               IPersistFolder_Release(pPersistFolder);
 754               SHFree(absPidl);
 755             }
 756             else
 757             {
 758               return E_FAIL;
 759             }
 760         }
 761         else if(_ILIsFolder(pidl))
 762         {
 763           LPITEMIDLIST pidltemp = ILCloneFirst(pidl);
 764           pShellFolder = IShellFolder_Constructor(iface, pidltemp);
 765           ILFree(pidltemp);
 766         }
 767         else
 768         {
 769           ERR("can't bind to a file\n");
 770           return E_FAIL;
 771         }
 772
 773         if (_ILIsPidlSimple(pidl))
 774         {
 775           *ppvOut = pShellFolder;
 776         }
 777         else
 778         {
 779           IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, &IID_IShellFolder, (LPVOID)&pSubFolder);
 780           IShellFolder_Release(pShellFolder);
 781           *ppvOut = pSubFolder;
 782         }
 783
 784         TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
 785
 786         return S_OK;
 787 }
 788
 789 /**************************************************************************
 790 *  IShellFolder_fnBindToStorage
 791 * PARAMETERS
 792 *  LPCITEMIDLIST pidl,       //[in ] complex pidl to store
 793 *  LPBC          pbc,        //[in ] reserved
 794 *  REFIID        riid,       //[in ] Initial storage interface
 795 *  LPVOID*       ppvObject   //[out] Interface* returned
 796 */
 797 static HRESULT WINAPI IShellFolder_fnBindToStorage(
 798         IShellFolder2 * iface,
 799         LPCITEMIDLIST pidl,
 800         LPBC pbcReserved,
 801         REFIID riid,
 802         LPVOID *ppvOut)
 803 {
 804         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 805
 806         FIXME("(%p)->(pidl=%p,%p,\n\tIID:%s,%p) stub\n",
 807               This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
 808
 809         *ppvOut = NULL;
 810         return E_NOTIMPL;
 811 }
 812
 813 /**************************************************************************
 814 *  IShellFolder_fnCompareIDs
 815 *
 816 * PARMETERS
 817 *  LPARAM        lParam, //[in ] Column?
 818 *  LPCITEMIDLIST pidl1,  //[in ] simple pidl
 819 *  LPCITEMIDLIST pidl2)  //[in ] simple pidl
 820 *
 821 * NOTES
 822 *   Special case - If one of the items is a Path and the other is a File,
 823 *   always make the Path come before the File.
 824 *
 825 * NOTES
 826 *  use SCODE_CODE() on the return value to get the result
 827 */
 828
 829 static HRESULT WINAPI  IShellFolder_fnCompareIDs(
 830         IShellFolder2 * iface,
 831         LPARAM lParam,
 832         LPCITEMIDLIST pidl1,
 833         LPCITEMIDLIST pidl2)
 834 {
 835         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 836
 837         CHAR szTemp1[MAX_PATH];
 838         CHAR szTemp2[MAX_PATH];
 839         int   nReturn;
 840         IShellFolder * psf;
 841         HRESULT hr = E_OUTOFMEMORY;
 842         LPCITEMIDLIST  pidlTemp;
 843         PIDLTYPE pt1, pt2;
 844
 845         TRACE("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n",This,lParam,pidl1,pidl2);
 846         pdump (pidl1);
 847         pdump (pidl2);
 848
 849         if (!pidl1 && !pidl2)
 850         {
 851           hr = ResultFromShort(0);
 852         }
 853         else if (!pidl1)
 854         {
 855           hr = ResultFromShort(-1);
 856         }
 857         else if (!pidl2)
 858         {
 859           hr = ResultFromShort(1);
 860         }
 861         else
 862         {
 863           LPPIDLDATA pd1, pd2;
 864           pd1 = _ILGetDataPointer(pidl1);
 865           pd2 = _ILGetDataPointer(pidl2);
 866
 867           /* compate the types. sort order is the PT_* constant */
 868           pt1 = ( pd1 ? pd1->type: PT_DESKTOP);
 869           pt2 = ( pd2 ? pd2->type: PT_DESKTOP);
 870
 871           if (pt1 != pt2)
 872           {
 873             hr = ResultFromShort(pt1-pt2);
 874           }
 875           else                                          /* same type of pidl */
 876           {
 877             _ILSimpleGetText(pidl1, szTemp1, MAX_PATH);
 878             _ILSimpleGetText(pidl2, szTemp2, MAX_PATH);
 879             nReturn = strcasecmp(szTemp1, szTemp2);
 880
 881             if (nReturn == 0)                           /* first pidl different ? */
 882             {
 883               pidl1 = ILGetNext(pidl1);
 884
 885               if (pidl1 && pidl1->mkid.cb)              /* go deeper? */
 886               {
 887                 pidlTemp = ILCloneFirst(pidl1);
 888                 pidl2 = ILGetNext(pidl2);
 889
 890                 hr = IShellFolder_BindToObject(iface, pidlTemp, NULL, &IID_IShellFolder, (LPVOID*)&psf);
 891                 if (SUCCEEDED(hr))
 892                 {
 893                   nReturn = IShellFolder_CompareIDs(psf, 0, pidl1, pidl2);
 894                   IShellFolder_Release(psf);
 895                   hr = ResultFromShort(nReturn);
 896                 }
 897                 ILFree(pidlTemp);
 898               }
 899               else
 900               {
 901                 hr = ResultFromShort(nReturn);          /* two equal simple pidls */
 902               }
 903             }
 904             else
 905             {
 906               hr = ResultFromShort(nReturn);            /* two different simple pidls */
 907             }
 908           }
 909         }
 910
 911         TRACE("-- res=0x%08lx\n", hr);
 912         return hr;
 913 }
 914
 915 /**************************************************************************
 916 *       IShellFolder_fnCreateViewObject
 917 */
 918 static HRESULT WINAPI IShellFolder_fnCreateViewObject(
 919         IShellFolder2 * iface,
 920         HWND hwndOwner,
 921         REFIID riid,
 922         LPVOID *ppvOut)
 923 {
 924         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 925
 926         LPSHELLVIEW     pShellView;
 927         HRESULT         hr = E_INVALIDARG;
 928
 929         TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
 930
 931         if(ppvOut)
 932         {
 933           *ppvOut = NULL;
 934
 935           if(IsEqualIID(riid, &IID_IDropTarget))
 936           {
 937             hr = IShellFolder_QueryInterface(iface, &IID_IDropTarget, ppvOut);
 938           }
 939           else if(IsEqualIID(riid, &IID_IContextMenu))
 940           {
 941             FIXME("IContextMenu not implemented\n");
 942             hr = E_NOTIMPL;
 943           }
 944           else if(IsEqualIID(riid, &IID_IShellView))
 945           {
 946             pShellView = IShellView_Constructor((IShellFolder*)iface);
 947             if(pShellView)
 948             {
 949               hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
 950               IShellView_Release(pShellView);
 951             }
 952           }
 953         }
 954         TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
 955         return hr;
 956 }
 957
 958 /**************************************************************************
 959 *  IShellFolder_fnGetAttributesOf
 960 *
 961 * PARAMETERS
 962 *  UINT            cidl,     //[in ] num elements in pidl array
 963 *  LPCITEMIDLIST*  apidl,    //[in ] simple pidl array
 964 *  ULONG*          rgfInOut) //[out] result array
 965 *
 966 */
 967 static HRESULT WINAPI IShellFolder_fnGetAttributesOf(
 968         IShellFolder2 * iface,
 969         UINT cidl,
 970         LPCITEMIDLIST *apidl,
 971         DWORD *rgfInOut)
 972 {
 973         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
 974
 975         HRESULT hr = S_OK;
 976
 977         TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl,*rgfInOut);
 978
 979         if ( (!cidl) || (!apidl) || (!rgfInOut))
 980           return E_INVALIDARG;
 981
 982         while (cidl > 0 && *apidl)
 983         {
 984           pdump (*apidl);
 985           SHELL32_GetItemAttributes(_IShellFolder_(This), *apidl, rgfInOut);
 986           apidl++;
 987           cidl--;
 988         }
 989
 990         TRACE("-- result=0x%08lx\n",*rgfInOut);
 991
 992         return hr;
 993 }
 994 /**************************************************************************
 995 *  IShellFolder_fnGetUIObjectOf
 996 *
 997 * PARAMETERS
 998 *  HWND           hwndOwner, //[in ] Parent window for any output
 999 *  UINT           cidl,      //[in ] array size
1000 *  LPCITEMIDLIST* apidl,     //[in ] simple pidl array
1001 *  REFIID         riid,      //[in ] Requested Interface
1002 *  UINT*          prgfInOut, //[   ] reserved
1003 *  LPVOID*        ppvObject) //[out] Resulting Interface
1004 *
1005 * NOTES
1006 *  This function gets asked to return "view objects" for one or more (multiple select)
1007 *  items:
1008 *  The viewobject typically is an COM object with one of the following interfaces:
1009 *  IExtractIcon,IDataObject,IContextMenu
1010 *  In order to support icon positions in the default Listview your DataObject
1011 *  must implement the SetData method (in addition to GetData :) - the shell passes
1012 *  a barely documented "Icon positions" structure to SetData when the drag starts,
1013 *  and GetData's it if the drop is in another explorer window that needs the positions.
1014 */
1015 static HRESULT WINAPI IShellFolder_fnGetUIObjectOf(
1016         IShellFolder2 * iface,
1017         HWND            hwndOwner,
1018         UINT            cidl,
1019         LPCITEMIDLIST * apidl,
1020         REFIID          riid,
1021         UINT *          prgfInOut,
1022         LPVOID *        ppvOut)
1023 {
1024         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1025
1026         LPITEMIDLIST    pidl;
1027         IUnknown*       pObj = NULL;
1028         HRESULT         hr = E_INVALIDARG;
1029
1030         TRACE("(%p)->(0x%04x,%u,apidl=%p,\n\tIID:%s,%p,%p)\n",
1031           This,hwndOwner,cidl,apidl,debugstr_guid(riid),prgfInOut,ppvOut);
1032
1033         if (ppvOut)
1034         {
1035           *ppvOut = NULL;
1036
1037           if(IsEqualIID(riid, &IID_IContextMenu) && (cidl >= 1))
1038           {
1039             pObj  = (LPUNKNOWN)ISvItemCm_Constructor((IShellFolder*)iface, This->absPidl, apidl, cidl);
1040             hr = S_OK;
1041           }
1042           else if (IsEqualIID(riid, &IID_IDataObject) &&(cidl >= 1))
1043           {
1044             pObj = (LPUNKNOWN)IDataObject_Constructor (hwndOwner, This->absPidl, apidl, cidl);
1045             hr = S_OK;
1046           }
1047           else if (IsEqualIID(riid, &IID_IExtractIconA) && (cidl == 1))
1048           {
1049             pidl = ILCombine(This->absPidl,apidl[0]);
1050             pObj = (LPUNKNOWN)IExtractIconA_Constructor( pidl );
1051             SHFree(pidl);
1052             hr = S_OK;
1053           }
1054           else if (IsEqualIID(riid, &IID_IDropTarget) && (cidl >= 1))
1055           {
1056             hr = IShellFolder_QueryInterface(iface, &IID_IDropTarget, (LPVOID*)&pObj);
1057           }
1058           else
1059           {
1060             hr = E_NOINTERFACE;
1061           }
1062
1063           if(!pObj)
1064             hr = E_OUTOFMEMORY;
1065
1066           *ppvOut = pObj;
1067         }
1068         TRACE("(%p)->hr=0x%08lx\n",This, hr);
1069         return hr;
1070 }
1071
1072 /**************************************************************************
1073 *  IShellFolder_fnGetDisplayNameOf
1074 *  Retrieves the display name for the specified file object or subfolder
1075 *
1076 * PARAMETERS
1077 *  LPCITEMIDLIST pidl,    //[in ] complex pidl to item
1078 *  DWORD         dwFlags, //[in ] SHGNO formatting flags
1079 *  LPSTRRET      lpName)  //[out] Returned display name
1080 *
1081 * FIXME
1082 *  if the name is in the pidl the ret value should be a STRRET_OFFSET
1083 */
1084 #define GET_SHGDN_FOR(dwFlags)         ((DWORD)dwFlags & (DWORD)0x0000FF00)
1085 #define GET_SHGDN_RELATION(dwFlags)    ((DWORD)dwFlags & (DWORD)0x000000FF)
1086
1087 static HRESULT WINAPI IShellFolder_fnGetDisplayNameOf(
1088         IShellFolder2 * iface,
1089         LPCITEMIDLIST pidl,
1090         DWORD dwFlags,
1091         LPSTRRET strRet)
1092 {
1093         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1094
1095         CHAR            szPath[MAX_PATH]= "";
1096         int             len = 0;
1097         BOOL            bSimplePidl;
1098
1099         TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
1100         pdump(pidl);
1101
1102         if(!pidl || !strRet) return E_INVALIDARG;
1103
1104         bSimplePidl = _ILIsPidlSimple(pidl);
1105
1106         /* take names of special folders only if its only this folder */
1107         if (_ILIsSpecialFolder(pidl))
1108         {
1109           if ( bSimplePidl)
1110           {
1111             _ILSimpleGetText(pidl, szPath, MAX_PATH); /* append my own path */
1112           }
1113         }
1114         else
1115         {
1116           if (!(dwFlags & SHGDN_INFOLDER) && (dwFlags & SHGDN_FORPARSING) && This->sMyPath)
1117           {
1118             strcpy (szPath, This->sMyPath);                     /* get path to root*/
1119             PathAddBackslashA(szPath);
1120             len = strlen(szPath);
1121           }
1122           _ILSimpleGetText(pidl, szPath + len, MAX_PATH - len); /* append my own path */
1123         }
1124
1125         if ( (dwFlags & SHGDN_FORPARSING) && !bSimplePidl)      /* go deeper if needed */
1126         {
1127           PathAddBackslashA(szPath);
1128           len = strlen(szPath);
1129
1130           if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, szPath + len, MAX_PATH - len)))
1131             return E_OUTOFMEMORY;
1132         }
1133         strRet->uType = STRRET_CSTRA;
1134         lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
1135
1136         TRACE("-- (%p)->(%s)\n", This, szPath);
1137         return S_OK;
1138 }
1139
1140 /**************************************************************************
1141 *  IShellFolder_fnSetNameOf
1142 *  Changes the name of a file object or subfolder, possibly changing its item
1143 *  identifier in the process.
1144 *
1145 * PARAMETERS
1146 *  HWND          hwndOwner,  //[in ] Owner window for output
1147 *  LPCITEMIDLIST pidl,       //[in ] simple pidl of item to change
1148 *  LPCOLESTR     lpszName,   //[in ] the items new display name
1149 *  DWORD         dwFlags,    //[in ] SHGNO formatting flags
1150 *  LPITEMIDLIST* ppidlOut)   //[out] simple pidl returned
1151 */
1152 static HRESULT WINAPI IShellFolder_fnSetNameOf(
1153         IShellFolder2 * iface,
1154         HWND hwndOwner,
1155         LPCITEMIDLIST pidl, /*simple pidl*/
1156         LPCOLESTR lpName,
1157         DWORD dwFlags,
1158         LPITEMIDLIST *pPidlOut)
1159 {
1160         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1161         char szSrc[MAX_PATH], szDest[MAX_PATH];
1162         int len;
1163         BOOL bIsFolder = _ILIsFolder(ILFindLastID(pidl));
1164
1165         TRACE("(%p)->(%u,pidl=%p,%s,%lu,%p)\n",
1166           This,hwndOwner,pidl,debugstr_w(lpName),dwFlags,pPidlOut);
1167
1168         /* build source path */
1169         if (dwFlags & SHGDN_INFOLDER)
1170         {
1171           strcpy(szSrc, This->sMyPath);
1172           PathAddBackslashA(szSrc);
1173           len = strlen (szSrc);
1174           _ILSimpleGetText(pidl, szSrc+len, MAX_PATH-len);
1175         }
1176         else
1177         {
1178           SHGetPathFromIDListA(pidl, szSrc);
1179         }
1180
1181         /* build destination path */
1182         strcpy(szDest, This->sMyPath);
1183         PathAddBackslashA(szDest);
1184         len = strlen (szDest);
1185         lstrcpynWtoA(szDest+len, lpName, MAX_PATH-len);
1186
1187         TRACE("src=%s dest=%s\n", szSrc, szDest);
1188         if ( MoveFileA(szSrc, szDest) )
1189         {
1190           if (pPidlOut) *pPidlOut = SHSimpleIDListFromPathA(szDest);
1191           SHChangeNotifyA( bIsFolder?SHCNE_RENAMEFOLDER:SHCNE_RENAMEITEM, SHCNF_PATHA, szSrc, szDest);
1192           return S_OK;
1193         }
1194         return E_FAIL;
1195 }
1196
1197 static HRESULT WINAPI IShellFolder_fnGetDefaultSearchGUID(
1198         IShellFolder2 * iface,
1199         GUID *pguid)
1200 {
1201         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1202         FIXME("(%p)\n",This);
1203         return E_NOTIMPL;
1204 }
1205 static HRESULT WINAPI IShellFolder_fnEnumSearches(
1206         IShellFolder2 * iface,
1207         IEnumExtraSearch **ppenum)
1208 {
1209         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1210         FIXME("(%p)\n",This);
1211         return E_NOTIMPL;
1212 }
1213 static HRESULT WINAPI IShellFolder_fnGetDefaultColumn(
1214         IShellFolder2 * iface,
1215         DWORD dwRes,
1216         ULONG *pSort,
1217         ULONG *pDisplay)
1218 {
1219         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1220
1221         TRACE("(%p)\n",This);
1222
1223         if (pSort) *pSort = 0;
1224         if (pDisplay) *pDisplay = 0;
1225
1226         return S_OK;
1227 }
1228 static HRESULT WINAPI IShellFolder_fnGetDefaultColumnState(
1229         IShellFolder2 * iface,
1230         UINT iColumn,
1231         DWORD *pcsFlags)
1232 {
1233         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1234
1235         TRACE("(%p)\n",This);
1236
1237         if (!pcsFlags || iColumn >= GENERICSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1238
1239         *pcsFlags = GenericSFHeader[iColumn].pcsFlags;
1240
1241         return S_OK;
1242 }
1243 static HRESULT WINAPI IShellFolder_fnGetDetailsEx(
1244         IShellFolder2 * iface,
1245         LPCITEMIDLIST pidl,
1246         const SHCOLUMNID *pscid,
1247         VARIANT *pv)
1248 {
1249         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1250         FIXME("(%p)\n",This);
1251
1252         return E_NOTIMPL;
1253 }
1254 static HRESULT WINAPI IShellFolder_fnGetDetailsOf(
1255         IShellFolder2 * iface,
1256         LPCITEMIDLIST pidl,
1257         UINT iColumn,
1258         SHELLDETAILS *psd)
1259 {
1260         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1261         HRESULT hr = E_FAIL;
1262
1263         TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
1264
1265         if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1266
1267         if (!pidl)
1268         {
1269           /* the header titles */
1270           psd->fmt = GenericSFHeader[iColumn].fmt;
1271           psd->cxChar = GenericSFHeader[iColumn].cxChar;
1272           psd->str.uType = STRRET_CSTRA;
1273           LoadStringA(shell32_hInstance, GenericSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
1274           return S_OK;
1275         }
1276         else
1277         {
1278           /* the data from the pidl */
1279           switch(iColumn)
1280           {
1281             case 0:     /* name */
1282               hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
1283               break;
1284             case 1:     /* size */
1285               _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
1286               break;
1287             case 2:     /* type */
1288               _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
1289               break;
1290             case 3:     /* date */
1291               _ILGetFileDate(pidl, psd->str.u.cStr, MAX_PATH);
1292               break;
1293             case 4:     /* attributes */
1294               _ILGetFileAttributes(pidl, psd->str.u.cStr, MAX_PATH);
1295               break;
1296           }
1297           hr = S_OK;
1298           psd->str.uType = STRRET_CSTRA;
1299         }
1300
1301         return hr;
1302 }
1303 static HRESULT WINAPI IShellFolder_fnMapNameToSCID(
1304         IShellFolder2 * iface,
1305         LPCWSTR pwszName,
1306         SHCOLUMNID *pscid)
1307 {
1308         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1309         FIXME("(%p)\n",This);
1310         return E_NOTIMPL;
1311 }
1312
1313 static ICOM_VTABLE(IShellFolder2) sfvt =
1314 {
1315         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1316         IShellFolder_fnQueryInterface,
1317         IShellFolder_fnAddRef,
1318         IShellFolder_fnRelease,
1319         IShellFolder_fnParseDisplayName,
1320         IShellFolder_fnEnumObjects,
1321         IShellFolder_fnBindToObject,
1322         IShellFolder_fnBindToStorage,
1323         IShellFolder_fnCompareIDs,
1324         IShellFolder_fnCreateViewObject,
1325         IShellFolder_fnGetAttributesOf,
1326         IShellFolder_fnGetUIObjectOf,
1327         IShellFolder_fnGetDisplayNameOf,
1328         IShellFolder_fnSetNameOf,
1329
1330         /* ShellFolder2 */
1331         IShellFolder_fnGetDefaultSearchGUID,
1332         IShellFolder_fnEnumSearches,
1333         IShellFolder_fnGetDefaultColumn,
1334         IShellFolder_fnGetDefaultColumnState,
1335         IShellFolder_fnGetDetailsEx,
1336         IShellFolder_fnGetDetailsOf,
1337         IShellFolder_fnMapNameToSCID
1338 };
1339
1340 /****************************************************************************
1341  * ISFHelper for IShellFolder implementation
1342  */
1343
1344 static HRESULT WINAPI ISFHelper_fnQueryInterface(
1345         ISFHelper *iface,
1346         REFIID riid,
1347         LPVOID *ppvObj)
1348 {
1349         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1350
1351         TRACE("(%p)\n", This);
1352
1353         return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
1354 }
1355
1356 static ULONG WINAPI ISFHelper_fnAddRef(
1357         ISFHelper *iface)
1358 {
1359         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1360
1361         TRACE("(%p)\n", This);
1362
1363         return IUnknown_AddRef(This->pUnkOuter);
1364 }
1365
1366 static ULONG WINAPI ISFHelper_fnRelease(
1367         ISFHelper *iface)
1368 {
1369         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1370
1371         TRACE("(%p)\n", This);
1372
1373         return IUnknown_Release(This->pUnkOuter);
1374 }
1375
1376
1377 /****************************************************************************
1378  * ISFHelper_fnAddFolder
1379  *
1380  * creates a unique folder name
1381  */
1382
1383 static HRESULT WINAPI ISFHelper_fnGetUniqueName(
1384         ISFHelper *iface,
1385         LPSTR lpName,
1386         UINT uLen)
1387 {
1388         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1389         IEnumIDList * penum;
1390         HRESULT hr;
1391         char szText[MAX_PATH];
1392         char * szNewFolder = "New Folder";
1393
1394         TRACE("(%p)(%s %u)\n", This, lpName, uLen);
1395
1396         if (uLen < strlen(szNewFolder) + 4) return E_POINTER;
1397
1398         strcpy(lpName, szNewFolder);
1399
1400         hr = IShellFolder_fnEnumObjects(_IShellFolder2_(This), 0, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penum);
1401         if (penum)
1402         {
1403           LPITEMIDLIST pidl;
1404           DWORD dwFetched;
1405           int i=1;
1406
1407 next:     IEnumIDList_Reset(penum);
1408           while(S_OK == IEnumIDList_Next(penum, 1, &pidl, &dwFetched) && dwFetched)
1409           {
1410             _ILSimpleGetText(pidl, szText, MAX_PATH);
1411             if (0 == strcasecmp(szText, lpName))
1412             {
1413               sprintf(lpName, "%s %d", szNewFolder, i++);
1414               if (i > 99)
1415               {
1416                 hr = E_FAIL;
1417                 break;
1418               }
1419               goto next;
1420             }
1421           }
1422
1423           IEnumIDList_Release(penum);
1424         }
1425         return hr;
1426 }
1427
1428 /****************************************************************************
1429  * ISFHelper_fnAddFolder
1430  *
1431  * adds a new folder.
1432  */
1433
1434 static HRESULT WINAPI ISFHelper_fnAddFolder(
1435         ISFHelper *iface,
1436         HWND hwnd,
1437         LPCSTR lpName,
1438         LPITEMIDLIST* ppidlOut)
1439 {
1440         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1441         char lpstrNewDir[MAX_PATH];
1442         DWORD bRes;
1443         HRESULT hres = E_FAIL;
1444
1445         TRACE("(%p)(%s %p)\n", This, lpName, ppidlOut);
1446
1447         strcpy(lpstrNewDir, This->sMyPath);
1448         PathAddBackslashA(lpstrNewDir);
1449         strcat(lpstrNewDir, lpName);
1450
1451         bRes = CreateDirectoryA(lpstrNewDir, NULL);
1452
1453         if (bRes)
1454         {
1455           LPITEMIDLIST pidl, pidlitem;
1456
1457           pidlitem = SHSimpleIDListFromPathA(lpstrNewDir);
1458
1459           pidl = ILCombine(This->absPidl, pidlitem);
1460           SHChangeNotifyA(SHCNE_MKDIR, SHCNF_IDLIST, pidl, NULL);
1461           SHFree(pidl);
1462
1463           if (ppidlOut) *ppidlOut = pidlitem;
1464           hres = S_OK;
1465         }
1466         else
1467         {
1468           char lpstrText[128+MAX_PATH];
1469           char lpstrTempText[128];
1470           char lpstrCaption[256];
1471
1472           /* Cannot Create folder because of permissions */
1473           LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_DENIED, lpstrTempText, sizeof(lpstrTempText));
1474           LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_CAPTION, lpstrCaption, sizeof(lpstrCaption));
1475           sprintf(lpstrText,lpstrTempText, lpstrNewDir);
1476           MessageBoxA(hwnd,lpstrText, lpstrCaption, MB_OK | MB_ICONEXCLAMATION);
1477         }
1478
1479         return hres;
1480 }
1481
1482 /****************************************************************************
1483  * ISFHelper_fnDeleteItems
1484  *
1485  * deletes items in folder
1486  */
1487 static HRESULT WINAPI ISFHelper_fnDeleteItems(
1488         ISFHelper *iface,
1489         UINT cidl,
1490         LPCITEMIDLIST* apidl)
1491 {
1492         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1493         int i;
1494         char szPath[MAX_PATH];
1495
1496         TRACE("(%p)(%u %p)\n", This, cidl, apidl);
1497
1498         for(i=0; i< cidl; i++)
1499         {
1500           strcpy(szPath, This->sMyPath);
1501           PathAddBackslashA(szPath);
1502           _ILSimpleGetText(apidl[i], szPath+strlen(szPath), MAX_PATH);
1503
1504           if (_ILIsFolder(apidl[i]))
1505           {
1506             LPITEMIDLIST pidl;
1507
1508             MESSAGE("delete %s\n", szPath);
1509             if (! SHELL_DeleteDirectoryA(szPath, TRUE)) return E_FAIL;
1510             pidl = ILCombine(This->absPidl, apidl[i]);
1511             SHChangeNotifyA(SHCNE_RMDIR, SHCNF_IDLIST, pidl, NULL);
1512             SHFree(pidl);
1513           }
1514           else if (_ILIsValue(apidl[i]))
1515           {
1516             LPITEMIDLIST pidl;
1517
1518             MESSAGE("delete %s\n", szPath);
1519             if (! DeleteFileA(szPath)) return E_FAIL;
1520             pidl = ILCombine(This->absPidl, apidl[i]);
1521             SHChangeNotifyA(SHCNE_DELETE, SHCNF_IDLIST, pidl, NULL);
1522             SHFree(pidl);
1523           }
1524
1525         }
1526         return S_OK;
1527 }
1528
1529 /****************************************************************************
1530  * ISFHelper_fnCopyItems
1531  *
1532  * copys items to this folder
1533  */
1534 static HRESULT WINAPI ISFHelper_fnCopyItems(
1535         ISFHelper *iface,
1536         IShellFolder* pSFFrom,
1537         UINT cidl,
1538         LPCITEMIDLIST *apidl)
1539 {
1540         int i;
1541         IPersistFolder2 * ppf2=NULL;
1542         char szSrcPath[MAX_PATH], szDstPath[MAX_PATH];
1543         _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1544
1545         TRACE("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
1546
1547         IShellFolder_QueryInterface(pSFFrom, &IID_IPersistFolder2, (LPVOID*)&ppf2);
1548         if (ppf2)
1549         {
1550           LPITEMIDLIST pidl;
1551           if (SUCCEEDED(IPersistFolder2_GetCurFolder(ppf2, &pidl)))
1552           {
1553             for (i=0; i<cidl; i++)
1554             {
1555               SHGetPathFromIDListA(pidl, szSrcPath);
1556               PathAddBackslashA(szSrcPath);
1557               _ILSimpleGetText(apidl[i], szSrcPath+strlen(szSrcPath), MAX_PATH);
1558
1559               strcpy(szDstPath, This->sMyPath);
1560               PathAddBackslashA(szDstPath);
1561               _ILSimpleGetText(apidl[i], szDstPath+strlen(szDstPath), MAX_PATH);
1562               MESSAGE("would copy %s to %s\n", szSrcPath, szDstPath);
1563             }
1564             SHFree(pidl);
1565           }
1566           IPersistFolder2_Release(ppf2);
1567         }
1568         return S_OK;
1569 }
1570
1571 static ICOM_VTABLE(ISFHelper) shvt =
1572 {
1573         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1574         ISFHelper_fnQueryInterface,
1575         ISFHelper_fnAddRef,
1576         ISFHelper_fnRelease,
1577         ISFHelper_fnGetUniqueName,
1578         ISFHelper_fnAddFolder,
1579         ISFHelper_fnDeleteItems,
1580         ISFHelper_fnCopyItems,
1581 };
1582
1583 /***********************************************************************
1584 *       [Desktopfolder] IShellFolder implementation
1585 */
1586 static struct ICOM_VTABLE(IShellFolder2) sfdvt;
1587
1588 static shvheader DesktopSFHeader [] =
1589 {
1590  { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
1591  { IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
1592  { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
1593  { IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12 },
1594  { IDS_SHV_COLUMN5, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 5 }
1595 };
1596 #define DESKTOPSHELLVIEWCOLUMNS 5
1597
1598 /**************************************************************************
1599 *       ISF_Desktop_Constructor
1600 *
1601 */
1602 IShellFolder * ISF_Desktop_Constructor()
1603 {
1604         IGenericSFImpl *        sf;
1605
1606         sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
1607         sf->ref=1;
1608         ICOM_VTBL(sf)=&unkvt;
1609         sf->lpvtblShellFolder=&sfdvt;
1610         sf->absPidl=_ILCreateDesktop(); /* my qualified pidl */
1611         sf->pUnkOuter = (IUnknown *) &sf->lpVtbl;
1612
1613         TRACE("(%p)\n",sf);
1614
1615         shell32_ObjCount++;
1616         return _IShellFolder_(sf);
1617 }
1618
1619 /**************************************************************************
1620  *      ISF_Desktop_fnQueryInterface
1621  *
1622  * NOTES supports not IPersist/IPersistFolder
1623  */
1624 static HRESULT WINAPI ISF_Desktop_fnQueryInterface(
1625         IShellFolder2 * iface,
1626         REFIID riid,
1627         LPVOID *ppvObj)
1628 {
1629         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1630
1631         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
1632
1633         *ppvObj = NULL;
1634
1635         if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
1636         {
1637           *ppvObj = _IUnknown_(This);
1638         }
1639         else if(IsEqualIID(riid, &IID_IShellFolder))  /*IShellFolder*/
1640         {
1641           *ppvObj = _IShellFolder_(This);
1642         }
1643         else if(IsEqualIID(riid, &IID_IShellFolder2))  /*IShellFolder2*/
1644         {
1645           *ppvObj = _IShellFolder_(This);
1646         }
1647
1648         if(*ppvObj)
1649         {
1650           IUnknown_AddRef((IUnknown*)(*ppvObj));
1651           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
1652           return S_OK;
1653         }
1654         TRACE("-- Interface: E_NOINTERFACE\n");
1655         return E_NOINTERFACE;
1656 }
1657
1658 /**************************************************************************
1659 *       ISF_Desktop_fnParseDisplayName
1660 *
1661 * NOTES
1662 *       "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" and "" binds
1663 *       to MyComputer
1664 */
1665 static HRESULT WINAPI ISF_Desktop_fnParseDisplayName(
1666         IShellFolder2 * iface,
1667         HWND hwndOwner,
1668         LPBC pbcReserved,
1669         LPOLESTR lpszDisplayName,
1670         DWORD *pchEaten,
1671         LPITEMIDLIST *ppidl,
1672         DWORD *pdwAttributes)
1673 {
1674         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1675
1676         LPCWSTR         szNext=NULL;
1677         LPITEMIDLIST    pidlTemp=NULL;
1678         HRESULT         hr=E_OUTOFMEMORY;
1679
1680         TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
1681         This,hwndOwner,pbcReserved,lpszDisplayName,
1682         debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
1683
1684         *ppidl = 0;
1685         if (pchEaten) *pchEaten = 0;    /* strange but like the original */
1686
1687         /* fixme no real parsing implemented */
1688         pidlTemp = _ILCreateMyComputer();
1689         szNext = lpszDisplayName;
1690
1691         if (szNext && *szNext)
1692         {
1693           hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
1694         }
1695         else
1696         {
1697           hr = S_OK;
1698
1699           if (pdwAttributes && *pdwAttributes)
1700           {
1701             SHELL32_GetItemAttributes(_IShellFolder_(This), pidlTemp, pdwAttributes);
1702           }
1703         }
1704
1705         *ppidl = pidlTemp;
1706
1707         TRACE("(%p)->(-- ret=0x%08lx)\n", This, hr);
1708
1709         return hr;
1710 }
1711
1712 /**************************************************************************
1713 *               ISF_Desktop_fnEnumObjects
1714 */
1715 static HRESULT WINAPI ISF_Desktop_fnEnumObjects(
1716         IShellFolder2 * iface,
1717         HWND hwndOwner,
1718         DWORD dwFlags,
1719         LPENUMIDLIST* ppEnumIDList)
1720 {
1721         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1722
1723         TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
1724
1725         *ppEnumIDList = NULL;
1726         *ppEnumIDList = IEnumIDList_Constructor (NULL, dwFlags, EIDL_DESK);
1727
1728         TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
1729
1730         if(!*ppEnumIDList) return E_OUTOFMEMORY;
1731
1732         return S_OK;
1733 }
1734
1735 /**************************************************************************
1736 *               ISF_Desktop_fnBindToObject
1737 */
1738 static HRESULT WINAPI ISF_Desktop_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
1739                         LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
1740 {
1741         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1742         GUID            const * clsid;
1743         IShellFolder    *pShellFolder, *pSubFolder;
1744
1745         TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",
1746               This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
1747
1748         *ppvOut = NULL;
1749
1750         if ((clsid=_ILGetGUIDPointer(pidl)))
1751         {
1752           if ( IsEqualIID(clsid, &CLSID_MyComputer))
1753           {
1754             pShellFolder = ISF_MyComputer_Constructor();
1755           }
1756           else
1757           {
1758              /* shell extension */
1759              if (!SUCCEEDED(SHELL32_CoCreateInitSF (This->absPidl, pidl, clsid, riid, (LPVOID*)&pShellFolder)))
1760              {
1761                return E_INVALIDARG;
1762              }
1763           }
1764         }
1765         else
1766         {
1767           /* file system folder on the desktop */
1768           LPITEMIDLIST deskpidl, firstpidl, completepidl;
1769           IPersistFolder * ppf;
1770
1771           /* combine pidls */
1772           SHGetSpecialFolderLocation(0, CSIDL_DESKTOPDIRECTORY, &deskpidl);
1773           firstpidl = ILCloneFirst(pidl);
1774           completepidl = ILCombine(deskpidl, firstpidl);
1775
1776           pShellFolder = IShellFolder_Constructor(NULL, NULL);
1777           if (SUCCEEDED(IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder, (LPVOID*)&ppf)))
1778           {
1779             IPersistFolder_Initialize(ppf, completepidl);
1780             IPersistFolder_Release(ppf);
1781           }
1782           ILFree(completepidl);
1783           ILFree(deskpidl);
1784           ILFree(firstpidl);
1785         }
1786
1787         if (_ILIsPidlSimple(pidl))      /* no sub folders */
1788         {
1789           *ppvOut = pShellFolder;
1790         }
1791         else                            /* go deeper */
1792         {
1793           IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, riid, (LPVOID)&pSubFolder);
1794           IShellFolder_Release(pShellFolder);
1795           *ppvOut = pSubFolder;
1796         }
1797
1798         TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
1799
1800         return S_OK;
1801 }
1802
1803 /**************************************************************************
1804 *       ISF_Desktop_fnCreateViewObject
1805 */
1806 static HRESULT WINAPI ISF_Desktop_fnCreateViewObject( IShellFolder2 * iface,
1807                  HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
1808 {
1809         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1810
1811         LPSHELLVIEW     pShellView;
1812         HRESULT         hr = E_INVALIDARG;
1813
1814         TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
1815
1816         if(ppvOut)
1817         {
1818           *ppvOut = NULL;
1819
1820           if(IsEqualIID(riid, &IID_IDropTarget))
1821           {
1822             WARN("IDropTarget not implemented\n");
1823             hr = E_NOTIMPL;
1824           }
1825           else if(IsEqualIID(riid, &IID_IContextMenu))
1826           {
1827             WARN("IContextMenu not implemented\n");
1828             hr = E_NOTIMPL;
1829           }
1830           else if(IsEqualIID(riid, &IID_IShellView))
1831           {
1832             pShellView = IShellView_Constructor((IShellFolder*)iface);
1833             if(pShellView)
1834             {
1835               hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
1836               IShellView_Release(pShellView);
1837             }
1838           }
1839         }
1840         TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
1841         return hr;
1842 }
1843
1844 /**************************************************************************
1845 *  ISF_Desktop_fnGetAttributesOf
1846 */
1847 static HRESULT WINAPI ISF_Desktop_fnGetAttributesOf(
1848         IShellFolder2 * iface,
1849         UINT cidl,
1850         LPCITEMIDLIST *apidl,
1851         DWORD *rgfInOut)
1852 {
1853         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1854
1855         HRESULT         hr = S_OK;
1856
1857         TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl, *rgfInOut);
1858
1859         if ( (!cidl) || (!apidl) || (!rgfInOut))
1860           return E_INVALIDARG;
1861
1862         while (cidl > 0 && *apidl)
1863         {
1864           pdump (*apidl);
1865           SHELL32_GetItemAttributes(_IShellFolder_(This), *apidl, rgfInOut);
1866           apidl++;
1867           cidl--;
1868         }
1869
1870         TRACE("-- result=0x%08lx\n",*rgfInOut);
1871
1872         return hr;
1873 }
1874
1875 /**************************************************************************
1876 *       ISF_Desktop_fnGetDisplayNameOf
1877 *
1878 * NOTES
1879 *       special case: pidl = null gives desktop-name back
1880 */
1881 static HRESULT WINAPI ISF_Desktop_fnGetDisplayNameOf(
1882         IShellFolder2 * iface,
1883         LPCITEMIDLIST pidl,
1884         DWORD dwFlags,
1885         LPSTRRET strRet)
1886 {
1887         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1888
1889         CHAR            szPath[MAX_PATH]= "";
1890
1891         TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
1892         pdump(pidl);
1893
1894         if(!strRet) return E_INVALIDARG;
1895
1896         if(!pidl)
1897         {
1898           HCR_GetClassName(&CLSID_ShellDesktop, szPath, MAX_PATH);
1899         }
1900         else if ( _ILIsPidlSimple(pidl) )
1901         {
1902           _ILSimpleGetText(pidl, szPath, MAX_PATH);
1903         }
1904         else
1905         {
1906           if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, szPath, MAX_PATH)))
1907             return E_OUTOFMEMORY;
1908         }
1909         strRet->uType = STRRET_CSTRA;
1910         lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
1911
1912
1913         TRACE("-- (%p)->(%s)\n", This, szPath);
1914         return S_OK;
1915 }
1916
1917 static HRESULT WINAPI ISF_Desktop_fnGetDefaultSearchGUID(
1918         IShellFolder2 * iface,
1919         GUID *pguid)
1920 {
1921         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1922         FIXME("(%p)\n",This);
1923         return E_NOTIMPL;
1924 }
1925 static HRESULT WINAPI ISF_Desktop_fnEnumSearches(
1926         IShellFolder2 * iface,
1927         IEnumExtraSearch **ppenum)
1928 {
1929         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1930         FIXME("(%p)\n",This);
1931         return E_NOTIMPL;
1932 }
1933 static HRESULT WINAPI ISF_Desktop_fnGetDefaultColumn(
1934         IShellFolder2 * iface,
1935         DWORD dwRes,
1936         ULONG *pSort,
1937         ULONG *pDisplay)
1938 {
1939         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1940
1941         TRACE("(%p)\n",This);
1942
1943         if (pSort) *pSort = 0;
1944         if (pDisplay) *pDisplay = 0;
1945
1946         return S_OK;
1947 }
1948 static HRESULT WINAPI ISF_Desktop_fnGetDefaultColumnState(
1949         IShellFolder2 * iface,
1950         UINT iColumn,
1951         DWORD *pcsFlags)
1952 {
1953         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1954
1955         TRACE("(%p)\n",This);
1956
1957         if (!pcsFlags || iColumn >= DESKTOPSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1958
1959         *pcsFlags = DesktopSFHeader[iColumn].pcsFlags;
1960
1961         return S_OK;
1962 }
1963 static HRESULT WINAPI ISF_Desktop_fnGetDetailsEx(
1964         IShellFolder2 * iface,
1965         LPCITEMIDLIST pidl,
1966         const SHCOLUMNID *pscid,
1967         VARIANT *pv)
1968 {
1969         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1970         FIXME("(%p)\n",This);
1971
1972         return E_NOTIMPL;
1973 }
1974 static HRESULT WINAPI ISF_Desktop_fnGetDetailsOf(
1975         IShellFolder2 * iface,
1976         LPCITEMIDLIST pidl,
1977         UINT iColumn,
1978         SHELLDETAILS *psd)
1979 {
1980         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1981         HRESULT hr = E_FAIL;;
1982
1983         TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
1984
1985         if (!psd || iColumn >= DESKTOPSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1986
1987         if (!pidl)
1988         {
1989           psd->fmt = DesktopSFHeader[iColumn].fmt;
1990           psd->cxChar = DesktopSFHeader[iColumn].cxChar;
1991           psd->str.uType = STRRET_CSTRA;
1992           LoadStringA(shell32_hInstance, DesktopSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
1993           return S_OK;
1994         }
1995         else
1996         {
1997           /* the data from the pidl */
1998           switch(iColumn)
1999           {
2000             case 0:     /* name */
2001               hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
2002               break;
2003             case 1:     /* size */
2004               _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
2005               break;
2006             case 2:     /* type */
2007               _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
2008               break;
2009             case 3:     /* date */
2010               _ILGetFileDate(pidl, psd->str.u.cStr, MAX_PATH);
2011               break;
2012             case 4:     /* attributes */
2013               _ILGetFileAttributes(pidl, psd->str.u.cStr, MAX_PATH);
2014               break;
2015           }
2016           hr = S_OK;
2017           psd->str.uType = STRRET_CSTRA;
2018         }
2019
2020         return hr;
2021 }
2022 static HRESULT WINAPI ISF_Desktop_fnMapNameToSCID(
2023         IShellFolder2 * iface,
2024         LPCWSTR pwszName,
2025         SHCOLUMNID *pscid)
2026 {
2027         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2028         FIXME("(%p)\n",This);
2029         return E_NOTIMPL;
2030 }
2031
2032 static ICOM_VTABLE(IShellFolder2) sfdvt =
2033 {
2034         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2035         ISF_Desktop_fnQueryInterface,
2036         IShellFolder_fnAddRef,
2037         IShellFolder_fnRelease,
2038         ISF_Desktop_fnParseDisplayName,
2039         ISF_Desktop_fnEnumObjects,
2040         ISF_Desktop_fnBindToObject,
2041         IShellFolder_fnBindToStorage,
2042         IShellFolder_fnCompareIDs,
2043         ISF_Desktop_fnCreateViewObject,
2044         ISF_Desktop_fnGetAttributesOf,
2045         IShellFolder_fnGetUIObjectOf,
2046         ISF_Desktop_fnGetDisplayNameOf,
2047         IShellFolder_fnSetNameOf,
2048
2049         /* ShellFolder2 */
2050         ISF_Desktop_fnGetDefaultSearchGUID,
2051         ISF_Desktop_fnEnumSearches,
2052         ISF_Desktop_fnGetDefaultColumn,
2053         ISF_Desktop_fnGetDefaultColumnState,
2054         ISF_Desktop_fnGetDetailsEx,
2055         ISF_Desktop_fnGetDetailsOf,
2056         ISF_Desktop_fnMapNameToSCID
2057 };
2058
2059
2060 /***********************************************************************
2061 *   IShellFolder [MyComputer] implementation
2062 */
2063
2064 static struct ICOM_VTABLE(IShellFolder2) sfmcvt;
2065
2066 static shvheader MyComputerSFHeader [] =
2067 {
2068  { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
2069  { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2070  { IDS_SHV_COLUMN6, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2071  { IDS_SHV_COLUMN7, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2072 };
2073 #define MYCOMPUTERSHELLVIEWCOLUMNS 4
2074
2075 /**************************************************************************
2076 *       ISF_MyComputer_Constructor
2077 */
2078 static IShellFolder * ISF_MyComputer_Constructor(void)
2079 {
2080         IGenericSFImpl *        sf;
2081
2082         sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
2083         sf->ref=1;
2084
2085         ICOM_VTBL(sf)=&unkvt;
2086         sf->lpvtblShellFolder=&sfmcvt;
2087         sf->lpvtblPersistFolder2 = &psfvt;
2088         sf->pclsid = (CLSID*)&CLSID_SFMyComp;
2089         sf->absPidl=_ILCreateMyComputer();      /* my qualified pidl */
2090         sf->pUnkOuter = (IUnknown *) &sf->lpVtbl;
2091
2092         TRACE("(%p)\n",sf);
2093
2094         shell32_ObjCount++;
2095         return _IShellFolder_(sf);
2096 }
2097
2098 /**************************************************************************
2099 *       ISF_MyComputer_fnParseDisplayName
2100 */
2101 static HRESULT WINAPI ISF_MyComputer_fnParseDisplayName(
2102         IShellFolder2 * iface,
2103         HWND hwndOwner,
2104         LPBC pbcReserved,
2105         LPOLESTR lpszDisplayName,
2106         DWORD *pchEaten,
2107         LPITEMIDLIST *ppidl,
2108         DWORD *pdwAttributes)
2109 {
2110         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2111
2112         HRESULT         hr = E_OUTOFMEMORY;
2113         LPCWSTR         szNext=NULL;
2114         WCHAR           szElement[MAX_PATH];
2115         CHAR            szTempA[MAX_PATH];
2116         LPITEMIDLIST    pidlTemp;
2117
2118         TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
2119         This,hwndOwner,pbcReserved,lpszDisplayName,
2120         debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
2121
2122         *ppidl = 0;
2123         if (pchEaten) *pchEaten = 0;    /* strange but like the original */
2124
2125         /* do we have an absolute path name ? */
2126         if (PathGetDriveNumberW(lpszDisplayName) >= 0 &&
2127             lpszDisplayName[2] == (WCHAR)'\\')
2128         {
2129           szNext = GetNextElementW(lpszDisplayName, szElement, MAX_PATH);
2130           lstrcpynWtoA(szTempA, szElement, lstrlenW(szElement) + 1);
2131           pidlTemp = _ILCreateDrive(szTempA);
2132
2133           if (szNext && *szNext)
2134           {
2135             hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
2136           }
2137           else
2138           {
2139             if (pdwAttributes && *pdwAttributes)
2140             {
2141               SHELL32_GetItemAttributes(_IShellFolder_(This), pidlTemp, pdwAttributes);
2142             }
2143             hr = S_OK;
2144           }
2145           *ppidl = pidlTemp;
2146         }
2147
2148         TRACE("(%p)->(-- ret=0x%08lx)\n", This, hr);
2149
2150         return hr;
2151 }
2152
2153 /**************************************************************************
2154 *               ISF_MyComputer_fnEnumObjects
2155 */
2156 static HRESULT WINAPI ISF_MyComputer_fnEnumObjects(
2157         IShellFolder2 * iface,
2158         HWND hwndOwner,
2159         DWORD dwFlags,
2160         LPENUMIDLIST* ppEnumIDList)
2161 {
2162         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2163
2164         TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
2165
2166         *ppEnumIDList = NULL;
2167         *ppEnumIDList = IEnumIDList_Constructor (NULL, dwFlags, EIDL_MYCOMP);
2168
2169         TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
2170
2171         if(!*ppEnumIDList) return E_OUTOFMEMORY;
2172
2173         return S_OK;
2174 }
2175
2176 /**************************************************************************
2177 *               ISF_MyComputer_fnBindToObject
2178 */
2179 static HRESULT WINAPI ISF_MyComputer_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
2180                         LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
2181 {
2182         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2183         GUID            const * clsid;
2184         IShellFolder    *pShellFolder, *pSubFolder;
2185         LPITEMIDLIST    pidltemp;
2186
2187         TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",
2188               This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
2189
2190         if(!pidl || !ppvOut) return E_INVALIDARG;
2191
2192         *ppvOut = NULL;
2193
2194         if ((clsid=_ILGetGUIDPointer(pidl)) && !IsEqualIID(clsid, &CLSID_MyComputer))
2195         {
2196            if (!SUCCEEDED(SHELL32_CoCreateInitSF (This->absPidl, pidl, clsid, riid, (LPVOID*)&pShellFolder)))
2197            {
2198              return E_FAIL;
2199            }
2200         }
2201         else
2202         {
2203           if (!_ILIsDrive(pidl)) return E_INVALIDARG;
2204
2205           pidltemp = ILCloneFirst(pidl);
2206           pShellFolder = IShellFolder_Constructor(iface, pidltemp);
2207           ILFree(pidltemp);
2208         }
2209
2210         if (_ILIsPidlSimple(pidl))      /* no sub folders */
2211         {
2212           *ppvOut = pShellFolder;
2213         }
2214         else                            /* go deeper */
2215         {
2216           IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, &IID_IShellFolder, (LPVOID)&pSubFolder);
2217           IShellFolder_Release(pShellFolder);
2218           *ppvOut = pSubFolder;
2219         }
2220
2221         TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
2222
2223         return S_OK;
2224 }
2225
2226 /**************************************************************************
2227 *       ISF_MyComputer_fnCreateViewObject
2228 */
2229 static HRESULT WINAPI ISF_MyComputer_fnCreateViewObject( IShellFolder2 * iface,
2230                  HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
2231 {
2232         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2233
2234         LPSHELLVIEW     pShellView;
2235         HRESULT         hr = E_INVALIDARG;
2236
2237         TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
2238
2239         if(ppvOut)
2240         {
2241           *ppvOut = NULL;
2242
2243           if(IsEqualIID(riid, &IID_IDropTarget))
2244           {
2245             WARN("IDropTarget not implemented\n");
2246             hr = E_NOTIMPL;
2247           }
2248           else if(IsEqualIID(riid, &IID_IContextMenu))
2249           {
2250             WARN("IContextMenu not implemented\n");
2251             hr = E_NOTIMPL;
2252           }
2253           else if(IsEqualIID(riid, &IID_IShellView))
2254           {
2255             pShellView = IShellView_Constructor((IShellFolder*)iface);
2256             if(pShellView)
2257             {
2258               hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
2259               IShellView_Release(pShellView);
2260             }
2261           }
2262         }
2263         TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
2264         return hr;
2265 }
2266
2267 /**************************************************************************
2268 *  ISF_MyComputer_fnGetAttributesOf
2269 */
2270 static HRESULT WINAPI ISF_MyComputer_fnGetAttributesOf(
2271         IShellFolder2 * iface,
2272         UINT cidl,
2273         LPCITEMIDLIST *apidl,
2274         DWORD *rgfInOut)
2275 {
2276         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2277
2278         HRESULT         hr = S_OK;
2279
2280         TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl,*rgfInOut);
2281
2282         if ( (!cidl) || (!apidl) || (!rgfInOut))
2283           return E_INVALIDARG;
2284
2285         while (cidl > 0 && *apidl)
2286         {
2287           pdump (*apidl);
2288           SHELL32_GetItemAttributes(_IShellFolder_(This), *apidl, rgfInOut);
2289           apidl++;
2290           cidl--;
2291         }
2292
2293         TRACE("-- result=0x%08lx\n",*rgfInOut);
2294         return hr;
2295 }
2296
2297 /**************************************************************************
2298 *       ISF_MyComputer_fnGetDisplayNameOf
2299 *
2300 * NOTES
2301 *       The desktopfolder creates only complete paths (SHGDN_FORPARSING).
2302 *       SHGDN_INFOLDER makes no sense.
2303 */
2304 static HRESULT WINAPI ISF_MyComputer_fnGetDisplayNameOf(
2305         IShellFolder2 * iface,
2306         LPCITEMIDLIST pidl,
2307         DWORD dwFlags,
2308         LPSTRRET strRet)
2309 {
2310         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2311
2312         char            szPath[MAX_PATH], szDrive[18];
2313         int             len = 0;
2314         BOOL            bSimplePidl;
2315
2316         TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
2317         pdump(pidl);
2318
2319         if(!strRet) return E_INVALIDARG;
2320
2321         szPath[0]=0x00; szDrive[0]=0x00;
2322
2323
2324         bSimplePidl = _ILIsPidlSimple(pidl);
2325
2326         if (_ILIsSpecialFolder(pidl))
2327         {
2328           /* take names of special folders only if its only this folder */
2329           if ( bSimplePidl )
2330           {
2331             _ILSimpleGetText(pidl, szPath, MAX_PATH); /* append my own path */
2332           }
2333         }
2334         else
2335         {
2336           if (!_ILIsDrive(pidl))
2337           {
2338             ERR("Wrong pidl type\n");
2339             return E_INVALIDARG;
2340           }
2341
2342           _ILSimpleGetText(pidl, szPath, MAX_PATH);     /* append my own path */
2343
2344           /* long view "lw_name (C:)" */
2345           if ( bSimplePidl && !(dwFlags & SHGDN_FORPARSING))
2346           {
2347             DWORD dwVolumeSerialNumber,dwMaximumComponetLength,dwFileSystemFlags;
2348
2349             GetVolumeInformationA(szPath,szDrive,12,&dwVolumeSerialNumber,&dwMaximumComponetLength,&dwFileSystemFlags,NULL,0);
2350             strcat (szDrive," (");
2351             strncat (szDrive, szPath, 2);
2352             strcat (szDrive,")");
2353             strcpy (szPath, szDrive);
2354           }
2355         }
2356
2357         if (!bSimplePidl)       /* go deeper if needed */
2358         {
2359           PathAddBackslashA(szPath);
2360           len = strlen(szPath);
2361
2362           if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags | SHGDN_FORPARSING, szPath + len, MAX_PATH - len)))
2363             return E_OUTOFMEMORY;
2364         }
2365         strRet->uType = STRRET_CSTRA;
2366         lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
2367
2368
2369         TRACE("-- (%p)->(%s)\n", This, szPath);
2370         return S_OK;
2371 }
2372
2373 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultSearchGUID(
2374         IShellFolder2 * iface,
2375         GUID *pguid)
2376 {
2377         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2378         FIXME("(%p)\n",This);
2379         return E_NOTIMPL;
2380 }
2381 static HRESULT WINAPI ISF_MyComputer_fnEnumSearches(
2382         IShellFolder2 * iface,
2383         IEnumExtraSearch **ppenum)
2384 {
2385         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2386         FIXME("(%p)\n",This);
2387         return E_NOTIMPL;
2388 }
2389 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumn(
2390         IShellFolder2 * iface,
2391         DWORD dwRes,
2392         ULONG *pSort,
2393         ULONG *pDisplay)
2394 {
2395         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2396
2397         TRACE("(%p)\n",This);
2398
2399         if (pSort) *pSort = 0;
2400         if (pDisplay) *pDisplay = 0;
2401
2402         return S_OK;
2403 }
2404 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumnState(
2405         IShellFolder2 * iface,
2406         UINT iColumn,
2407         DWORD *pcsFlags)
2408 {
2409         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2410
2411         TRACE("(%p)\n",This);
2412
2413         if (!pcsFlags || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS ) return E_INVALIDARG;
2414
2415         *pcsFlags = MyComputerSFHeader[iColumn].pcsFlags;
2416
2417         return S_OK;
2418 }
2419 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsEx(
2420         IShellFolder2 * iface,
2421         LPCITEMIDLIST pidl,
2422         const SHCOLUMNID *pscid,
2423         VARIANT *pv)
2424 {
2425         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2426         FIXME("(%p)\n",This);
2427
2428         return E_NOTIMPL;
2429 }
2430
2431 /* fixme: drive size >4GB is rolling over */
2432 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsOf(
2433         IShellFolder2 * iface,
2434         LPCITEMIDLIST pidl,
2435         UINT iColumn,
2436         SHELLDETAILS *psd)
2437 {
2438         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2439         HRESULT hr;
2440
2441         TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
2442
2443         if (!psd || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS ) return E_INVALIDARG;
2444
2445         if (!pidl)
2446         {
2447           psd->fmt = MyComputerSFHeader[iColumn].fmt;
2448           psd->cxChar = MyComputerSFHeader[iColumn].cxChar;
2449           psd->str.uType = STRRET_CSTRA;
2450           LoadStringA(shell32_hInstance, MyComputerSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
2451           return S_OK;
2452         }
2453         else
2454         {
2455           char szPath[MAX_PATH];
2456           ULARGE_INTEGER ulBytes;
2457
2458           psd->str.u.cStr[0] = 0x00;
2459           psd->str.uType = STRRET_CSTRA;
2460           switch(iColumn)
2461           {
2462             case 0:     /* name */
2463               hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
2464               break;
2465             case 1:     /* type */
2466               _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
2467               break;
2468             case 2:     /* total size */
2469               if (_ILIsDrive(pidl))
2470               {
2471                 _ILSimpleGetText(pidl, szPath, MAX_PATH);
2472                 GetDiskFreeSpaceExA(szPath, NULL, &ulBytes, NULL);
2473                 StrFormatByteSizeA(ulBytes.s.LowPart, psd->str.u.cStr, MAX_PATH);
2474               }
2475               break;
2476             case 3:     /* free size */
2477               if (_ILIsDrive(pidl))
2478               {
2479                 _ILSimpleGetText(pidl, szPath, MAX_PATH);
2480                 GetDiskFreeSpaceExA(szPath, &ulBytes, NULL, NULL);
2481                 StrFormatByteSizeA(ulBytes.s.LowPart, psd->str.u.cStr, MAX_PATH);
2482               }
2483               break;
2484           }
2485           hr = S_OK;
2486         }
2487
2488         return hr;
2489 }
2490 static HRESULT WINAPI ISF_MyComputer_fnMapNameToSCID(
2491         IShellFolder2 * iface,
2492         LPCWSTR pwszName,
2493         SHCOLUMNID *pscid)
2494 {
2495         _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2496         FIXME("(%p)\n",This);
2497         return E_NOTIMPL;
2498 }
2499
2500 static ICOM_VTABLE(IShellFolder2) sfmcvt =
2501 {
2502         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2503         IShellFolder_fnQueryInterface,
2504         IShellFolder_fnAddRef,
2505         IShellFolder_fnRelease,
2506         ISF_MyComputer_fnParseDisplayName,
2507         ISF_MyComputer_fnEnumObjects,
2508         ISF_MyComputer_fnBindToObject,
2509         IShellFolder_fnBindToStorage,
2510         IShellFolder_fnCompareIDs,
2511         ISF_MyComputer_fnCreateViewObject,
2512         ISF_MyComputer_fnGetAttributesOf,
2513         IShellFolder_fnGetUIObjectOf,
2514         ISF_MyComputer_fnGetDisplayNameOf,
2515         IShellFolder_fnSetNameOf,
2516
2517         /* ShellFolder2 */
2518         ISF_MyComputer_fnGetDefaultSearchGUID,
2519         ISF_MyComputer_fnEnumSearches,
2520         ISF_MyComputer_fnGetDefaultColumn,
2521         ISF_MyComputer_fnGetDefaultColumnState,
2522         ISF_MyComputer_fnGetDetailsEx,
2523         ISF_MyComputer_fnGetDetailsOf,
2524         ISF_MyComputer_fnMapNameToSCID
2525 };
2526
2527
2528 /************************************************************************
2529  * ISFPersistFolder_QueryInterface (IUnknown)
2530  *
2531  */
2532 static HRESULT WINAPI ISFPersistFolder2_QueryInterface(
2533         IPersistFolder2 *       iface,
2534         REFIID                  iid,
2535         LPVOID*                 ppvObj)
2536 {
2537         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2538
2539         TRACE("(%p)\n", This);
2540
2541         return IUnknown_QueryInterface(This->pUnkOuter, iid, ppvObj);
2542 }
2543
2544 /************************************************************************
2545  * ISFPersistFolder_AddRef (IUnknown)
2546  *
2547  */
2548 static ULONG WINAPI ISFPersistFolder2_AddRef(
2549         IPersistFolder2 *       iface)
2550 {
2551         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2552
2553         TRACE("(%p)\n", This);
2554
2555         return IUnknown_AddRef(This->pUnkOuter);
2556 }
2557
2558 /************************************************************************
2559  * ISFPersistFolder_Release (IUnknown)
2560  *
2561  */
2562 static ULONG WINAPI ISFPersistFolder2_Release(
2563         IPersistFolder2 *       iface)
2564 {
2565         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2566
2567         TRACE("(%p)\n", This);
2568
2569         return IUnknown_Release(This->pUnkOuter);
2570 }
2571
2572 /************************************************************************
2573  * ISFPersistFolder_GetClassID (IPersist)
2574  */
2575 static HRESULT WINAPI ISFPersistFolder2_GetClassID(
2576         IPersistFolder2 *       iface,
2577         CLSID *                 lpClassId)
2578 {
2579         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2580
2581         TRACE("(%p)\n", This);
2582
2583         if (!lpClassId) return E_POINTER;
2584         *lpClassId = *This->pclsid;
2585
2586         return S_OK;
2587 }
2588
2589 /************************************************************************
2590  * ISFPersistFolder_Initialize (IPersistFolder)
2591  *
2592  * NOTES
2593  *  sMyPath is not set. Don't know how to handle in a non rooted environment.
2594  */
2595 static HRESULT WINAPI ISFPersistFolder2_Initialize(
2596         IPersistFolder2 *       iface,
2597         LPCITEMIDLIST           pidl)
2598 {
2599         char sTemp[MAX_PATH];
2600         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2601
2602         TRACE("(%p)->(%p)\n", This, pidl);
2603
2604         /* free the old stuff */
2605         if(This->absPidl)
2606         {
2607           SHFree(This->absPidl);
2608           This->absPidl = NULL;
2609         }
2610         if(This->sMyPath)
2611         {
2612           SHFree(This->sMyPath);
2613           This->sMyPath = NULL;
2614         }
2615
2616         /* set my pidl */
2617         This->absPidl = ILClone(pidl);
2618
2619         /* set my path */
2620         if (SHGetPathFromIDListA(pidl, sTemp))
2621         {
2622           This->sMyPath = SHAlloc(strlen(sTemp)+1);
2623           strcpy(This->sMyPath, sTemp);
2624         }
2625
2626         TRACE("--(%p)->(%s)\n", This, This->sMyPath);
2627
2628         return S_OK;
2629 }
2630
2631 /**************************************************************************
2632 *  IPersistFolder2_fnGetCurFolder
2633 */
2634 static HRESULT WINAPI ISFPersistFolder2_fnGetCurFolder(
2635         IPersistFolder2 *       iface,
2636         LPITEMIDLIST * pidl)
2637 {
2638         _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2639
2640         TRACE("(%p)->(%p)\n",This, pidl);
2641
2642         if (!pidl) return E_POINTER;
2643
2644         *pidl = ILClone(This->absPidl);
2645
2646         return S_OK;
2647 }
2648
2649 static ICOM_VTABLE(IPersistFolder2) psfvt =
2650 {
2651         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2652         ISFPersistFolder2_QueryInterface,
2653         ISFPersistFolder2_AddRef,
2654         ISFPersistFolder2_Release,
2655         ISFPersistFolder2_GetClassID,
2656         ISFPersistFolder2_Initialize,
2657         ISFPersistFolder2_fnGetCurFolder
2658 };
2659
2660 /****************************************************************************
2661  * ISFDropTarget implementation
2662  */
2663 static BOOL ISFDropTarget_QueryDrop(
2664         IDropTarget *iface,
2665         DWORD dwKeyState,
2666         LPDWORD pdwEffect)
2667 {
2668         DWORD dwEffect = *pdwEffect;
2669
2670         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2671
2672         *pdwEffect = DROPEFFECT_NONE;
2673
2674         if (This->fAcceptFmt)
2675         { /* Does our interpretation of the keystate ... */
2676           *pdwEffect = KeyStateToDropEffect(dwKeyState);
2677
2678           /* ... matches the desired effect ? */
2679           if (dwEffect & *pdwEffect)
2680           {
2681             return TRUE;
2682           }
2683         }
2684         return FALSE;
2685 }
2686
2687 static HRESULT WINAPI ISFDropTarget_QueryInterface(
2688         IDropTarget *iface,
2689         REFIID riid,
2690         LPVOID *ppvObj)
2691 {
2692         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2693
2694         TRACE("(%p)\n", This);
2695
2696         return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
2697 }
2698
2699 static ULONG WINAPI ISFDropTarget_AddRef( IDropTarget *iface)
2700 {
2701         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2702
2703         TRACE("(%p)\n", This);
2704
2705         return IUnknown_AddRef(This->pUnkOuter);
2706 }
2707
2708 static ULONG WINAPI ISFDropTarget_Release( IDropTarget *iface)
2709 {
2710         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2711
2712         TRACE("(%p)\n", This);
2713
2714         return IUnknown_Release(This->pUnkOuter);
2715 }
2716
2717 static HRESULT WINAPI ISFDropTarget_DragEnter(
2718         IDropTarget     *iface,
2719         IDataObject     *pDataObject,
2720         DWORD           dwKeyState,
2721         POINTL          pt,
2722         DWORD           *pdwEffect)
2723 {
2724         FORMATETC       fmt;
2725
2726         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2727
2728         TRACE("(%p)->(DataObject=%p)\n",This,pDataObject);
2729
2730         InitFormatEtc(fmt, This->cfShellIDList, TYMED_HGLOBAL);
2731
2732         This->fAcceptFmt = (S_OK == IDataObject_QueryGetData(pDataObject, &fmt)) ? TRUE : FALSE;
2733
2734         ISFDropTarget_QueryDrop(iface, dwKeyState, pdwEffect);
2735
2736         return S_OK;
2737 }
2738
2739 static HRESULT WINAPI ISFDropTarget_DragOver(
2740         IDropTarget     *iface,
2741         DWORD           dwKeyState,
2742         POINTL          pt,
2743         DWORD           *pdwEffect)
2744 {
2745         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2746
2747         TRACE("(%p)\n",This);
2748
2749         if(!pdwEffect) return E_INVALIDARG;
2750
2751         ISFDropTarget_QueryDrop(iface, dwKeyState, pdwEffect);
2752
2753         return S_OK;
2754 }
2755
2756 static HRESULT WINAPI ISFDropTarget_DragLeave(
2757         IDropTarget     *iface)
2758 {
2759         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2760
2761         TRACE("(%p)\n",This);
2762
2763         This->fAcceptFmt = FALSE;
2764
2765         return S_OK;
2766 }
2767
2768 static HRESULT WINAPI ISFDropTarget_Drop(
2769         IDropTarget     *iface,
2770         IDataObject*    pDataObject,
2771         DWORD           dwKeyState,
2772         POINTL          pt,
2773         DWORD           *pdwEffect)
2774 {
2775         _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2776
2777         FIXME("(%p) object dropped\n",This);
2778
2779         return E_NOTIMPL;
2780 }
2781
2782 static struct ICOM_VTABLE(IDropTarget) dtvt =
2783 {
2784         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2785         ISFDropTarget_QueryInterface,
2786         ISFDropTarget_AddRef,
2787         ISFDropTarget_Release,
2788         ISFDropTarget_DragEnter,
2789         ISFDropTarget_DragOver,
2790         ISFDropTarget_DragLeave,
2791         ISFDropTarget_Drop
2792 };