?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
po: Update Catalan translation.
[wine.git] / dlls / shell32 / shfldr_fs.c
blobb591533126dfc7945b53214be2bbf704903c3d8d
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 IEnumIDListImpl *list;
452
453 TRACE ("(%p)->(HWND=%p flags=0x%08x pplist=%p)\n", This, hwndOwner,
454 dwFlags, ppEnumIDList);
455
456 if (!(list = IEnumIDList_Constructor()))
457 return E_OUTOFMEMORY;
458 CreateFolderEnumList(list, This->sPathTarget, dwFlags);
459 *ppEnumIDList = &list->IEnumIDList_iface;
460
461 TRACE ("-- (%p)->(new ID List: %p)\n", This, *ppEnumIDList);
462
463 return S_OK;
464 }
465
466 /**************************************************************************
467 * IShellFolder_fnBindToObject
468 * PARAMETERS
469 * LPCITEMIDLIST pidl, //[in ] relative pidl to open
470 * LPBC pbc, //[in ] optional FileSystemBindData context
471 * REFIID riid, //[in ] Initial Interface
472 * LPVOID* ppvObject //[out] Interface*
473 */
474 static HRESULT WINAPI
475 IShellFolder_fnBindToObject (IShellFolder2 * iface, LPCITEMIDLIST pidl,
476 LPBC pbc, REFIID riid, LPVOID * ppvOut)
477 {
478 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
479
480 TRACE ("(%p)->(pidl=%p,%p,%s,%p)\n", This, pidl, pbc,
481 shdebugstr_guid (riid), ppvOut);
482
483 return SHELL32_BindToChild (This->pidlRoot, This->sPathTarget, pidl, riid,
484 ppvOut);
485 }
486
487 /**************************************************************************
488 * IShellFolder_fnBindToStorage
489 * PARAMETERS
490 * LPCITEMIDLIST pidl, //[in ] complex pidl to store
491 * LPBC pbc, //[in ] reserved
492 * REFIID riid, //[in ] Initial storage interface
493 * LPVOID* ppvObject //[out] Interface* returned
494 */
495 static HRESULT WINAPI
496 IShellFolder_fnBindToStorage (IShellFolder2 * iface, LPCITEMIDLIST pidl,
497 LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
498 {
499 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
500
501 FIXME ("(%p)->(pidl=%p,%p,%s,%p) stub\n", This, pidl, pbcReserved,
502 shdebugstr_guid (riid), ppvOut);
503
504 *ppvOut = NULL;
505 return E_NOTIMPL;
506 }
507
508 /**************************************************************************
509 * IShellFolder_fnCompareIDs
510 */
511
512 static HRESULT WINAPI
513 IShellFolder_fnCompareIDs (IShellFolder2 * iface, LPARAM lParam,
514 LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
515 {
516 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
517
518 int nReturn;
519
520 TRACE ("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n", This, lParam, pidl1, pidl2);
521 nReturn = SHELL32_CompareIDs (_IShellFolder_ (This), lParam, pidl1, pidl2);
522 TRACE ("-- %i\n", nReturn);
523 return nReturn;
524 }
525
526 /**************************************************************************
527 * IShellFolder_fnCreateViewObject
528 */
529 static HRESULT WINAPI
530 IShellFolder_fnCreateViewObject (IShellFolder2 * iface, HWND hwndOwner,
531 REFIID riid, LPVOID * ppvOut)
532 {
533 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
534
535 LPSHELLVIEW pShellView;
536 HRESULT hr = E_INVALIDARG;
537
538 TRACE ("(%p)->(hwnd=%p,%s,%p)\n", This, hwndOwner, shdebugstr_guid (riid),
539 ppvOut);
540
541 if (ppvOut) {
542 *ppvOut = NULL;
543
544 if (IsEqualIID (riid, &IID_IDropTarget)) {
545 hr = IShellFolder_QueryInterface (iface, &IID_IDropTarget, ppvOut);
546 } else if (IsEqualIID (riid, &IID_IContextMenu)) {
547 FIXME ("IContextMenu not implemented\n");
548 hr = E_NOTIMPL;
549 } else if (IsEqualIID (riid, &IID_IShellView)) {
550 pShellView = IShellView_Constructor ((IShellFolder *) iface);
551 if (pShellView) {
552 hr = IShellView_QueryInterface (pShellView, riid, ppvOut);
553 IShellView_Release (pShellView);
554 }
555 }
556 }
557 TRACE ("-- (%p)->(interface=%p)\n", This, ppvOut);
558 return hr;
559 }
560
561 /**************************************************************************
562 * IShellFolder_fnGetAttributesOf
563 *
564 * PARAMETERS
565 * UINT cidl, //[in ] num elements in pidl array
566 * LPCITEMIDLIST* apidl, //[in ] simple pidl array
567 * ULONG* rgfInOut) //[out] result array
568 *
569 */
570 static HRESULT WINAPI
571 IShellFolder_fnGetAttributesOf (IShellFolder2 * iface, UINT cidl,
572 LPCITEMIDLIST * apidl, DWORD * rgfInOut)
573 {
574 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
575
576 HRESULT hr = S_OK;
577
578 TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n", This, cidl, apidl,
579 rgfInOut, rgfInOut ? *rgfInOut : 0);
580
581 if (!rgfInOut)
582 return E_INVALIDARG;
583 if (cidl && !apidl)
584 return E_INVALIDARG;
585
586 if (*rgfInOut == 0)
587 *rgfInOut = ~0;
588
589 if(cidl == 0){
590 IShellFolder *psfParent = NULL;
591 LPCITEMIDLIST rpidl = NULL;
592
593 hr = SHBindToParent(This->pidlRoot, &IID_IShellFolder, (LPVOID*)&psfParent, &rpidl);
594 if(SUCCEEDED(hr)) {
595 SHELL32_GetItemAttributes (psfParent, rpidl, rgfInOut);
596 IShellFolder_Release(psfParent);
597 }
598 }
599 else {
600 while (cidl > 0 && *apidl) {
601 pdump (*apidl);
602 SHELL32_GetItemAttributes (_IShellFolder_ (This), *apidl, rgfInOut);
603 apidl++;
604 cidl--;
605 }
606 }
607 /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
608 *rgfInOut &= ~SFGAO_VALIDATE;
609
610 TRACE ("-- result=0x%08x\n", *rgfInOut);
611
612 return hr;
613 }
614
615 /**************************************************************************
616 * SHELL32_CreateExtensionUIObject (internal)
617 */
618 HRESULT SHELL32_CreateExtensionUIObject(IShellFolder2 *iface,
619 LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
620 {
621 static const WCHAR reg_blockedW[] = {'S','o','f','t','w','a','r','e','\\',
622 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
623 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
624 'S','h','e','l','l',' ','E','x','t','e','n','s','i','o','n','s','\\',
625 'B','l','o','c','k','e','d',0};
626 static const WCHAR formatW[] = {'.','%','s','\\','S','h','e','l','l','E','x','\\',
627 '{','%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
628 '%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x',
629 '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0};
630
631 IPersistFile *persist_file;
632 char extensionA[20];
633 WCHAR extensionW[20], buf[MAX_PATH];
634 DWORD size = MAX_PATH;
635 STRRET path;
636 WCHAR *file;
637 GUID guid;
638 HKEY key;
639 HRESULT hr;
640
641
642 if(!_ILGetExtension(pidl, extensionA, 20))
643 return S_FALSE;
644
645 MultiByteToWideChar(CP_ACP, 0, extensionA, -1, extensionW, 20);
646
647 sprintfW(buf, formatW, extensionW, riid->Data1, riid->Data2, riid->Data3,
648 riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
649 riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]);
650
651 if(RegGetValueW(HKEY_CLASSES_ROOT, buf, NULL, RRF_RT_REG_SZ,
652 NULL, buf, &size) != ERROR_SUCCESS)
653 return S_FALSE;
654
655 if(RegCreateKeyExW(HKEY_LOCAL_MACHINE, reg_blockedW, 0, 0, 0,
656 KEY_READ, NULL, &key, NULL) != ERROR_SUCCESS)
657 return E_FAIL;
658 if(RegQueryValueExW(key, buf, 0, NULL, NULL, NULL)
659 != ERROR_FILE_NOT_FOUND)
660 return E_ACCESSDENIED;
661 RegCloseKey(key);
662
663 if(RegCreateKeyExW(HKEY_CURRENT_USER, reg_blockedW, 0, 0, 0,
664 KEY_READ, NULL, &key, NULL) != ERROR_SUCCESS)
665 return E_FAIL;
666 if(RegQueryValueExW(key, buf, 0, NULL, NULL, NULL)
667 != ERROR_FILE_NOT_FOUND)
668 return E_ACCESSDENIED;
669 RegCloseKey(key);
670
671 if(!GUIDFromStringW(buf, &guid))
672 return E_FAIL;
673
674 hr = CoCreateInstance(&guid, NULL, CLSCTX_INPROC_SERVER,
675 &IID_IPersistFile, (void**)&persist_file);
676 if(FAILED(hr))
677 return hr;
678
679 hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_FORPARSING, &path);
680 if(SUCCEEDED(hr))
681 hr = StrRetToStrW(&path, NULL, &file);
682 if(FAILED(hr)) {
683 IPersistFile_Release(persist_file);
684 return hr;
685 }
686
687 hr = IPersistFile_Load(persist_file, file, STGM_READ);
688 CoTaskMemFree(file);
689 if(FAILED(hr)) {
690 IPersistFile_Release(persist_file);
691 return hr;
692 }
693
694 hr = IPersistFile_QueryInterface(persist_file, riid, ppvOut);
695 IPersistFile_Release(persist_file);
696 return hr;
697 }
698
699 /**************************************************************************
700 * IShellFolder_fnGetUIObjectOf
701 *
702 * PARAMETERS
703 * HWND hwndOwner, //[in ] Parent window for any output
704 * UINT cidl, //[in ] array size
705 * LPCITEMIDLIST* apidl, //[in ] simple pidl array
706 * REFIID riid, //[in ] Requested Interface
707 * UINT* prgfInOut, //[ ] reserved
708 * LPVOID* ppvObject) //[out] Resulting Interface
709 *
710 * NOTES
711 * This function gets asked to return "view objects" for one or more (multiple
712 * select) items:
713 * The viewobject typically is an COM object with one of the following
714 * interfaces:
715 * IExtractIcon,IDataObject,IContextMenu
716 * In order to support icon positions in the default Listview your DataObject
717 * must implement the SetData method (in addition to GetData :) - the shell
718 * passes a barely documented "Icon positions" structure to SetData when the
719 * drag starts, and GetData's it if the drop is in another explorer window that
720 * needs the positions.
721 */
722 static HRESULT WINAPI
723 IShellFolder_fnGetUIObjectOf (IShellFolder2 * iface,
724 HWND hwndOwner,
725 UINT cidl, LPCITEMIDLIST * apidl, REFIID riid,
726 UINT * prgfInOut, LPVOID * ppvOut)
727 {
728 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
729
730 LPITEMIDLIST pidl;
731 IUnknown *pObj = NULL;
732 HRESULT hr = E_INVALIDARG;
733
734 TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
735 This, hwndOwner, cidl, apidl, shdebugstr_guid (riid), prgfInOut, ppvOut);
736
737 if (ppvOut) {
738 *ppvOut = NULL;
739
740 if(cidl == 1) {
741 hr = SHELL32_CreateExtensionUIObject(iface, *apidl, riid, ppvOut);
742 if(hr != S_FALSE)
743 return hr;
744 }
745
746 if (IsEqualIID (riid, &IID_IContextMenu) && (cidl >= 1)) {
747 pObj = (LPUNKNOWN) ISvItemCm_Constructor ((IShellFolder *) iface,
748 This->pidlRoot, apidl, cidl);
749 hr = S_OK;
750 } else if (IsEqualIID (riid, &IID_IDataObject) && (cidl >= 1)) {
751 pObj = (LPUNKNOWN) IDataObject_Constructor (hwndOwner,
752 This->pidlRoot, apidl, cidl);
753 hr = S_OK;
754 } else if (IsEqualIID (riid, &IID_IExtractIconA) && (cidl == 1)) {
755 pidl = ILCombine (This->pidlRoot, apidl[0]);
756 pObj = (LPUNKNOWN) IExtractIconA_Constructor (pidl);
757 SHFree (pidl);
758 hr = S_OK;
759 } else if (IsEqualIID (riid, &IID_IExtractIconW) && (cidl == 1)) {
760 pidl = ILCombine (This->pidlRoot, apidl[0]);
761 pObj = (LPUNKNOWN) IExtractIconW_Constructor (pidl);
762 SHFree (pidl);
763 hr = S_OK;
764 } else if (IsEqualIID (riid, &IID_IDropTarget) && (cidl >= 1)) {
765 hr = IShellFolder_QueryInterface (iface, &IID_IDropTarget,
766 (LPVOID *) & pObj);
767 } else if ((IsEqualIID(riid,&IID_IShellLinkW) ||
768 IsEqualIID(riid,&IID_IShellLinkA)) && (cidl == 1)) {
769 pidl = ILCombine (This->pidlRoot, apidl[0]);
770 hr = IShellLink_ConstructFromFile(NULL, riid, pidl, (LPVOID*)&pObj);
771 SHFree (pidl);
772 } else {
773 hr = E_NOINTERFACE;
774 }
775
776 if (SUCCEEDED(hr) && !pObj)
777 hr = E_OUTOFMEMORY;
778
779 *ppvOut = pObj;
780 }
781 TRACE ("(%p)->hr=0x%08x\n", This, hr);
782 return hr;
783 }
784
785 static const WCHAR AdvancedW[] = { 'S','O','F','T','W','A','R','E',
786 '\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
787 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l',
788 'o','r','e','r','\\','A','d','v','a','n','c','e','d',0 };
789 static const WCHAR HideFileExtW[] = { 'H','i','d','e','F','i','l','e','E','x',
790 't',0 };
791 static const WCHAR NeverShowExtW[] = { 'N','e','v','e','r','S','h','o','w','E',
792 'x','t',0 };
793
794 /******************************************************************************
795 * SHELL_FS_HideExtension [Internal]
796 *
797 * Query the registry if the filename extension of a given path should be
798 * hidden.
799 *
800 * PARAMS
801 * szPath [I] Relative or absolute path of a file
802 *
803 * RETURNS
804 * TRUE, if the filename's extension should be hidden
805 * FALSE, otherwise.
806 */
807 BOOL SHELL_FS_HideExtension(LPCWSTR szPath)
808 {
809 HKEY hKey;
810 DWORD dwData;
811 DWORD dwDataSize = sizeof (DWORD);
812 BOOL doHide = FALSE; /* The default value is FALSE (win98 at least) */
813
814 if (!RegCreateKeyExW(HKEY_CURRENT_USER, AdvancedW, 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0)) {
815 if (!RegQueryValueExW(hKey, HideFileExtW, 0, 0, (LPBYTE) &dwData, &dwDataSize))
816 doHide = dwData;
817 RegCloseKey (hKey);
818 }
819
820 if (!doHide) {
821 LPWSTR ext = PathFindExtensionW(szPath);
822
823 if (*ext != '\0') {
824 WCHAR classname[MAX_PATH];
825 LONG classlen = sizeof(classname);
826
827 if (!RegQueryValueW(HKEY_CLASSES_ROOT, ext, classname, &classlen))
828 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, classname, &hKey)) {
829 if (!RegQueryValueExW(hKey, NeverShowExtW, 0, NULL, NULL, NULL))
830 doHide = TRUE;
831 RegCloseKey(hKey);
832 }
833 }
834 }
835 return doHide;
836 }
837
838 void SHELL_FS_ProcessDisplayFilename(LPWSTR szPath, DWORD dwFlags)
839 {
840 /*FIXME: MSDN also mentions SHGDN_FOREDITING which is not yet handled. */
841 if (!(dwFlags & SHGDN_FORPARSING) &&
842 ((dwFlags & SHGDN_INFOLDER) || (dwFlags == SHGDN_NORMAL))) {
843 if (SHELL_FS_HideExtension(szPath) && szPath[0] != '.')
844 PathRemoveExtensionW(szPath);
845 }
846 }
847
848 /**************************************************************************
849 * IShellFolder_fnGetDisplayNameOf
850 * Retrieves the display name for the specified file object or subfolder
851 *
852 * PARAMETERS
853 * LPCITEMIDLIST pidl, //[in ] complex pidl to item
854 * DWORD dwFlags, //[in ] SHGNO formatting flags
855 * LPSTRRET lpName) //[out] Returned display name
856 *
857 * FIXME
858 * if the name is in the pidl the ret value should be a STRRET_OFFSET
859 */
860
861 static HRESULT WINAPI
862 IShellFolder_fnGetDisplayNameOf (IShellFolder2 * iface, LPCITEMIDLIST pidl,
863 DWORD dwFlags, LPSTRRET strRet)
864 {
865 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
866 LPWSTR pszPath;
867
868 HRESULT hr = S_OK;
869 int len = 0;
870
871 TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet);
872 pdump (pidl);
873
874 if (!pidl || !strRet)
875 return E_INVALIDARG;
876
877 pszPath = CoTaskMemAlloc((MAX_PATH +1) * sizeof(WCHAR));
878 if (!pszPath)
879 return E_OUTOFMEMORY;
880
881 if (_ILIsDesktop(pidl)) { /* empty pidl */
882 if ((GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING) &&
883 (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER))
884 {
885 if (This->sPathTarget)
886 lstrcpynW(pszPath, This->sPathTarget, MAX_PATH);
887 } else {
888 /* pidl has to contain exactly one non null SHITEMID */
889 hr = E_INVALIDARG;
890 }
891 } else if (_ILIsPidlSimple(pidl)) {
892 if ((GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING) &&
893 (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER) &&
894 This->sPathTarget)
895 {
896 lstrcpynW(pszPath, This->sPathTarget, MAX_PATH);
897 PathAddBackslashW(pszPath);
898 len = lstrlenW(pszPath);
899 }
900 _ILSimpleGetTextW(pidl, pszPath + len, MAX_PATH + 1 - len);
901 if (!_ILIsFolder(pidl)) SHELL_FS_ProcessDisplayFilename(pszPath, dwFlags);
902 } else {
903 hr = SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, pszPath, MAX_PATH);
904 }
905
906 if (SUCCEEDED(hr)) {
907 /* Win9x always returns ANSI strings, NT always returns Unicode strings */
908 if (GetVersion() & 0x80000000) {
909 strRet->uType = STRRET_CSTR;
910 if (!WideCharToMultiByte(CP_ACP, 0, pszPath, -1, strRet->u.cStr, MAX_PATH,
911 NULL, NULL))
912 strRet->u.cStr[0] = '\0';
913 CoTaskMemFree(pszPath);
914 } else {
915 strRet->uType = STRRET_WSTR;
916 strRet->u.pOleStr = pszPath;
917 }
918 } else
919 CoTaskMemFree(pszPath);
920
921 TRACE ("-- (%p)->(%s)\n", This, strRet->uType == STRRET_CSTR ? strRet->u.cStr : debugstr_w(strRet->u.pOleStr));
922 return hr;
923 }
924
925 /**************************************************************************
926 * IShellFolder_fnSetNameOf
927 * Changes the name of a file object or subfolder, possibly changing its item
928 * identifier in the process.
929 *
930 * PARAMETERS
931 * HWND hwndOwner, //[in ] Owner window for output
932 * LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
933 * LPCOLESTR lpszName, //[in ] the items new display name
934 * DWORD dwFlags, //[in ] SHGNO formatting flags
935 * LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
936 */
937 static HRESULT WINAPI IShellFolder_fnSetNameOf (IShellFolder2 * iface,
938 HWND hwndOwner,
939 LPCITEMIDLIST pidl,
940 LPCOLESTR lpName,
941 DWORD dwFlags,
942 LPITEMIDLIST * pPidlOut)
943 {
944 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
945 WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1];
946 LPWSTR ptr;
947 BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl));
948
949 TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", This, hwndOwner, pidl,
950 debugstr_w (lpName), dwFlags, pPidlOut);
951
952 /* build source path */
953 lstrcpynW(szSrc, This->sPathTarget, MAX_PATH);
954 ptr = PathAddBackslashW (szSrc);
955 if (ptr)
956 _ILSimpleGetTextW (pidl, ptr, MAX_PATH + 1 - (ptr - szSrc));
957
958 /* build destination path */
959 if (dwFlags == SHGDN_NORMAL || dwFlags & SHGDN_INFOLDER) {
960 lstrcpynW(szDest, This->sPathTarget, MAX_PATH);
961 ptr = PathAddBackslashW (szDest);
962 if (ptr)
963 lstrcpynW(ptr, lpName, MAX_PATH + 1 - (ptr - szDest));
964 } else
965 lstrcpynW(szDest, lpName, MAX_PATH);
966
967 if(!(dwFlags & SHGDN_FORPARSING) && SHELL_FS_HideExtension(szSrc)) {
968 WCHAR *ext = PathFindExtensionW(szSrc);
969 if(*ext != '\0') {
970 INT len = strlenW(szDest);
971 lstrcpynW(szDest + len, ext, MAX_PATH - len);
972 }
973 }
974
975 TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
976
977 if (MoveFileW (szSrc, szDest)) {
978 HRESULT hr = S_OK;
979
980 if (pPidlOut)
981 hr = _ILCreateFromPathW(szDest, pPidlOut);
982
983 SHChangeNotify (bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM,
984 SHCNF_PATHW, szSrc, szDest);
985
986 return hr;
987 }
988
989 return E_FAIL;
990 }
991
992 static HRESULT WINAPI IShellFolder_fnGetDefaultSearchGUID (IShellFolder2 *iface,
993 GUID * pguid)
994 {
995 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
996 FIXME ("(%p)\n", This);
997 return E_NOTIMPL;
998 }
999 static HRESULT WINAPI IShellFolder_fnEnumSearches (IShellFolder2 * iface,
1000 IEnumExtraSearch ** ppenum)
1001 {
1002 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1003 FIXME ("(%p)\n", This);
1004 return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI
1008 IShellFolder_fnGetDefaultColumn (IShellFolder2 * iface, DWORD dwRes,
1009 ULONG * pSort, ULONG * pDisplay)
1010 {
1011 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1012
1013 TRACE ("(%p)\n", This);
1014
1015 if (pSort)
1016 *pSort = 0;
1017 if (pDisplay)
1018 *pDisplay = 0;
1019
1020 return S_OK;
1021 }
1022
1023 static HRESULT WINAPI
1024 IShellFolder_fnGetDefaultColumnState (IShellFolder2 * iface, UINT iColumn,
1025 DWORD * pcsFlags)
1026 {
1027 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1028
1029 TRACE ("(%p)\n", This);
1030
1031 if (!pcsFlags || iColumn >= GENERICSHELLVIEWCOLUMNS)
1032 return E_INVALIDARG;
1033
1034 *pcsFlags = GenericSFHeader[iColumn].pcsFlags;
1035
1036 return S_OK;
1037 }
1038
1039 static HRESULT WINAPI
1040 IShellFolder_fnGetDetailsEx (IShellFolder2 * iface, LPCITEMIDLIST pidl,
1041 const SHCOLUMNID * pscid, VARIANT * pv)
1042 {
1043 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1044 FIXME ("(%p)\n", This);
1045
1046 return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI
1050 IShellFolder_fnGetDetailsOf (IShellFolder2 * iface, LPCITEMIDLIST pidl,
1051 UINT iColumn, SHELLDETAILS * psd)
1052 {
1053 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1054 HRESULT hr = E_FAIL;
1055
1056 TRACE ("(%p)->(%p %i %p)\n", This, pidl, iColumn, psd);
1057
1058 if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS)
1059 return E_INVALIDARG;
1060
1061 if (!pidl) {
1062 /* the header titles */
1063 psd->fmt = GenericSFHeader[iColumn].fmt;
1064 psd->cxChar = GenericSFHeader[iColumn].cxChar;
1065 psd->str.uType = STRRET_CSTR;
1066 LoadStringA (shell32_hInstance, GenericSFHeader[iColumn].colnameid,
1067 psd->str.u.cStr, MAX_PATH);
1068 return S_OK;
1069 } else {
1070 hr = S_OK;
1071 psd->str.uType = STRRET_CSTR;
1072 /* the data from the pidl */
1073 switch (iColumn) {
1074 case 0: /* name */
1075 hr = IShellFolder_GetDisplayNameOf (iface, pidl,
1076 SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
1077 break;
1078 case 1: /* size */
1079 _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
1080 break;
1081 case 2: /* type */
1082 _ILGetFileType (pidl, psd->str.u.cStr, MAX_PATH);
1083 break;
1084 case 3: /* date */
1085 _ILGetFileDate (pidl, psd->str.u.cStr, MAX_PATH);
1086 break;
1087 case 4: /* attributes */
1088 _ILGetFileAttributes (pidl, psd->str.u.cStr, MAX_PATH);
1089 break;
1090 }
1091 }
1092
1093 return hr;
1094 }
1095
1096 static HRESULT WINAPI
1097 IShellFolder_fnMapColumnToSCID (IShellFolder2 * iface, UINT column,
1098 SHCOLUMNID * pscid)
1099 {
1100 IGenericSFImpl *This = impl_from_IShellFolder2(iface);
1101 FIXME ("(%p)\n", This);
1102 return E_NOTIMPL;
1103 }
1104
1105 static const IShellFolder2Vtbl sfvt =
1106 {
1107 IShellFolder_fnQueryInterface,
1108 IShellFolder_fnAddRef,
1109 IShellFolder_fnRelease,
1110 IShellFolder_fnParseDisplayName,
1111 IShellFolder_fnEnumObjects,
1112 IShellFolder_fnBindToObject,
1113 IShellFolder_fnBindToStorage,
1114 IShellFolder_fnCompareIDs,
1115 IShellFolder_fnCreateViewObject,
1116 IShellFolder_fnGetAttributesOf,
1117 IShellFolder_fnGetUIObjectOf,
1118 IShellFolder_fnGetDisplayNameOf,
1119 IShellFolder_fnSetNameOf,
1120 /* ShellFolder2 */
1121 IShellFolder_fnGetDefaultSearchGUID,
1122 IShellFolder_fnEnumSearches,
1123 IShellFolder_fnGetDefaultColumn,
1124 IShellFolder_fnGetDefaultColumnState,
1125 IShellFolder_fnGetDetailsEx,
1126 IShellFolder_fnGetDetailsOf,
1127 IShellFolder_fnMapColumnToSCID
1128 };
1129
1130 /****************************************************************************
1131 * ISFHelper for IShellFolder implementation
1132 */
1133
1134 static HRESULT WINAPI
1135 ISFHelper_fnQueryInterface (ISFHelper * iface, REFIID riid, LPVOID * ppvObj)
1136 {
1137 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1138
1139 TRACE ("(%p)->(count=%u)\n", This, This->ref);
1140
1141 return IUnknown_QueryInterface (This->pUnkOuter, riid, ppvObj);
1142 }
1143
1144 static ULONG WINAPI ISFHelper_fnAddRef (ISFHelper * iface)
1145 {
1146 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1147
1148 TRACE ("(%p)->(count=%u)\n", This, This->ref);
1149
1150 return IUnknown_AddRef (This->pUnkOuter);
1151 }
1152
1153 static ULONG WINAPI ISFHelper_fnRelease (ISFHelper * iface)
1154 {
1155 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1156
1157 TRACE ("(%p)\n", This);
1158
1159 return IUnknown_Release (This->pUnkOuter);
1160 }
1161
1162 /****************************************************************************
1163 * ISFHelper_fnGetUniqueName
1164 *
1165 * creates a unique folder name
1166 */
1167
1168 static HRESULT WINAPI
1169 ISFHelper_fnGetUniqueName (ISFHelper * iface, LPWSTR pwszName, UINT uLen)
1170 {
1171 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1172 IEnumIDList *penum;
1173 HRESULT hr;
1174 WCHAR wszText[MAX_PATH];
1175 WCHAR wszNewFolder[25];
1176 const WCHAR wszFormat[] = {'%','s',' ','%','d',0 };
1177
1178 TRACE ("(%p)(%p %u)\n", This, pwszName, uLen);
1179
1180 LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, sizeof(wszNewFolder)/sizeof(WCHAR));
1181 if (uLen < sizeof(wszNewFolder)/sizeof(WCHAR) + 3)
1182 return E_POINTER;
1183
1184 lstrcpynW (pwszName, wszNewFolder, uLen);
1185
1186 hr = IShellFolder_fnEnumObjects (_IShellFolder2_ (This), 0,
1187 SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penum);
1188 if (penum) {
1189 LPITEMIDLIST pidl;
1190 DWORD dwFetched;
1191 int i = 1;
1192
1193 next:
1194 IEnumIDList_Reset (penum);
1195 while (S_OK == IEnumIDList_Next (penum, 1, &pidl, &dwFetched) &&
1196 dwFetched) {
1197 _ILSimpleGetTextW (pidl, wszText, MAX_PATH);
1198 if (0 == lstrcmpiW (wszText, pwszName)) {
1199 snprintfW (pwszName, uLen, wszFormat, wszNewFolder, i++);
1200 if (i > 99) {
1201 hr = E_FAIL;
1202 break;
1203 }
1204 goto next;
1205 }
1206 }
1207
1208 IEnumIDList_Release (penum);
1209 }
1210 return hr;
1211 }
1212
1213 /****************************************************************************
1214 * ISFHelper_fnAddFolder
1215 *
1216 * adds a new folder.
1217 */
1218
1219 static HRESULT WINAPI
1220 ISFHelper_fnAddFolder (ISFHelper * iface, HWND hwnd, LPCWSTR pwszName,
1221 LPITEMIDLIST * ppidlOut)
1222 {
1223 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1224 WCHAR wszNewDir[MAX_PATH];
1225 DWORD bRes;
1226 HRESULT hres = E_FAIL;
1227
1228 TRACE ("(%p)(%s %p)\n", This, debugstr_w(pwszName), ppidlOut);
1229
1230 wszNewDir[0] = 0;
1231 if (This->sPathTarget)
1232 lstrcpynW(wszNewDir, This->sPathTarget, MAX_PATH);
1233 PathAppendW(wszNewDir, pwszName);
1234
1235 bRes = CreateDirectoryW (wszNewDir, NULL);
1236 if (bRes) {
1237 LPITEMIDLIST relPidl;
1238
1239 lstrcpyW(wszNewDir, pwszName);
1240
1241 hres = IShellFolder_ParseDisplayName((IShellFolder*)&This->lpvtblShellFolder,
1242 hwnd, NULL, wszNewDir, NULL, &relPidl, NULL);
1243
1244 if (SUCCEEDED(hres)) {
1245 LPITEMIDLIST fullPidl;
1246
1247 fullPidl = ILCombine(This->pidlRoot, relPidl);
1248
1249 if (fullPidl) {
1250 SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, fullPidl, NULL);
1251 ILFree(fullPidl);
1252
1253 if (ppidlOut)
1254 *ppidlOut = relPidl;
1255 else
1256 ILFree(relPidl);
1257 } else {
1258 WARN("failed to combine %s into a full PIDL\n", wine_dbgstr_w(pwszName));
1259 ILFree(relPidl);
1260 }
1261
1262 } else
1263 WARN("failed to parse %s into a PIDL\n", wine_dbgstr_w(pwszName));
1264
1265 } else {
1266 WCHAR wszText[128 + MAX_PATH];
1267 WCHAR wszTempText[128];
1268 WCHAR wszCaption[256];
1269
1270 /* Cannot Create folder because of permissions */
1271 LoadStringW (shell32_hInstance, IDS_CREATEFOLDER_DENIED, wszTempText,
1272 sizeof (wszTempText)/sizeof (wszTempText[0]));
1273 LoadStringW (shell32_hInstance, IDS_CREATEFOLDER_CAPTION, wszCaption,
1274 sizeof (wszCaption)/sizeof (wszCaption[0]));
1275 sprintfW (wszText, wszTempText, wszNewDir);
1276 MessageBoxW (hwnd, wszText, wszCaption, MB_OK | MB_ICONEXCLAMATION);
1277 }
1278
1279 return hres;
1280 }
1281
1282 /****************************************************************************
1283 * build_paths_list
1284 *
1285 * Builds a list of paths like the one used in SHFileOperation from a table of
1286 * PIDLs relative to the given base folder
1287 */
1288 static WCHAR *build_paths_list(LPCWSTR wszBasePath, int cidl, const LPCITEMIDLIST *pidls)
1289 {
1290 WCHAR *wszPathsList;
1291 WCHAR *wszListPos;
1292 int iPathLen;
1293 int i;
1294
1295 iPathLen = lstrlenW(wszBasePath);
1296 wszPathsList = HeapAlloc(GetProcessHeap(), 0, MAX_PATH*sizeof(WCHAR)*cidl+1);
1297 wszListPos = wszPathsList;
1298
1299 for (i = 0; i < cidl; i++) {
1300 if (!_ILIsFolder(pidls[i]) && !_ILIsValue(pidls[i]))
1301 continue;
1302
1303 lstrcpynW(wszListPos, wszBasePath, MAX_PATH);
1304 /* FIXME: abort if path too long */
1305 _ILSimpleGetTextW(pidls[i], wszListPos+iPathLen, MAX_PATH-iPathLen);
1306 wszListPos += lstrlenW(wszListPos)+1;
1307 }
1308 *wszListPos=0;
1309 return wszPathsList;
1310 }
1311
1312 /****************************************************************************
1313 * ISFHelper_fnDeleteItems
1314 *
1315 * deletes items in folder
1316 */
1317 static HRESULT WINAPI
1318 ISFHelper_fnDeleteItems (ISFHelper * iface, UINT cidl, LPCITEMIDLIST * apidl)
1319 {
1320 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1321 UINT i;
1322 SHFILEOPSTRUCTW op;
1323 WCHAR wszPath[MAX_PATH];
1324 WCHAR *wszPathsList;
1325 HRESULT ret;
1326 WCHAR *wszCurrentPath;
1327
1328 TRACE ("(%p)(%u %p)\n", This, cidl, apidl);
1329 if (cidl==0) return S_OK;
1330
1331 if (This->sPathTarget)
1332 lstrcpynW(wszPath, This->sPathTarget, MAX_PATH);
1333 else
1334 wszPath[0] = '\0';
1335 PathAddBackslashW(wszPath);
1336 wszPathsList = build_paths_list(wszPath, cidl, apidl);
1337
1338 ZeroMemory(&op, sizeof(op));
1339 op.hwnd = GetActiveWindow();
1340 op.wFunc = FO_DELETE;
1341 op.pFrom = wszPathsList;
1342 op.fFlags = FOF_ALLOWUNDO;
1343 if (SHFileOperationW(&op))
1344 {
1345 WARN("SHFileOperation failed\n");
1346 ret = E_FAIL;
1347 }
1348 else
1349 ret = S_OK;
1350
1351 /* we currently need to manually send the notifies */
1352 wszCurrentPath = wszPathsList;
1353 for (i = 0; i < cidl; i++)
1354 {
1355 LONG wEventId;
1356
1357 if (_ILIsFolder(apidl[i]))
1358 wEventId = SHCNE_RMDIR;
1359 else if (_ILIsValue(apidl[i]))
1360 wEventId = SHCNE_DELETE;
1361 else
1362 continue;
1363
1364 /* check if file exists */
1365 if (GetFileAttributesW(wszCurrentPath) == INVALID_FILE_ATTRIBUTES)
1366 {
1367 LPITEMIDLIST pidl = ILCombine(This->pidlRoot, apidl[i]);
1368 SHChangeNotify(wEventId, SHCNF_IDLIST, pidl, NULL);
1369 SHFree(pidl);
1370 }
1371
1372 wszCurrentPath += lstrlenW(wszCurrentPath)+1;
1373 }
1374 HeapFree(GetProcessHeap(), 0, wszPathsList);
1375 return ret;
1376 }
1377
1378 /****************************************************************************
1379 * ISFHelper_fnCopyItems
1380 *
1381 * copies items to this folder
1382 */
1383 static HRESULT WINAPI
1384 ISFHelper_fnCopyItems (ISFHelper * iface, IShellFolder * pSFFrom, UINT cidl,
1385 LPCITEMIDLIST * apidl)
1386 {
1387 HRESULT ret=E_FAIL;
1388 IPersistFolder2 *ppf2 = NULL;
1389 WCHAR wszSrcPathRoot[MAX_PATH],
1390 wszDstPath[MAX_PATH+1];
1391 WCHAR *wszSrcPathsList;
1392 IGenericSFImpl *This = impl_from_ISFHelper(iface);
1393
1394 SHFILEOPSTRUCTW fop;
1395
1396 TRACE ("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
1397
1398 IShellFolder_QueryInterface (pSFFrom, &IID_IPersistFolder2,
1399 (LPVOID *) & ppf2);
1400 if (ppf2) {
1401 LPITEMIDLIST pidl;
1402
1403 if (SUCCEEDED (IPersistFolder2_GetCurFolder (ppf2, &pidl))) {
1404 SHGetPathFromIDListW (pidl, wszSrcPathRoot);
1405 ZeroMemory(wszDstPath, MAX_PATH+1);
1406 if (This->sPathTarget)
1407 lstrcpynW(wszDstPath, This->sPathTarget, MAX_PATH);
1408 PathAddBackslashW(wszSrcPathRoot);
1409 PathAddBackslashW(wszDstPath);
1410 wszSrcPathsList = build_paths_list(wszSrcPathRoot, cidl, apidl);
1411 ZeroMemory(&fop, sizeof(fop));
1412 fop.hwnd = GetActiveWindow();
1413 fop.wFunc = FO_COPY;
1414 fop.pFrom = wszSrcPathsList;
1415 fop.pTo = wszDstPath;
1416 fop.fFlags = FOF_ALLOWUNDO;
1417 ret = S_OK;
1418 if(SHFileOperationW(&fop))
1419 {
1420 WARN("Copy failed\n");
1421 ret = E_FAIL;
1422 }
1423 HeapFree(GetProcessHeap(), 0, wszSrcPathsList);
1424
1425 }
1426 SHFree(pidl);
1427 IPersistFolder2_Release(ppf2);
1428 }
1429 return ret;
1430 }
1431
1432 static const ISFHelperVtbl shvt =
1433 {
1434 ISFHelper_fnQueryInterface,
1435 ISFHelper_fnAddRef,
1436 ISFHelper_fnRelease,
1437 ISFHelper_fnGetUniqueName,
1438 ISFHelper_fnAddFolder,
1439 ISFHelper_fnDeleteItems,
1440 ISFHelper_fnCopyItems
1441 };
1442
1443 /************************************************************************
1444 * IFSFldr_PersistFolder3_QueryInterface
1445 *
1446 */
1447 static HRESULT WINAPI
1448 IFSFldr_PersistFolder3_QueryInterface (IPersistFolder3 * iface, REFIID iid,
1449 LPVOID * ppvObj)
1450 {
1451 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1452
1453 TRACE ("(%p)\n", This);
1454
1455 return IUnknown_QueryInterface (This->pUnkOuter, iid, ppvObj);
1456 }
1457
1458 /************************************************************************
1459 * IFSFldr_PersistFolder3_AddRef
1460 *
1461 */
1462 static ULONG WINAPI
1463 IFSFldr_PersistFolder3_AddRef (IPersistFolder3 * iface)
1464 {
1465 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1466
1467 TRACE ("(%p)->(count=%u)\n", This, This->ref);
1468
1469 return IUnknown_AddRef (This->pUnkOuter);
1470 }
1471
1472 /************************************************************************
1473 * IFSFldr_PersistFolder3_Release
1474 *
1475 */
1476 static ULONG WINAPI
1477 IFSFldr_PersistFolder3_Release (IPersistFolder3 * iface)
1478 {
1479 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1480
1481 TRACE ("(%p)->(count=%u)\n", This, This->ref);
1482
1483 return IUnknown_Release (This->pUnkOuter);
1484 }
1485
1486 /************************************************************************
1487 * IFSFldr_PersistFolder3_GetClassID
1488 */
1489 static HRESULT WINAPI
1490 IFSFldr_PersistFolder3_GetClassID (IPersistFolder3 * iface, CLSID * lpClassId)
1491 {
1492 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1493
1494 TRACE ("(%p)\n", This);
1495
1496 if (!lpClassId)
1497 return E_POINTER;
1498 *lpClassId = *This->pclsid;
1499
1500 return S_OK;
1501 }
1502
1503 /************************************************************************
1504 * IFSFldr_PersistFolder3_Initialize
1505 *
1506 * NOTES
1507 * sPathTarget is not set. Don't know how to handle in a non rooted environment.
1508 */
1509 static HRESULT WINAPI
1510 IFSFldr_PersistFolder3_Initialize (IPersistFolder3 * iface, LPCITEMIDLIST pidl)
1511 {
1512 WCHAR wszTemp[MAX_PATH];
1513
1514 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1515
1516 TRACE ("(%p)->(%p)\n", This, pidl);
1517
1518 SHFree (This->pidlRoot); /* free the old pidl */
1519 This->pidlRoot = ILClone (pidl); /* set my pidl */
1520
1521 SHFree (This->sPathTarget);
1522 This->sPathTarget = NULL;
1523
1524 /* set my path */
1525 if (SHGetPathFromIDListW (pidl, wszTemp)) {
1526 int len = strlenW(wszTemp);
1527 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1528 if (!This->sPathTarget)
1529 return E_OUTOFMEMORY;
1530 memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1531 }
1532
1533 TRACE ("--(%p)->(%s)\n", This, debugstr_w(This->sPathTarget));
1534 return S_OK;
1535 }
1536
1537 /**************************************************************************
1538 * IFSFldr_PersistFolder3_GetCurFolder
1539 */
1540 static HRESULT WINAPI
1541 IFSFldr_PersistFolder3_fnGetCurFolder (IPersistFolder3 * iface,
1542 LPITEMIDLIST * pidl)
1543 {
1544 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1545
1546 TRACE ("(%p)->(%p)\n", This, pidl);
1547
1548 if (!pidl) return E_POINTER;
1549 *pidl = ILClone (This->pidlRoot);
1550 return S_OK;
1551 }
1552
1553 /**************************************************************************
1554 * IFSFldr_PersistFolder3_InitializeEx
1555 *
1556 * FIXME: error handling
1557 */
1558 static HRESULT WINAPI
1559 IFSFldr_PersistFolder3_InitializeEx (IPersistFolder3 * iface,
1560 IBindCtx * pbc, LPCITEMIDLIST pidlRoot,
1561 const PERSIST_FOLDER_TARGET_INFO * ppfti)
1562 {
1563 WCHAR wszTemp[MAX_PATH];
1564
1565 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1566
1567 TRACE ("(%p)->(%p,%p,%p)\n", This, pbc, pidlRoot, ppfti);
1568 if (ppfti)
1569 TRACE ("--%p %s %s 0x%08x 0x%08x\n",
1570 ppfti->pidlTargetFolder, debugstr_w (ppfti->szTargetParsingName),
1571 debugstr_w (ppfti->szNetworkProvider), ppfti->dwAttributes,
1572 ppfti->csidl);
1573
1574 pdump (pidlRoot);
1575 if (ppfti && ppfti->pidlTargetFolder)
1576 pdump (ppfti->pidlTargetFolder);
1577
1578 if (This->pidlRoot)
1579 __SHFreeAndNil (&This->pidlRoot); /* free the old */
1580 if (This->sPathTarget)
1581 __SHFreeAndNil (&This->sPathTarget);
1582
1583 /*
1584 * Root path and pidl
1585 */
1586 This->pidlRoot = ILClone (pidlRoot);
1587
1588 /*
1589 * the target folder is specified in csidl OR pidlTargetFolder OR
1590 * szTargetParsingName
1591 */
1592 if (ppfti) {
1593 if (ppfti->csidl != -1) {
1594 if (SHGetSpecialFolderPathW (0, wszTemp, ppfti->csidl,
1595 ppfti->csidl & CSIDL_FLAG_CREATE)) {
1596 int len = strlenW(wszTemp);
1597 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1598 if (!This->sPathTarget)
1599 return E_OUTOFMEMORY;
1600 memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1601 }
1602 } else if (ppfti->szTargetParsingName[0]) {
1603 int len = strlenW(ppfti->szTargetParsingName);
1604 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1605 if (!This->sPathTarget)
1606 return E_OUTOFMEMORY;
1607 memcpy(This->sPathTarget, ppfti->szTargetParsingName,
1608 (len + 1) * sizeof(WCHAR));
1609 } else if (ppfti->pidlTargetFolder) {
1610 if (SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTemp)) {
1611 int len = strlenW(wszTemp);
1612 This->sPathTarget = SHAlloc((len + 1) * sizeof(WCHAR));
1613 if (!This->sPathTarget)
1614 return E_OUTOFMEMORY;
1615 memcpy(This->sPathTarget, wszTemp, (len + 1) * sizeof(WCHAR));
1616 }
1617 }
1618 }
1619
1620 TRACE ("--(%p)->(target=%s)\n", This, debugstr_w(This->sPathTarget));
1621 pdump (This->pidlRoot);
1622 return (This->sPathTarget) ? S_OK : E_FAIL;
1623 }
1624
1625 static HRESULT WINAPI
1626 IFSFldr_PersistFolder3_GetFolderTargetInfo (IPersistFolder3 * iface,
1627 PERSIST_FOLDER_TARGET_INFO * ppfti)
1628 {
1629 IGenericSFImpl *This = impl_from_IPersistFolder3(iface);
1630 FIXME ("(%p)->(%p)\n", This, ppfti);
1631 ZeroMemory (ppfti, sizeof (*ppfti));
1632 return E_NOTIMPL;
1633 }
1634
1635 static const IPersistFolder3Vtbl vt_FSFldr_PersistFolder3 =
1636 {
1637 IFSFldr_PersistFolder3_QueryInterface,
1638 IFSFldr_PersistFolder3_AddRef,
1639 IFSFldr_PersistFolder3_Release,
1640 IFSFldr_PersistFolder3_GetClassID,
1641 IFSFldr_PersistFolder3_Initialize,
1642 IFSFldr_PersistFolder3_fnGetCurFolder,
1643 IFSFldr_PersistFolder3_InitializeEx,
1644 IFSFldr_PersistFolder3_GetFolderTargetInfo
1645 };
1646
1647 /****************************************************************************
1648 * ISFDropTarget implementation
1649 */
1650 static BOOL
1651 ISFDropTarget_QueryDrop (IDropTarget * iface, DWORD dwKeyState,
1652 LPDWORD pdwEffect)
1653 {
1654 DWORD dwEffect = *pdwEffect;
1655
1656 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1657
1658 *pdwEffect = DROPEFFECT_NONE;
1659
1660 if (This->fAcceptFmt) { /* Does our interpretation of the keystate ... */
1661 *pdwEffect = KeyStateToDropEffect (dwKeyState);
1662
1663 /* ... matches the desired effect ? */
1664 if (dwEffect & *pdwEffect) {
1665 return TRUE;
1666 }
1667 }
1668 return FALSE;
1669 }
1670
1671 static HRESULT WINAPI
1672 ISFDropTarget_QueryInterface (IDropTarget * iface, REFIID riid, LPVOID * ppvObj)
1673 {
1674 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1675
1676 TRACE ("(%p)\n", This);
1677
1678 return IUnknown_QueryInterface (This->pUnkOuter, riid, ppvObj);
1679 }
1680
1681 static ULONG WINAPI ISFDropTarget_AddRef (IDropTarget * iface)
1682 {
1683 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1684
1685 TRACE ("(%p)\n", This);
1686
1687 return IUnknown_AddRef (This->pUnkOuter);
1688 }
1689
1690 static ULONG WINAPI ISFDropTarget_Release (IDropTarget * iface)
1691 {
1692 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1693
1694 TRACE ("(%p)\n", This);
1695
1696 return IUnknown_Release (This->pUnkOuter);
1697 }
1698
1699 static HRESULT WINAPI
1700 ISFDropTarget_DragEnter (IDropTarget * iface, IDataObject * pDataObject,
1701 DWORD dwKeyState, POINTL pt, DWORD * pdwEffect)
1702 {
1703 FORMATETC fmt;
1704
1705 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1706
1707 TRACE ("(%p)->(DataObject=%p)\n", This, pDataObject);
1708
1709 InitFormatEtc (fmt, This->cfShellIDList, TYMED_HGLOBAL);
1710
1711 This->fAcceptFmt = (S_OK == IDataObject_QueryGetData (pDataObject, &fmt)) ?
1712 TRUE : FALSE;
1713
1714 ISFDropTarget_QueryDrop (iface, dwKeyState, pdwEffect);
1715
1716 return S_OK;
1717 }
1718
1719 static HRESULT WINAPI
1720 ISFDropTarget_DragOver (IDropTarget * iface, DWORD dwKeyState, POINTL pt,
1721 DWORD * pdwEffect)
1722 {
1723 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1724
1725 TRACE ("(%p)\n", This);
1726
1727 if (!pdwEffect)
1728 return E_INVALIDARG;
1729
1730 ISFDropTarget_QueryDrop (iface, dwKeyState, pdwEffect);
1731
1732 return S_OK;
1733 }
1734
1735 static HRESULT WINAPI ISFDropTarget_DragLeave (IDropTarget * iface)
1736 {
1737 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1738
1739 TRACE ("(%p)\n", This);
1740
1741 This->fAcceptFmt = FALSE;
1742
1743 return S_OK;
1744 }
1745
1746 static HRESULT WINAPI
1747 ISFDropTarget_Drop (IDropTarget * iface, IDataObject * pDataObject,
1748 DWORD dwKeyState, POINTL pt, DWORD * pdwEffect)
1749 {
1750 IGenericSFImpl *This = impl_from_IDropTarget(iface);
1751
1752 FIXME ("(%p) object dropped\n", This);
1753
1754 return E_NOTIMPL;
1755 }
1756
1757 static const IDropTargetVtbl dtvt = {
1758 ISFDropTarget_QueryInterface,
1759 ISFDropTarget_AddRef,
1760 ISFDropTarget_Release,
1761 ISFDropTarget_DragEnter,
1762 ISFDropTarget_DragOver,
1763 ISFDropTarget_DragLeave,
1764 ISFDropTarget_Drop
1765 };
Windows API implementation