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