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