dlls/shell32/shfldr_fs.c

   1
   2 /*
   3  * file system folder
   4  *
   5  * Copyright 1997             Marcus Meissner
   6  * Copyright 1998, 1999, 2002 Juergen Schmied
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30
  31 #define COBJMACROS
  32 #define NONAMELESSUNION
  33
  34 #include "winerror.h"
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winreg.h"
  38 #include "wingdi.h"
  39 #include "winuser.h"
  40
  41 #include "ole2.h"
  42 #include "shlguid.h"
  43
  44 #include "pidl.h"
  45 #include "undocshell.h"
  46 #include "shell32_main.h"
  47 #include "shresdef.h"
  48 #include "shlwapi.h"
  49 #include "shellfolder.h"
  50 #include "wine/debug.h"
  51 #include "debughlp.h"
  52 #include "shfldr.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL (shell);
  55
  56 /***********************************************************************
  57 *   IShellFolder implementation
  58 */
  59
  60 typedef struct {
  61     IUnknown IUnknown_inner;
  62     LONG ref;
  63     IShellFolder2 IShellFolder2_iface;
  64     IPersistFolder3 IPersistFolder3_iface;
  65     IDropTarget IDropTarget_iface;
  66     ISFHelper ISFHelper_iface;
  67     IUnknown *outer_unk;
  68
  69     CLSID *pclsid;
  70
  71     /* both paths are parsible from the desktop */
  72     LPWSTR sPathTarget;     /* complete path to target used for enumeration and ChangeNotify */
  73
  74     LPITEMIDLIST pidlRoot; /* absolute pidl */
  75
  76     UINT cfShellIDList;    /* clipboardformat for IDropTarget */
  77     BOOL fAcceptFmt;       /* flag for pending Drop */
  78 } IGenericSFImpl;
  79
  80 static inline IGenericSFImpl *impl_from_IUnknown(IUnknown *iface)
  81 {
  82     return CONTAINING_RECORD(iface, IGenericSFImpl, IUnknown_inner);
  83 }
  84
  85 static inline IGenericSFImpl *impl_from_IShellFolder2(IShellFolder2 *iface)
  86 {
  87     return CONTAINING_RECORD(iface, IGenericSFImpl, IShellFolder2_iface);
  88 }
  89
  90 static inline IGenericSFImpl *impl_from_IPersistFolder3(IPersistFolder3 *iface)
  91 {
  92     return CONTAINING_RECORD(iface, IGenericSFImpl, IPersistFolder3_iface);
  93 }
  94
  95 static inline IGenericSFImpl *impl_from_IDropTarget(IDropTarget *iface)
  96 {
  97     return CONTAINING_RECORD(iface, IGenericSFImpl, IDropTarget_iface);
  98 }
  99
 100 static inline IGenericSFImpl *impl_from_ISFHelper(ISFHelper *iface)
 101 {
 102     return CONTAINING_RECORD(iface, IGenericSFImpl, ISFHelper_iface);
 103 }
 104
 105 /**************************************************************************
 106 * registers clipboardformat once
 107 */
 108 static void SF_RegisterClipFmt (IGenericSFImpl * This)
 109 {
 110     TRACE ("(%p)\n", This);
 111
 112     if (!This->cfShellIDList) {
 113         This->cfShellIDList = RegisterClipboardFormatW (CFSTR_SHELLIDLISTW);
 114     }
 115 }
 116
 117 /**************************************************************************
 118 * inner IUnknown
 119 */
 120 static HRESULT WINAPI IUnknown_fnQueryInterface(IUnknown *iface, REFIID riid, void **ppvObj)
 121 {
 122     IGenericSFImpl *This = impl_from_IUnknown(iface);
 123
 124     TRACE("(%p)->(%s,%p)\n", This, shdebugstr_guid(riid), ppvObj);
 125
 126     *ppvObj = NULL;
 127
 128     if (IsEqualIID (riid, &IID_IUnknown))
 129         *ppvObj = &This->IUnknown_inner;
 130     else if (IsEqualIID(riid, &IID_IShellFolder) || IsEqualIID(riid, &IID_IShellFolder2))
 131         *ppvObj = &This->IShellFolder2_iface;
 132     else if (IsEqualIID(riid, &IID_IPersist) || IsEqualIID(riid, &IID_IPersistFolder) ||
 133             IsEqualIID(riid, &IID_IPersistFolder2) || IsEqualIID(riid, &IID_IPersistFolder3))
 134         *ppvObj = &This->IPersistFolder3_iface;
 135     else if (IsEqualIID (riid, &IID_ISFHelper))
 136         *ppvObj = &This->ISFHelper_iface;
 137     else if (IsEqualIID (riid, &IID_IDropTarget)) {
 138         *ppvObj = &This->IDropTarget_iface;
 139         SF_RegisterClipFmt(This);
 140     }
 141
 142     if (*ppvObj) {
 143         IUnknown_AddRef((IUnknown *)*ppvObj);
 144         TRACE ("-- Interface = %p\n", *ppvObj);
 145         return S_OK;
 146     }
 147     TRACE ("-- Interface: E_NOINTERFACE\n");
 148     return E_NOINTERFACE;
 149 }
 150
 151 static ULONG WINAPI IUnknown_fnAddRef(IUnknown *iface)
 152 {
 153     IGenericSFImpl *This = impl_from_IUnknown(iface);
 154     ULONG ref = InterlockedIncrement(&This->ref);
 155
 156     TRACE("(%p) ref=%d\n", This, ref);
 157
 158     return ref;
 159 }
 160
 161 static ULONG WINAPI IUnknown_fnRelease(IUnknown *iface)
 162 {
 163     IGenericSFImpl *This = impl_from_IUnknown(iface);
 164     ULONG ref = InterlockedDecrement(&This->ref);
 165
 166     TRACE("(%p) ref=%d\n", This, ref);
 167
 168     if (!ref) {
 169         TRACE("-- destroying IShellFolder(%p)\n", This);
 170
 171         SHFree(This->pidlRoot);
 172         SHFree(This->sPathTarget);
 173         LocalFree(This);
 174     }
 175     return ref;
 176 }
 177
 178 static const IUnknownVtbl unkvt =
 179 {
 180       IUnknown_fnQueryInterface,
 181       IUnknown_fnAddRef,
 182       IUnknown_fnRelease,
 183 };
 184
 185 static const shvheader GenericSFHeader[] =
 186 {
 187     { &FMTID_Storage, PID_STG_NAME,        IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 15 },
 188     { &FMTID_Storage, PID_STG_SIZE,        IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 10 },
 189     { &FMTID_Storage, PID_STG_STORAGETYPE, IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 10 },
 190     { &FMTID_Storage, PID_STG_WRITETIME,   IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12 },
 191     { &FMTID_Storage, PID_STG_ATTRIBUTES,  IDS_SHV_COLUMN5, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 5  },
 192 };
 193
 194 #define GENERICSHELLVIEWCOLUMNS 5
 195
 196 /**************************************************************************
 197  *  IShellFolder_fnQueryInterface
 198  */
 199 static HRESULT WINAPI IShellFolder_fnQueryInterface(IShellFolder2 *iface, REFIID riid,
 200         void **ppvObj)
 201 {
 202     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 203
 204     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
 205 }
 206
 207 /**************************************************************************
 208 *  IShellFolder_AddRef
 209 */
 210 static ULONG WINAPI IShellFolder_fnAddRef(IShellFolder2 *iface)
 211 {
 212     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 213
 214     return IUnknown_AddRef(This->outer_unk);
 215 }
 216
 217 /**************************************************************************
 218  *  IShellFolder_fnRelease
 219  */
 220 static ULONG WINAPI IShellFolder_fnRelease(IShellFolder2 *iface)
 221 {
 222     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 223
 224     return IUnknown_Release(This->outer_unk);
 225 }
 226
 227 /**************************************************************************
 228  *  SHELL32_CreatePidlFromBindCtx  [internal]
 229  *
 230  *  If the caller bound File System Bind Data, assume it is the
 231  *   find data for the path.
 232  *  This allows binding of paths that don't exist.
 233  */
 234 LPITEMIDLIST SHELL32_CreatePidlFromBindCtx(IBindCtx *pbc, LPCWSTR path)
 235 {
 236     static WCHAR szfsbc[] = {
 237         'F','i','l','e',' ','S','y','s','t','e','m',' ',
 238         'B','i','n','d',' ','D','a','t','a',0 };
 239     IFileSystemBindData *fsbd = NULL;
 240     LPITEMIDLIST pidl = NULL;
 241     IUnknown *unk = NULL;
 242     HRESULT r;
 243
 244     TRACE("%p %s\n", pbc, debugstr_w(path));
 245
 246     if (!pbc)
 247         return NULL;
 248
 249     /* see if the caller bound File System Bind Data */
 250     r = IBindCtx_GetObjectParam( pbc, szfsbc, &unk );
 251     if (FAILED(r))
 252         return NULL;
 253
 254     r = IUnknown_QueryInterface( unk, &IID_IFileSystemBindData, (void**)&fsbd );
 255     if (SUCCEEDED(r))
 256     {
 257         WIN32_FIND_DATAW wfd;
 258
 259         r = IFileSystemBindData_GetFindData( fsbd, &wfd );
 260         if (SUCCEEDED(r))
 261         {
 262             lstrcpynW( &wfd.cFileName[0], path, MAX_PATH );
 263             pidl = _ILCreateFromFindDataW( &wfd );
 264         }
 265         IFileSystemBindData_Release( fsbd );
 266     }
 267     IUnknown_Release( unk );
 268
 269     return pidl;
 270 }
 271
 272 /**************************************************************************
 273 * IShellFolder_ParseDisplayName {SHELL32}
 274 *
 275 * Parse a display name.
 276 *
 277 * PARAMS
 278 *  hwndOwner       [in]  Parent window for any message's
 279 *  pbc             [in]  optional FileSystemBindData context
 280 *  lpszDisplayName [in]  Unicode displayname.
 281 *  pchEaten        [out] (unicode) characters processed
 282 *  ppidl           [out] complex pidl to item
 283 *  pdwAttributes   [out] items attributes
 284 *
 285 * NOTES
 286 *  Every folder tries to parse only its own (the leftmost) pidl and creates a
 287 *  subfolder to evaluate the remaining parts.
 288 *  Now we can parse into namespaces implemented by shell extensions
 289 *
 290 *  Behaviour on win98: lpszDisplayName=NULL -> crash
 291 *                      lpszDisplayName="" -> returns mycomputer-pidl
 292 *
 293 * FIXME
 294 *    pdwAttributes is not set
 295 *    pchEaten is not set like in windows
 296 */
 297 static HRESULT WINAPI
 298 IShellFolder_fnParseDisplayName (IShellFolder2 * iface,
 299                                  HWND hwndOwner,
 300                                  LPBC pbc,
 301                                  LPOLESTR lpszDisplayName,
 302                                  DWORD * pchEaten, LPITEMIDLIST * ppidl,
 303                                  DWORD * pdwAttributes)
 304 {
 305     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 306
 307     HRESULT hr = E_INVALIDARG;
 308     LPCWSTR szNext = NULL;
 309     WCHAR szElement[MAX_PATH];
 310     WCHAR szPath[MAX_PATH];
 311     LPITEMIDLIST pidlTemp = NULL;
 312     DWORD len;
 313
 314     TRACE ("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n",
 315      This, hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
 316      pchEaten, ppidl, pdwAttributes);
 317
 318     if (!lpszDisplayName || !ppidl)
 319         return E_INVALIDARG;
 320
 321     if (pchEaten)
 322         *pchEaten = 0; /* strange but like the original */
 323
 324     pidlTemp = SHELL32_CreatePidlFromBindCtx(pbc, lpszDisplayName);
 325     if (!pidlTemp && *lpszDisplayName)
 326     {
 327         /* get the next element */
 328         szNext = GetNextElementW (lpszDisplayName, szElement, MAX_PATH);
 329
 330         /* build the full pathname to the element */
 331         lstrcpynW(szPath, This->sPathTarget, MAX_PATH - 1);
 332         PathAddBackslashW(szPath);
 333         len = lstrlenW(szPath);
 334         lstrcpynW(szPath + len, szElement, MAX_PATH - len);
 335
 336         /* get the pidl */
 337         hr = _ILCreateFromPathW(szPath, &pidlTemp);
 338
 339         if (SUCCEEDED(hr)) {
 340             if (szNext && *szNext) {
 341                 /* try to analyse the next element */
 342                 hr = SHELL32_ParseNextElement (iface, hwndOwner, pbc,
 343                  &pidlTemp, (LPOLESTR) szNext, pchEaten, pdwAttributes);
 344             } else {
 345                 /* it's the last element */
 346                 if (pdwAttributes && *pdwAttributes)
 347                     hr = SHELL32_GetItemAttributes(&This->IShellFolder2_iface, pidlTemp, pdwAttributes);
 348             }
 349         }
 350     }
 351
 352     if (SUCCEEDED(hr))
 353         *ppidl = pidlTemp;
 354     else
 355         *ppidl = NULL;
 356
 357     TRACE ("(%p)->(-- pidl=%p ret=0x%08x)\n", This, *ppidl, hr);
 358
 359     return hr;
 360 }
 361
 362 /**************************************************************************
 363 * IShellFolder_fnEnumObjects
 364 * PARAMETERS
 365 *  HWND          hwndOwner,    //[in ] Parent Window
 366 *  DWORD         grfFlags,     //[in ] SHCONTF enumeration mask
 367 *  LPENUMIDLIST* ppenumIDList  //[out] IEnumIDList interface
 368 */
 369 static HRESULT WINAPI
 370 IShellFolder_fnEnumObjects (IShellFolder2 * iface, HWND hwndOwner,
 371                             DWORD dwFlags, LPENUMIDLIST * ppEnumIDList)
 372 {
 373     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 374     IEnumIDListImpl *list;
 375
 376     TRACE ("(%p)->(HWND=%p flags=0x%08x pplist=%p)\n", This, hwndOwner,
 377      dwFlags, ppEnumIDList);
 378
 379     if (!(list = IEnumIDList_Constructor()))
 380         return E_OUTOFMEMORY;
 381     CreateFolderEnumList(list, This->sPathTarget, dwFlags);
 382     *ppEnumIDList = &list->IEnumIDList_iface;
 383
 384     TRACE ("-- (%p)->(new ID List: %p)\n", This, *ppEnumIDList);
 385
 386     return S_OK;
 387 }
 388
 389 /**************************************************************************
 390 * IShellFolder_fnBindToObject
 391 * PARAMETERS
 392 *  LPCITEMIDLIST pidl,       //[in ] relative pidl to open
 393 *  LPBC          pbc,        //[in ] optional FileSystemBindData context
 394 *  REFIID        riid,       //[in ] Initial Interface
 395 *  LPVOID*       ppvObject   //[out] Interface*
 396 */
 397 static HRESULT WINAPI
 398 IShellFolder_fnBindToObject (IShellFolder2 * iface, LPCITEMIDLIST pidl,
 399                              LPBC pbc, REFIID riid, LPVOID * ppvOut)
 400 {
 401     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 402
 403     TRACE ("(%p)->(pidl=%p,%p,%s,%p)\n", This, pidl, pbc,
 404      shdebugstr_guid (riid), ppvOut);
 405
 406     return SHELL32_BindToChild (This->pidlRoot, This->sPathTarget, pidl, riid,
 407      ppvOut);
 408 }
 409
 410 /**************************************************************************
 411 *  IShellFolder_fnBindToStorage
 412 * PARAMETERS
 413 *  LPCITEMIDLIST pidl,       //[in ] complex pidl to store
 414 *  LPBC          pbc,        //[in ] reserved
 415 *  REFIID        riid,       //[in ] Initial storage interface
 416 *  LPVOID*       ppvObject   //[out] Interface* returned
 417 */
 418 static HRESULT WINAPI
 419 IShellFolder_fnBindToStorage (IShellFolder2 * iface, LPCITEMIDLIST pidl,
 420                               LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
 421 {
 422     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 423
 424     FIXME ("(%p)->(pidl=%p,%p,%s,%p) stub\n", This, pidl, pbcReserved,
 425      shdebugstr_guid (riid), ppvOut);
 426
 427     *ppvOut = NULL;
 428     return E_NOTIMPL;
 429 }
 430
 431 /**************************************************************************
 432 *  IShellFolder_fnCompareIDs
 433 */
 434
 435 static HRESULT WINAPI
 436 IShellFolder_fnCompareIDs (IShellFolder2 * iface, LPARAM lParam,
 437                            LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 438 {
 439     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 440
 441     int nReturn;
 442
 443     TRACE ("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n", This, lParam, pidl1, pidl2);
 444     nReturn = SHELL32_CompareIDs(&This->IShellFolder2_iface, lParam, pidl1, pidl2);
 445     TRACE ("-- %i\n", nReturn);
 446     return nReturn;
 447 }
 448
 449 /**************************************************************************
 450 * IShellFolder_fnCreateViewObject
 451 */
 452 static HRESULT WINAPI
 453 IShellFolder_fnCreateViewObject (IShellFolder2 * iface, HWND hwndOwner,
 454                                  REFIID riid, LPVOID * ppvOut)
 455 {
 456     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 457
 458     LPSHELLVIEW pShellView;
 459     HRESULT hr = E_INVALIDARG;
 460
 461     TRACE ("(%p)->(hwnd=%p,%s,%p)\n", This, hwndOwner, shdebugstr_guid (riid),
 462      ppvOut);
 463
 464     if (ppvOut) {
 465         *ppvOut = NULL;
 466
 467         if (IsEqualIID (riid, &IID_IDropTarget)) {
 468             hr = IShellFolder2_QueryInterface (iface, &IID_IDropTarget, ppvOut);
 469         } else if (IsEqualIID (riid, &IID_IContextMenu)) {
 470             hr = BackgroundMenu_Constructor((IShellFolder*)iface, FALSE, riid, ppvOut);
 471         } else if (IsEqualIID (riid, &IID_IShellView)) {
 472             pShellView = IShellView_Constructor ((IShellFolder *) iface);
 473             if (pShellView) {
 474                 hr = IShellView_QueryInterface (pShellView, riid, ppvOut);
 475                 IShellView_Release (pShellView);
 476             }
 477         }
 478     }
 479     TRACE ("-- (%p)->(interface=%p)\n", This, ppvOut);
 480     return hr;
 481 }
 482
 483 /**************************************************************************
 484 *  IShellFolder_fnGetAttributesOf
 485 *
 486 * PARAMETERS
 487 *  UINT            cidl,     //[in ] num elements in pidl array
 488 *  LPCITEMIDLIST*  apidl,    //[in ] simple pidl array
 489 *  ULONG*          rgfInOut) //[out] result array
 490 *
 491 */
 492 static HRESULT WINAPI
 493 IShellFolder_fnGetAttributesOf (IShellFolder2 * iface, UINT cidl,
 494                                 LPCITEMIDLIST * apidl, DWORD * rgfInOut)
 495 {
 496     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 497
 498     HRESULT hr = S_OK;
 499
 500     TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n", This, cidl, apidl,
 501      rgfInOut, rgfInOut ? *rgfInOut : 0);
 502
 503     if (!rgfInOut)
 504         return E_INVALIDARG;
 505     if (cidl && !apidl)
 506         return E_INVALIDARG;
 507
 508     if (*rgfInOut == 0)
 509         *rgfInOut = ~0;
 510
 511     if(cidl == 0){
 512         IShellFolder2 *parent = NULL;
 513         LPCITEMIDLIST rpidl = NULL;
 514
 515         hr = SHBindToParent(This->pidlRoot, &IID_IShellFolder2, (void **)&parent, &rpidl);
 516         if(SUCCEEDED(hr)) {
 517             SHELL32_GetItemAttributes(parent, rpidl, rgfInOut);
 518             IShellFolder2_Release(parent);
 519         }
 520     }
 521     else {
 522         while (cidl > 0 && *apidl) {
 523             pdump (*apidl);
 524             SHELL32_GetItemAttributes(&This->IShellFolder2_iface, *apidl, rgfInOut);
 525             apidl++;
 526             cidl--;
 527         }
 528     }
 529     /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
 530     *rgfInOut &= ~SFGAO_VALIDATE;
 531
 532     TRACE ("-- result=0x%08x\n", *rgfInOut);
 533
 534     return hr;
 535 }
 536
 537 /**************************************************************************
 538  * SHELL32_CreateExtensionUIObject (internal)
 539  */
 540 HRESULT SHELL32_CreateExtensionUIObject(IShellFolder2 *iface,
 541         LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
 542 {
 543     static const WCHAR reg_blockedW[] = {'S','o','f','t','w','a','r','e','\\',
 544         'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
 545         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 546         'S','h','e','l','l',' ','E','x','t','e','n','s','i','o','n','s','\\',
 547         'B','l','o','c','k','e','d',0};
 548     static const WCHAR formatW[] = {'.','%','s','\\','S','h','e','l','l','E','x','\\',
 549         '{','%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
 550         '%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x',
 551         '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0};
 552
 553     IPersistFile *persist_file;
 554     char extensionA[20];
 555     WCHAR extensionW[20], buf[MAX_PATH];
 556     DWORD size = MAX_PATH;
 557     STRRET path;
 558     WCHAR *file;
 559     GUID guid;
 560     HKEY key;
 561     HRESULT hr;
 562
 563
 564     if(!_ILGetExtension(pidl, extensionA, 20))
 565         return S_FALSE;
 566
 567     MultiByteToWideChar(CP_ACP, 0, extensionA, -1, extensionW, 20);
 568
 569     sprintfW(buf, formatW, extensionW, riid->Data1, riid->Data2, riid->Data3,
 570             riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
 571             riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 572
 573     if(RegGetValueW(HKEY_CLASSES_ROOT, buf, NULL, RRF_RT_REG_SZ,
 574                 NULL, buf, &size) != ERROR_SUCCESS)
 575         return S_FALSE;
 576
 577     if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, reg_blockedW, 0, 0, 0,
 578                 KEY_READ, NULL, &key, NULL) != ERROR_SUCCESS)
 579         return E_FAIL;
 580     if(RegQueryValueExW(key, buf, 0, NULL, NULL, NULL)
 581             != ERROR_FILE_NOT_FOUND)
 582         return E_ACCESSDENIED;
 583     RegCloseKey(key);
 584
 585     if(RegCreateKeyExW(HKEY_CURRENT_USER, reg_blockedW, 0, 0, 0,
 586                 KEY_READ, NULL, &key, NULL) != ERROR_SUCCESS)
 587         return E_FAIL;
 588     if(RegQueryValueExW(key, buf, 0, NULL, NULL, NULL)
 589             != ERROR_FILE_NOT_FOUND)
 590         return E_ACCESSDENIED;
 591     RegCloseKey(key);
 592
 593     if(!GUIDFromStringW(buf, &guid))
 594         return E_FAIL;
 595
 596     hr = CoCreateInstance(&guid, NULL, CLSCTX_INPROC_SERVER,
 597             &IID_IPersistFile, (void**)&persist_file);
 598     if(FAILED(hr))
 599         return hr;
 600
 601     hr = IShellFolder2_GetDisplayNameOf(iface, pidl, SHGDN_FORPARSING, &path);
 602     if(SUCCEEDED(hr))
 603         hr = StrRetToStrW(&path, NULL, &file);
 604     if(FAILED(hr)) {
 605         IPersistFile_Release(persist_file);
 606         return hr;
 607     }
 608
 609     hr = IPersistFile_Load(persist_file, file, STGM_READ);
 610     CoTaskMemFree(file);
 611     if(FAILED(hr)) {
 612         IPersistFile_Release(persist_file);
 613         return hr;
 614     }
 615
 616     hr = IPersistFile_QueryInterface(persist_file, riid, ppvOut);
 617     IPersistFile_Release(persist_file);
 618     return hr;
 619 }
 620
 621 /**************************************************************************
 622 *  IShellFolder_fnGetUIObjectOf
 623 *
 624 * PARAMETERS
 625 *  HWND           hwndOwner, //[in ] Parent window for any output
 626 *  UINT           cidl,      //[in ] array size
 627 *  LPCITEMIDLIST* apidl,     //[in ] simple pidl array
 628 *  REFIID         riid,      //[in ] Requested Interface
 629 *  UINT*          prgfInOut, //[   ] reserved
 630 *  LPVOID*        ppvObject) //[out] Resulting Interface
 631 *
 632 * NOTES
 633 *  This function gets asked to return "view objects" for one or more (multiple
 634 *  select) items:
 635 *  The viewobject typically is an COM object with one of the following
 636 *  interfaces:
 637 *  IExtractIcon,IDataObject,IContextMenu
 638 *  In order to support icon positions in the default Listview your DataObject
 639 *  must implement the SetData method (in addition to GetData :) - the shell
 640 *  passes a barely documented "Icon positions" structure to SetData when the
 641 *  drag starts, and GetData's it if the drop is in another explorer window that
 642 *  needs the positions.
 643 */
 644 static HRESULT WINAPI
 645 IShellFolder_fnGetUIObjectOf (IShellFolder2 * iface,
 646                               HWND hwndOwner,
 647                               UINT cidl, LPCITEMIDLIST * apidl, REFIID riid,
 648                               UINT * prgfInOut, LPVOID * ppvOut)
 649 {
 650     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 651
 652     LPITEMIDLIST pidl;
 653     IUnknown *pObj = NULL;
 654     HRESULT hr = E_INVALIDARG;
 655
 656     TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
 657      This, hwndOwner, cidl, apidl, shdebugstr_guid (riid), prgfInOut, ppvOut);
 658
 659     if (ppvOut) {
 660         *ppvOut = NULL;
 661
 662         if(cidl == 1) {
 663             hr = SHELL32_CreateExtensionUIObject(iface, *apidl, riid, ppvOut);
 664             if(hr != S_FALSE)
 665                 return hr;
 666         }
 667
 668         if (IsEqualIID (riid, &IID_IContextMenu) && (cidl >= 1)) {
 669             return ItemMenu_Constructor((IShellFolder*)iface, This->pidlRoot, apidl, cidl, riid, ppvOut);
 670         } else if (IsEqualIID (riid, &IID_IDataObject) && (cidl >= 1)) {
 671             pObj = (LPUNKNOWN) IDataObject_Constructor (hwndOwner,
 672              This->pidlRoot, apidl, cidl);
 673             hr = S_OK;
 674         } else if (IsEqualIID (riid, &IID_IExtractIconA) && (cidl == 1)) {
 675             pidl = ILCombine (This->pidlRoot, apidl[0]);
 676             pObj = (LPUNKNOWN) IExtractIconA_Constructor (pidl);
 677             SHFree (pidl);
 678             hr = S_OK;
 679         } else if (IsEqualIID (riid, &IID_IExtractIconW) && (cidl == 1)) {
 680             pidl = ILCombine (This->pidlRoot, apidl[0]);
 681             pObj = (LPUNKNOWN) IExtractIconW_Constructor (pidl);
 682             SHFree (pidl);
 683             hr = S_OK;
 684         } else if (IsEqualIID (riid, &IID_IDropTarget) && (cidl >= 1)) {
 685             hr = IShellFolder2_QueryInterface (iface, &IID_IDropTarget,
 686              (LPVOID *) & pObj);
 687         } else if ((IsEqualIID(riid,&IID_IShellLinkW) ||
 688          IsEqualIID(riid,&IID_IShellLinkA)) && (cidl == 1)) {
 689             pidl = ILCombine (This->pidlRoot, apidl[0]);
 690             hr = IShellLink_ConstructFromFile(NULL, riid, pidl, &pObj);
 691             SHFree (pidl);
 692         } else {
 693             hr = E_NOINTERFACE;
 694         }
 695
 696         if (SUCCEEDED(hr) && !pObj)
 697             hr = E_OUTOFMEMORY;
 698
 699         *ppvOut = pObj;
 700     }
 701     TRACE ("(%p)->hr=0x%08x\n", This, hr);
 702     return hr;
 703 }
 704
 705 static const WCHAR AdvancedW[] = { 'S','O','F','T','W','A','R','E',
 706  '\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
 707  'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l',
 708  'o','r','e','r','\\','A','d','v','a','n','c','e','d',0 };
 709 static const WCHAR HideFileExtW[] = { 'H','i','d','e','F','i','l','e','E','x',
 710  't',0 };
 711 static const WCHAR NeverShowExtW[] = { 'N','e','v','e','r','S','h','o','w','E',
 712  'x','t',0 };
 713
 714 /******************************************************************************
 715  * SHELL_FS_HideExtension [Internal]
 716  *
 717  * Query the registry if the filename extension of a given path should be
 718  * hidden.
 719  *
 720  * PARAMS
 721  *  szPath [I] Relative or absolute path of a file
 722  *
 723  * RETURNS
 724  *  TRUE, if the filename's extension should be hidden
 725  *  FALSE, otherwise.
 726  */
 727 BOOL SHELL_FS_HideExtension(LPCWSTR szPath)
 728 {
 729     HKEY hKey;
 730     DWORD dwData;
 731     DWORD dwDataSize = sizeof (DWORD);
 732     BOOL doHide = FALSE; /* The default value is FALSE (win98 at least) */
 733
 734     if (!RegCreateKeyExW(HKEY_CURRENT_USER, AdvancedW, 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0)) {
 735         if (!RegQueryValueExW(hKey, HideFileExtW, 0, 0, (LPBYTE) &dwData, &dwDataSize))
 736             doHide = dwData;
 737         RegCloseKey (hKey);
 738     }
 739
 740     if (!doHide) {
 741         LPWSTR ext = PathFindExtensionW(szPath);
 742
 743         if (*ext != '\0') {
 744             WCHAR classname[MAX_PATH];
 745             LONG classlen = sizeof(classname);
 746
 747             if (!RegQueryValueW(HKEY_CLASSES_ROOT, ext, classname, &classlen))
 748                 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, classname, &hKey)) {
 749                     if (!RegQueryValueExW(hKey, NeverShowExtW, 0, NULL, NULL, NULL))
 750                         doHide = TRUE;
 751                     RegCloseKey(hKey);
 752                 }
 753         }
 754     }
 755     return doHide;
 756 }
 757
 758 void SHELL_FS_ProcessDisplayFilename(LPWSTR szPath, DWORD dwFlags)
 759 {
 760     /*FIXME: MSDN also mentions SHGDN_FOREDITING which is not yet handled. */
 761     if (!(dwFlags & SHGDN_FORPARSING) &&
 762         ((dwFlags & SHGDN_INFOLDER) || (dwFlags == SHGDN_NORMAL))) {
 763         if (SHELL_FS_HideExtension(szPath) && szPath[0] != '.')
 764             PathRemoveExtensionW(szPath);
 765     }
 766 }
 767
 768 /**************************************************************************
 769 *  IShellFolder_fnGetDisplayNameOf
 770 *  Retrieves the display name for the specified file object or subfolder
 771 *
 772 * PARAMETERS
 773 *  LPCITEMIDLIST pidl,    //[in ] complex pidl to item
 774 *  DWORD         dwFlags, //[in ] SHGNO formatting flags
 775 *  LPSTRRET      lpName)  //[out] Returned display name
 776 *
 777 * FIXME
 778 *  if the name is in the pidl the ret value should be a STRRET_OFFSET
 779 */
 780
 781 static HRESULT WINAPI
 782 IShellFolder_fnGetDisplayNameOf (IShellFolder2 * iface, LPCITEMIDLIST pidl,
 783                                  DWORD dwFlags, LPSTRRET strRet)
 784 {
 785     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 786     LPWSTR pszPath;
 787
 788     HRESULT hr = S_OK;
 789     int len = 0;
 790
 791     TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet);
 792     pdump (pidl);
 793
 794     if (!pidl || !strRet)
 795         return E_INVALIDARG;
 796
 797     pszPath = CoTaskMemAlloc((MAX_PATH +1) * sizeof(WCHAR));
 798     if (!pszPath)
 799         return E_OUTOFMEMORY;
 800
 801     if (_ILIsDesktop(pidl)) { /* empty pidl */
 802         if ((GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING) &&
 803             (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER))
 804         {
 805             if (This->sPathTarget)
 806                 lstrcpynW(pszPath, This->sPathTarget, MAX_PATH);
 807         } else {
 808             /* pidl has to contain exactly one non null SHITEMID */
 809             hr = E_INVALIDARG;
 810         }
 811     } else if (_ILIsPidlSimple(pidl)) {
 812         if ((GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING) &&
 813             (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER) &&
 814             This->sPathTarget)
 815         {
 816             lstrcpynW(pszPath, This->sPathTarget, MAX_PATH);
 817             PathAddBackslashW(pszPath);
 818             len = lstrlenW(pszPath);
 819         }
 820         _ILSimpleGetTextW(pidl, pszPath + len, MAX_PATH + 1 - len);
 821         if (!_ILIsFolder(pidl)) SHELL_FS_ProcessDisplayFilename(pszPath, dwFlags);
 822     } else {
 823         hr = SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, pszPath, MAX_PATH);
 824     }
 825
 826     if (SUCCEEDED(hr)) {
 827         /* Win9x always returns ANSI strings, NT always returns Unicode strings */
 828         if (GetVersion() & 0x80000000) {
 829             strRet->uType = STRRET_CSTR;
 830             if (!WideCharToMultiByte(CP_ACP, 0, pszPath, -1, strRet->u.cStr, MAX_PATH,
 831                  NULL, NULL))
 832                 strRet->u.cStr[0] = '\0';
 833             CoTaskMemFree(pszPath);
 834         } else {
 835             strRet->uType = STRRET_WSTR;
 836             strRet->u.pOleStr = pszPath;
 837         }
 838     } else
 839         CoTaskMemFree(pszPath);
 840
 841     TRACE ("-- (%p)->(%s)\n", This, strRet->uType == STRRET_CSTR ? strRet->u.cStr : debugstr_w(strRet->u.pOleStr));
 842     return hr;
 843 }
 844
 845 /**************************************************************************
 846 *  IShellFolder_fnSetNameOf
 847 *  Changes the name of a file object or subfolder, possibly changing its item
 848 *  identifier in the process.
 849 *
 850 * PARAMETERS
 851 *  HWND          hwndOwner,  //[in ] Owner window for output
 852 *  LPCITEMIDLIST pidl,       //[in ] simple pidl of item to change
 853 *  LPCOLESTR     lpszName,   //[in ] the items new display name
 854 *  DWORD         dwFlags,    //[in ] SHGNO formatting flags
 855 *  LPITEMIDLIST* ppidlOut)   //[out] simple pidl returned
 856 */
 857 static HRESULT WINAPI IShellFolder_fnSetNameOf (IShellFolder2 * iface,
 858                                                 HWND hwndOwner,
 859                                                 LPCITEMIDLIST pidl,
 860                                                 LPCOLESTR lpName,
 861                                                 DWORD dwFlags,
 862                                                 LPITEMIDLIST * pPidlOut)
 863 {
 864     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 865     WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1];
 866     LPWSTR ptr;
 867     BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl));
 868
 869     TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", This, hwndOwner, pidl,
 870      debugstr_w (lpName), dwFlags, pPidlOut);
 871
 872     /* build source path */
 873     lstrcpynW(szSrc, This->sPathTarget, MAX_PATH);
 874     ptr = PathAddBackslashW (szSrc);
 875     if (ptr)
 876         _ILSimpleGetTextW (pidl, ptr, MAX_PATH + 1 - (ptr - szSrc));
 877
 878     /* build destination path */
 879     if (dwFlags == SHGDN_NORMAL || dwFlags & SHGDN_INFOLDER) {
 880         lstrcpynW(szDest, This->sPathTarget, MAX_PATH);
 881         ptr = PathAddBackslashW (szDest);
 882         if (ptr)
 883             lstrcpynW(ptr, lpName, MAX_PATH + 1 - (ptr - szDest));
 884     } else
 885         lstrcpynW(szDest, lpName, MAX_PATH);
 886
 887     if(!(dwFlags & SHGDN_FORPARSING) && SHELL_FS_HideExtension(szSrc)) {
 888         WCHAR *ext = PathFindExtensionW(szSrc);
 889         if(*ext != '\0') {
 890             INT len = strlenW(szDest);
 891             lstrcpynW(szDest + len, ext, MAX_PATH - len);
 892         }
 893     }
 894
 895     TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
 896
 897     if (MoveFileW (szSrc, szDest)) {
 898         HRESULT hr = S_OK;
 899
 900         if (pPidlOut)
 901             hr = _ILCreateFromPathW(szDest, pPidlOut);
 902
 903         SHChangeNotify (bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM,
 904          SHCNF_PATHW, szSrc, szDest);
 905
 906         return hr;
 907     }
 908
 909     return E_FAIL;
 910 }
 911
 912 static HRESULT WINAPI IShellFolder_fnGetDefaultSearchGUID(IShellFolder2 *iface, GUID *guid)
 913 {
 914     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 915     TRACE("(%p)->(%p)\n", This, guid);
 916     return E_NOTIMPL;
 917 }
 918
 919 static HRESULT WINAPI IShellFolder_fnEnumSearches (IShellFolder2 * iface,
 920                                                    IEnumExtraSearch ** ppenum)
 921 {
 922     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 923     FIXME ("(%p)\n", This);
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI
 928 IShellFolder_fnGetDefaultColumn(IShellFolder2 *iface, DWORD reserved, ULONG *sort, ULONG *display)
 929 {
 930     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 931
 932     TRACE("(%p)->(%#x, %p, %p)\n", This, reserved, sort, display);
 933
 934     return E_NOTIMPL;
 935 }
 936
 937 static HRESULT WINAPI
 938 IShellFolder_fnGetDefaultColumnState (IShellFolder2 * iface, UINT iColumn,
 939                                       DWORD * pcsFlags)
 940 {
 941     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 942
 943     TRACE ("(%p)\n", This);
 944
 945     if (!pcsFlags || iColumn >= GENERICSHELLVIEWCOLUMNS)
 946         return E_INVALIDARG;
 947
 948     *pcsFlags = GenericSFHeader[iColumn].pcsFlags;
 949
 950     return S_OK;
 951 }
 952
 953 static HRESULT WINAPI
 954 IShellFolder_fnGetDetailsEx (IShellFolder2 * iface, LPCITEMIDLIST pidl,
 955                              const SHCOLUMNID * pscid, VARIANT * pv)
 956 {
 957     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 958     FIXME ("(%p)\n", This);
 959
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI
 964 IShellFolder_fnGetDetailsOf (IShellFolder2 * iface, LPCITEMIDLIST pidl,
 965                              UINT iColumn, SHELLDETAILS * psd)
 966 {
 967     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
 968     HRESULT hr = E_FAIL;
 969
 970     TRACE ("(%p)->(%p %i %p)\n", This, pidl, iColumn, psd);
 971
 972     if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS)
 973         return E_INVALIDARG;
 974
 975     if (!pidl) {
 976         /* the header titles */
 977         psd->fmt = GenericSFHeader[iColumn].fmt;
 978         psd->cxChar = GenericSFHeader[iColumn].cxChar;
 979         psd->str.uType = STRRET_CSTR;
 980         LoadStringA (shell32_hInstance, GenericSFHeader[iColumn].colnameid,
 981          psd->str.u.cStr, MAX_PATH);
 982         return S_OK;
 983     } else {
 984         hr = S_OK;
 985         psd->str.uType = STRRET_CSTR;
 986         /* the data from the pidl */
 987         switch (iColumn) {
 988         case 0:                /* name */
 989             hr = IShellFolder2_GetDisplayNameOf (iface, pidl,
 990              SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
 991             break;
 992         case 1:                /* size */
 993             _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
 994             break;
 995         case 2:                /* type */
 996             _ILGetFileType (pidl, psd->str.u.cStr, MAX_PATH);
 997             break;
 998         case 3:                /* date */
 999             _ILGetFileDate (pidl, psd->str.u.cStr, MAX_PATH);
1000             break;
1001         case 4:                /* attributes */
1002             _ILGetFileAttributes (pidl, psd->str.u.cStr, MAX_PATH);
1003             break;
1004         }
1005     }
1006
1007     return hr;
1008 }
1009
1010 static HRESULT WINAPI
1011 IShellFolder_fnMapColumnToSCID (IShellFolder2 *iface, UINT column, SHCOLUMNID *scid)
1012 {
1013     IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1014
1015     TRACE("(%p)->(%u %p)\n", This, column, scid);
1016
1017     if (column >= GENERICSHELLVIEWCOLUMNS)
1018         return E_INVALIDARG;
1019
1020     return shellfolder_map_column_to_scid(GenericSFHeader, column, scid);
1021 }
1022
1023 static const IShellFolder2Vtbl sfvt =
1024 {
1025     IShellFolder_fnQueryInterface,
1026     IShellFolder_fnAddRef,
1027     IShellFolder_fnRelease,
1028     IShellFolder_fnParseDisplayName,
1029     IShellFolder_fnEnumObjects,
1030     IShellFolder_fnBindToObject,
1031     IShellFolder_fnBindToStorage,
1032     IShellFolder_fnCompareIDs,
1033     IShellFolder_fnCreateViewObject,
1034     IShellFolder_fnGetAttributesOf,
1035     IShellFolder_fnGetUIObjectOf,
1036     IShellFolder_fnGetDisplayNameOf,
1037     IShellFolder_fnSetNameOf,
1038     /* ShellFolder2 */
1039     IShellFolder_fnGetDefaultSearchGUID,
1040     IShellFolder_fnEnumSearches,
1041     IShellFolder_fnGetDefaultColumn,
1042     IShellFolder_fnGetDefaultColumnState,
1043     IShellFolder_fnGetDetailsEx,
1044     IShellFolder_fnGetDetailsOf,
1045     IShellFolder_fnMapColumnToSCID
1046 };
1047
1048 /****************************************************************************
1049  * ISFHelper for IShellFolder implementation
1050  */
1051
1052 static HRESULT WINAPI ISFHelper_fnQueryInterface(ISFHelper *iface, REFIID riid, void **ppvObj)
1053 {
1054     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1055
1056     return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
1057 }
1058
1059 static ULONG WINAPI ISFHelper_fnAddRef(ISFHelper *iface)
1060 {
1061     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1062
1063     return IUnknown_AddRef(This->outer_unk);
1064 }
1065
1066 static ULONG WINAPI ISFHelper_fnRelease(ISFHelper *iface)
1067 {
1068     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1069
1070     return IUnknown_Release(This->outer_unk);
1071 }
1072
1073 /****************************************************************************
1074  * ISFHelper_fnGetUniqueName
1075  *
1076  * creates a unique folder name
1077  */
1078
1079 static HRESULT WINAPI
1080 ISFHelper_fnGetUniqueName (ISFHelper * iface, LPWSTR pwszName, UINT uLen)
1081 {
1082     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1083     IEnumIDList *penum;
1084     HRESULT hr;
1085     WCHAR wszText[MAX_PATH];
1086     WCHAR wszNewFolder[25];
1087     static const WCHAR wszFormat[] = {'%','s',' ','%','d',0 };
1088
1089     TRACE ("(%p)(%p %u)\n", This, pwszName, uLen);
1090
1091     LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, ARRAY_SIZE(wszNewFolder));
1092     if (uLen < ARRAY_SIZE(wszNewFolder) + 3)
1093         return E_POINTER;
1094
1095     lstrcpynW (pwszName, wszNewFolder, uLen);
1096
1097     hr = IShellFolder2_EnumObjects(&This->IShellFolder2_iface, 0,
1098             SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penum);
1099     if (penum) {
1100         LPITEMIDLIST pidl;
1101         DWORD dwFetched;
1102         int i = 1;
1103
1104 next:
1105         IEnumIDList_Reset (penum);
1106         while (S_OK == IEnumIDList_Next (penum, 1, &pidl, &dwFetched) &&
1107          dwFetched) {
1108             _ILSimpleGetTextW (pidl, wszText, MAX_PATH);
1109             if (0 == lstrcmpiW (wszText, pwszName)) {
1110                 snprintfW (pwszName, uLen, wszFormat, wszNewFolder, i++);
1111                 if (i > 99) {
1112                     hr = E_FAIL;
1113                     break;
1114                 }
1115                 goto next;
1116             }
1117         }
1118
1119         IEnumIDList_Release (penum);
1120     }
1121     return hr;
1122 }
1123
1124 /****************************************************************************
1125  * ISFHelper_fnAddFolder
1126  *
1127  * adds a new folder.
1128  */
1129
1130 static HRESULT WINAPI
1131 ISFHelper_fnAddFolder (ISFHelper * iface, HWND hwnd, LPCWSTR pwszName,
1132                        LPITEMIDLIST * ppidlOut)
1133 {
1134     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1135     WCHAR wszNewDir[MAX_PATH];
1136     BOOL bRes;
1137     HRESULT hres = E_FAIL;
1138
1139     TRACE ("(%p)(%s %p)\n", This, debugstr_w(pwszName), ppidlOut);
1140
1141     wszNewDir[0] = 0;
1142     if (This->sPathTarget)
1143         lstrcpynW(wszNewDir, This->sPathTarget, MAX_PATH);
1144     PathAppendW(wszNewDir, pwszName);
1145
1146     bRes = CreateDirectoryW (wszNewDir, NULL);
1147     if (bRes) {
1148         LPITEMIDLIST relPidl;
1149
1150         lstrcpyW(wszNewDir, pwszName);
1151
1152         hres = IShellFolder2_ParseDisplayName(&This->IShellFolder2_iface, hwnd, NULL, wszNewDir,
1153                 NULL, &relPidl, NULL);
1154
1155         if (SUCCEEDED(hres)) {
1156             LPITEMIDLIST fullPidl;
1157
1158             fullPidl = ILCombine(This->pidlRoot, relPidl);
1159
1160             if (fullPidl) {
1161                 SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, fullPidl, NULL);
1162                 ILFree(fullPidl);
1163
1164                 if (ppidlOut)
1165                     *ppidlOut = relPidl;
1166                 else
1167                     ILFree(relPidl);
1168             } else {
1169                 WARN("failed to combine %s into a full PIDL\n", wine_dbgstr_w(pwszName));
1170                 ILFree(relPidl);
1171             }
1172
1173         } else
1174             WARN("failed to parse %s into a PIDL\n", wine_dbgstr_w(pwszName));
1175
1176     } else {
1177         WCHAR wszText[128 + MAX_PATH];
1178         WCHAR wszTempText[128];
1179         WCHAR wszCaption[256];
1180
1181         /* Cannot Create folder because of permissions */
1182         LoadStringW (shell32_hInstance, IDS_CREATEFOLDER_DENIED, wszTempText, ARRAY_SIZE(wszTempText));
1183         LoadStringW (shell32_hInstance, IDS_CREATEFOLDER_CAPTION, wszCaption, ARRAY_SIZE(wszCaption));
1184         sprintfW (wszText, wszTempText, wszNewDir);
1185         MessageBoxW (hwnd, wszText, wszCaption, MB_OK | MB_ICONEXCLAMATION);
1186     }
1187
1188     return hres;
1189 }
1190
1191 /****************************************************************************
1192  * build_paths_list
1193  *
1194  * Builds a list of paths like the one used in SHFileOperation from a table of
1195  * PIDLs relative to the given base folder
1196  */
1197 static WCHAR *build_paths_list(LPCWSTR wszBasePath, int cidl, const LPCITEMIDLIST *pidls)
1198 {
1199     WCHAR *wszPathsList;
1200     WCHAR *wszListPos;
1201     int iPathLen;
1202     int i;
1203
1204     iPathLen = lstrlenW(wszBasePath);
1205     wszPathsList = heap_alloc(MAX_PATH*sizeof(WCHAR)*cidl+1);
1206     wszListPos = wszPathsList;
1207
1208     for (i = 0; i < cidl; i++) {
1209         if (!_ILIsFolder(pidls[i]) && !_ILIsValue(pidls[i]))
1210             continue;
1211
1212         lstrcpynW(wszListPos, wszBasePath, MAX_PATH);
1213         /* FIXME: abort if path too long */
1214         _ILSimpleGetTextW(pidls[i], wszListPos+iPathLen, MAX_PATH-iPathLen);
1215         wszListPos += lstrlenW(wszListPos)+1;
1216     }
1217     *wszListPos=0;
1218     return wszPathsList;
1219 }
1220
1221 /****************************************************************************
1222  * ISFHelper_fnDeleteItems
1223  *
1224  * deletes items in folder
1225  */
1226 static HRESULT WINAPI
1227 ISFHelper_fnDeleteItems (ISFHelper * iface, UINT cidl, LPCITEMIDLIST * apidl)
1228 {
1229     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1230     UINT i;
1231     SHFILEOPSTRUCTW op;
1232     WCHAR wszPath[MAX_PATH];
1233     WCHAR *wszPathsList;
1234     HRESULT ret;
1235     WCHAR *wszCurrentPath;
1236
1237     TRACE ("(%p)(%u %p)\n", This, cidl, apidl);
1238     if (cidl==0) return S_OK;
1239
1240     if (This->sPathTarget)
1241         lstrcpynW(wszPath, This->sPathTarget, MAX_PATH);
1242     else
1243         wszPath[0] = '\0';
1244     PathAddBackslashW(wszPath);
1245     wszPathsList = build_paths_list(wszPath, cidl, apidl);
1246
1247     ZeroMemory(&op, sizeof(op));
1248     op.hwnd = GetActiveWindow();
1249     op.wFunc = FO_DELETE;
1250     op.pFrom = wszPathsList;
1251     op.fFlags = FOF_ALLOWUNDO;
1252     if (SHFileOperationW(&op))
1253     {
1254         WARN("SHFileOperation failed\n");
1255         ret = E_FAIL;
1256     }
1257     else
1258         ret = S_OK;
1259
1260     /* we currently need to manually send the notifies */
1261     wszCurrentPath = wszPathsList;
1262     for (i = 0; i < cidl; i++)
1263     {
1264         LONG wEventId;
1265
1266         if (_ILIsFolder(apidl[i]))
1267             wEventId = SHCNE_RMDIR;
1268         else if (_ILIsValue(apidl[i]))
1269             wEventId = SHCNE_DELETE;
1270         else
1271             continue;
1272
1273         /* check if file exists */
1274         if (GetFileAttributesW(wszCurrentPath) == INVALID_FILE_ATTRIBUTES)
1275         {
1276             LPITEMIDLIST pidl = ILCombine(This->pidlRoot, apidl[i]);
1277             SHChangeNotify(wEventId, SHCNF_IDLIST, pidl, NULL);
1278             SHFree(pidl);
1279         }
1280
1281         wszCurrentPath += lstrlenW(wszCurrentPath)+1;
1282     }
1283     heap_free(wszPathsList);
1284     return ret;
1285 }
1286
1287 /****************************************************************************
1288  * ISFHelper_fnCopyItems
1289  *
1290  * copies items to this folder
1291  */
1292 static HRESULT WINAPI
1293 ISFHelper_fnCopyItems (ISFHelper * iface, IShellFolder * pSFFrom, UINT cidl,
1294                        LPCITEMIDLIST * apidl)
1295 {
1296     HRESULT ret=E_FAIL;
1297     IPersistFolder2 *ppf2 = NULL;
1298     WCHAR wszSrcPathRoot[MAX_PATH],
1299       wszDstPath[MAX_PATH+1];
1300     WCHAR *wszSrcPathsList;
1301     IGenericSFImpl *This = impl_from_ISFHelper(iface);
1302
1303     SHFILEOPSTRUCTW fop;
1304
1305     TRACE ("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
1306
1307     IShellFolder_QueryInterface (pSFFrom, &IID_IPersistFolder2,
1308      (LPVOID *) & ppf2);
1309     if (ppf2) {
1310         LPITEMIDLIST pidl;
1311
1312         if (SUCCEEDED (IPersistFolder2_GetCurFolder (ppf2, &pidl))) {
1313             SHGetPathFromIDListW (pidl, wszSrcPathRoot);
1314             if (This->sPathTarget)
1315                 lstrcpynW(wszDstPath, This->sPathTarget, MAX_PATH);
1316             else
1317                 wszDstPath[0] = 0;
1318             PathAddBackslashW(wszSrcPathRoot);
1319             PathAddBackslashW(wszDstPath);
1320             wszSrcPathsList = build_paths_list(wszSrcPathRoot, cidl, apidl);
1321             ZeroMemory(&fop, sizeof(fop));
1322             fop.hwnd = GetActiveWindow();
1323             fop.wFunc = FO_COPY;
1324             fop.pFrom = wszSrcPathsList;
1325             fop.pTo = wszDstPath;
1326             fop.fFlags = FOF_ALLOWUNDO;
1327             ret = S_OK;
1328             if(SHFileOperationW(&fop))
1329             {
1330                 WARN("Copy failed\n");
1331                 ret = E_FAIL;
1332             }
1333             heap_free(wszSrcPathsList);
1334         }
1335         SHFree(pidl);
1336         IPersistFolder2_Release(ppf2);
1337     }
1338     return ret;
1339 }
1340
1341 static const ISFHelperVtbl shvt =
1342 {
1343     ISFHelper_fnQueryInterface,
1344     ISFHelper_fnAddRef,
1345     ISFHelper_fnRelease,
1346     ISFHelper_fnGetUniqueName,
1347     ISFHelper_fnAddFolder,
1348     ISFHelper_fnDeleteItems,
1349     ISFHelper_fnCopyItems
1350 };
1351
1352 /************************************************************************
1353  * IFSFldr_PersistFolder3_QueryInterface
1354  *
1355  */
1356 static HRESULT WINAPI IFSFldr_PersistFolder3_QueryInterface(IPersistFolder3 *iface, REFIID iid,
1357         void **ppv)
1358 {
1359     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1360
1361     return IUnknown_QueryInterface(This->outer_unk, iid, ppv);
1362 }
1363
1364 /************************************************************************
1365  * IFSFldr_PersistFolder3_AddRef
1366  *
1367  */
1368 static ULONG WINAPI IFSFldr_PersistFolder3_AddRef(IPersistFolder3 *iface)
1369 {
1370     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1371
1372     return IUnknown_AddRef(This->outer_unk);
1373 }
1374
1375 /************************************************************************
1376  * IFSFldr_PersistFolder3_Release
1377  *
1378  */
1379 static ULONG WINAPI IFSFldr_PersistFolder3_Release(IPersistFolder3 *iface)
1380 {
1381     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1382
1383     return IUnknown_Release(This->outer_unk);
1384 }
1385
1386 /************************************************************************
1387  * IFSFldr_PersistFolder3_GetClassID
1388  */
1389 static HRESULT WINAPI
1390 IFSFldr_PersistFolder3_GetClassID (IPersistFolder3 * iface, CLSID * lpClassId)
1391 {
1392     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1393
1394     TRACE ("(%p)\n", This);
1395
1396     if (!lpClassId)
1397         return E_POINTER;
1398     *lpClassId = *This->pclsid;
1399
1400     return S_OK;
1401 }
1402
1403 /************************************************************************
1404  * IFSFldr_PersistFolder3_Initialize
1405  *
1406  * NOTES
1407  *  sPathTarget is not set. Don't know how to handle in a non rooted environment.
1408  */
1409 static HRESULT WINAPI
1410 IFSFldr_PersistFolder3_Initialize (IPersistFolder3 * iface, LPCITEMIDLIST pidl)
1411 {
1412     WCHAR wszTemp[MAX_PATH];
1413
1414     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1415
1416     TRACE ("(%p)->(%p)\n", This, pidl);
1417
1418     SHFree (This->pidlRoot);     /* free the old pidl */
1419     This->pidlRoot = ILClone (pidl); /* set my pidl */
1420
1421     SHFree (This->sPathTarget);
1422     This->sPathTarget = NULL;
1423
1424     /* set my path */
1425     if (SHGetPathFromIDListW (pidl, wszTemp)) {
1426         int len = strlenW(wszTemp);
1427         This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1428         if (!This->sPathTarget)
1429             return E_OUTOFMEMORY;
1430         memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1431     }
1432
1433     TRACE ("--(%p)->(%s)\n", This, debugstr_w(This->sPathTarget));
1434     return S_OK;
1435 }
1436
1437 /**************************************************************************
1438  * IFSFldr_PersistFolder3_GetCurFolder
1439  */
1440 static HRESULT WINAPI
1441 IFSFldr_PersistFolder3_fnGetCurFolder (IPersistFolder3 * iface,
1442                                        LPITEMIDLIST * pidl)
1443 {
1444     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1445
1446     TRACE ("(%p)->(%p)\n", This, pidl);
1447
1448     if (!pidl) return E_POINTER;
1449     *pidl = ILClone (This->pidlRoot);
1450     return S_OK;
1451 }
1452
1453 /**************************************************************************
1454  * IFSFldr_PersistFolder3_InitializeEx
1455  *
1456  * FIXME: error handling
1457  */
1458 static HRESULT WINAPI
1459 IFSFldr_PersistFolder3_InitializeEx (IPersistFolder3 * iface,
1460                                      IBindCtx * pbc, LPCITEMIDLIST pidlRoot,
1461                                      const PERSIST_FOLDER_TARGET_INFO * ppfti)
1462 {
1463     WCHAR wszTemp[MAX_PATH];
1464
1465     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1466
1467     TRACE ("(%p)->(%p,%p,%p)\n", This, pbc, pidlRoot, ppfti);
1468     if (ppfti)
1469         TRACE ("--%p %s %s 0x%08x 0x%08x\n",
1470          ppfti->pidlTargetFolder, debugstr_w (ppfti->szTargetParsingName),
1471          debugstr_w (ppfti->szNetworkProvider), ppfti->dwAttributes,
1472          ppfti->csidl);
1473
1474     pdump (pidlRoot);
1475     if (ppfti && ppfti->pidlTargetFolder)
1476         pdump (ppfti->pidlTargetFolder);
1477
1478     if (This->pidlRoot)
1479     {
1480         SHFree(This->pidlRoot);
1481         This->pidlRoot = NULL;
1482     }
1483     if (This->sPathTarget)
1484     {
1485         SHFree(This->sPathTarget);
1486         This->sPathTarget = NULL;
1487     }
1488
1489     /*
1490      * Root path and pidl
1491      */
1492     This->pidlRoot = ILClone (pidlRoot);
1493
1494     /*
1495      *  the target folder is specified in csidl OR pidlTargetFolder OR
1496      *  szTargetParsingName
1497      */
1498     if (ppfti) {
1499         if (ppfti->csidl != -1) {
1500             if (SHGetSpecialFolderPathW (0, wszTemp, ppfti->csidl,
1501              ppfti->csidl & CSIDL_FLAG_CREATE)) {
1502                 int len = strlenW(wszTemp);
1503                 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1504                 if (!This->sPathTarget)
1505                     return E_OUTOFMEMORY;
1506                 memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1507             }
1508         } else if (ppfti->szTargetParsingName[0]) {
1509             int len = strlenW(ppfti->szTargetParsingName);
1510             This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1511             if (!This->sPathTarget)
1512                 return E_OUTOFMEMORY;
1513             memcpy(This->sPathTarget, ppfti->szTargetParsingName,
1514                    (len + 1) * sizeof(WCHAR));
1515         } else if (ppfti->pidlTargetFolder) {
1516             if (SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTemp)) {
1517                 int len = strlenW(wszTemp);
1518                 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1519                 if (!This->sPathTarget)
1520                     return E_OUTOFMEMORY;
1521                 memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1522             }
1523         }
1524     }
1525
1526     TRACE ("--(%p)->(target=%s)\n", This, debugstr_w(This->sPathTarget));
1527     pdump (This->pidlRoot);
1528     return (This->sPathTarget) ? S_OK : E_FAIL;
1529 }
1530
1531 static HRESULT WINAPI
1532 IFSFldr_PersistFolder3_GetFolderTargetInfo (IPersistFolder3 * iface,
1533                                             PERSIST_FOLDER_TARGET_INFO * ppfti)
1534 {
1535     IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1536     FIXME ("(%p)->(%p)\n", This, ppfti);
1537     ZeroMemory (ppfti, sizeof (*ppfti));
1538     return E_NOTIMPL;
1539 }
1540
1541 static const IPersistFolder3Vtbl pfvt =
1542 {
1543     IFSFldr_PersistFolder3_QueryInterface,
1544     IFSFldr_PersistFolder3_AddRef,
1545     IFSFldr_PersistFolder3_Release,
1546     IFSFldr_PersistFolder3_GetClassID,
1547     IFSFldr_PersistFolder3_Initialize,
1548     IFSFldr_PersistFolder3_fnGetCurFolder,
1549     IFSFldr_PersistFolder3_InitializeEx,
1550     IFSFldr_PersistFolder3_GetFolderTargetInfo
1551 };
1552
1553 /****************************************************************************
1554  * ISFDropTarget implementation
1555  */
1556 static HRESULT WINAPI ISFDropTarget_QueryInterface(IDropTarget *iface, REFIID riid, void **ppv)
1557 {
1558     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1559
1560     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
1561 }
1562
1563 static ULONG WINAPI ISFDropTarget_AddRef(IDropTarget *iface)
1564 {
1565     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1566
1567     return IUnknown_AddRef(This->outer_unk);
1568 }
1569
1570 static ULONG WINAPI ISFDropTarget_Release(IDropTarget *iface)
1571 {
1572     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1573
1574     return IUnknown_Release(This->outer_unk);
1575 }
1576
1577 static HRESULT WINAPI
1578 ISFDropTarget_DragEnter (IDropTarget * iface, IDataObject * pDataObject,
1579                          DWORD dwKeyState, POINTL pt, DWORD * pdwEffect)
1580 {
1581     FORMATETC fmt;
1582
1583     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1584
1585     TRACE ("(%p)->(DataObject=%p)\n", This, pDataObject);
1586
1587     InitFormatEtc (fmt, This->cfShellIDList, TYMED_HGLOBAL);
1588     This->fAcceptFmt = IDataObject_QueryGetData (pDataObject, &fmt) == S_OK;
1589     if (This->fAcceptFmt)
1590         *pdwEffect = KeyStateToDropEffect(dwKeyState);
1591     else
1592         *pdwEffect = DROPEFFECT_NONE;
1593
1594     return S_OK;
1595 }
1596
1597 static HRESULT WINAPI
1598 ISFDropTarget_DragOver (IDropTarget * iface, DWORD dwKeyState, POINTL pt,
1599                         DWORD * pdwEffect)
1600 {
1601     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1602
1603     TRACE ("(%p)\n", This);
1604
1605     if (!pdwEffect)
1606         return E_INVALIDARG;
1607
1608     if (This->fAcceptFmt)
1609         *pdwEffect = KeyStateToDropEffect(dwKeyState);
1610     else
1611         *pdwEffect = DROPEFFECT_NONE;
1612
1613     return S_OK;
1614 }
1615
1616 static HRESULT WINAPI ISFDropTarget_DragLeave (IDropTarget * iface)
1617 {
1618     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1619
1620     TRACE ("(%p)\n", This);
1621
1622     This->fAcceptFmt = FALSE;
1623
1624     return S_OK;
1625 }
1626
1627 static HRESULT WINAPI
1628 ISFDropTarget_Drop (IDropTarget * iface, IDataObject * pDataObject,
1629                     DWORD dwKeyState, POINTL pt, DWORD * pdwEffect)
1630 {
1631     IGenericSFImpl *This = impl_from_IDropTarget(iface);
1632
1633     FIXME ("(%p) object dropped\n", This);
1634
1635     return E_NOTIMPL;
1636 }
1637
1638 static const IDropTargetVtbl dtvt = {
1639     ISFDropTarget_QueryInterface,
1640     ISFDropTarget_AddRef,
1641     ISFDropTarget_Release,
1642     ISFDropTarget_DragEnter,
1643     ISFDropTarget_DragOver,
1644     ISFDropTarget_DragLeave,
1645     ISFDropTarget_Drop
1646 };
1647
1648 HRESULT WINAPI IFSFolder_Constructor(IUnknown *outer_unk, REFIID riid, void **ppv)
1649 {
1650     IGenericSFImpl *sf;
1651     HRESULT hr;
1652
1653     TRACE("outer_unk=%p %s\n", outer_unk, shdebugstr_guid(riid));
1654
1655     if (outer_unk && !IsEqualIID(riid, &IID_IUnknown))
1656         return CLASS_E_NOAGGREGATION;
1657
1658     sf = LocalAlloc(LMEM_ZEROINIT, sizeof(*sf));
1659     if (!sf)
1660         return E_OUTOFMEMORY;
1661
1662     sf->ref = 1;
1663     sf->IUnknown_inner.lpVtbl = &unkvt;
1664     sf->IShellFolder2_iface.lpVtbl = &sfvt;
1665     sf->IPersistFolder3_iface.lpVtbl = &pfvt;
1666     sf->IDropTarget_iface.lpVtbl = &dtvt;
1667     sf->ISFHelper_iface.lpVtbl = &shvt;
1668     sf->pclsid = (CLSID *) & CLSID_ShellFSFolder;
1669     sf->outer_unk = outer_unk ? outer_unk : &sf->IUnknown_inner;
1670
1671     hr = IUnknown_QueryInterface(&sf->IUnknown_inner, riid, ppv);
1672     IUnknown_Release(&sf->IUnknown_inner);
1673
1674     TRACE ("--%p\n", *ppv);
1675     return hr;
1676 }