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