?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make RDW_ValidateParent() modify the update region of all parents, not
[wine/multimedia.git] / dlls / shell32 / shlfolder.c
blob5512f71035c70851024cf7c6576064c42fc61e42
1 /*
2 * Shell Folder stuff
3 *
4 * Copyright 1997 Marcus Meissner
5 * Copyright 1998, 1999 Juergen Schmied
6 *
7 * IShellFolder2 and related interfaces
8 *
9 */
10
11 #include <stdlib.h>
12 #include <string.h>
13 #include <stdio.h>
14
15 #include "debugtools.h"
16 #include "winerror.h"
17
18 #include "oleidl.h"
19 #include "shlguid.h"
20
21 #include "pidl.h"
22 #include "wine/obj_base.h"
23 #include "wine/obj_dragdrop.h"
24 #include "wine/obj_shellfolder.h"
25 #include "wine/undocshell.h"
26 #include "shell32_main.h"
27 #include "shresdef.h"
28
29 #define INITGUID
30 #include "initguid.h"
31 #include "shellfolder.h"
32
33
34 DEFAULT_DEBUG_CHANNEL(shell)
35
36
37 /***************************************************************************
38 * debughelper: print out the return adress
39 * helps especially to track down unbalanced AddRef/Release
40 */
41 #define MEM_DEBUG 0
42
43 #if MEM_DEBUG
44 #define _CALL_TRACE TRACE("called from: 0x%08x\n", *( ((UINT*)&iface)-1 ));
45 #else
46 #define _CALL_TRACE
47 #endif
48
49 typedef struct
50 {
51 int colnameid;
52 int pcsFlags;
53 int fmt;
54 int cxChar;
55
56 } shvheader;
57
58 /***************************************************************************
59 * GetNextElement (internal function)
60 *
61 * gets a part of a string till the first backslash
62 *
63 * PARAMETERS
64 * pszNext [IN] string to get the element from
65 * pszOut [IN] pointer to buffer whitch receives string
66 * dwOut [IN] length of pszOut
67 *
68 * RETURNS
69 * LPSTR pointer to first, not yet parsed char
70 */
71
72 static LPCWSTR GetNextElementW(LPCWSTR pszNext,LPWSTR pszOut,DWORD dwOut)
73 { LPCWSTR pszTail = pszNext;
74 DWORD dwCopy;
75 TRACE("(%s %p 0x%08lx)\n",debugstr_w(pszNext),pszOut,dwOut);
76
77 *pszOut=0x0000;
78
79 if(!pszNext || !*pszNext)
80 return NULL;
81
82 while(*pszTail && (*pszTail != (WCHAR)'\\'))
83 pszTail++;
84
85 dwCopy = (WCHAR*)pszTail - (WCHAR*)pszNext + 1;
86 lstrcpynW(pszOut, pszNext, (dwOut<dwCopy)? dwOut : dwCopy);
87
88 if(*pszTail)
89 pszTail++;
90 else
91 pszTail = NULL;
92
93 TRACE("--(%s %s 0x%08lx %p)\n",debugstr_w(pszNext),debugstr_w(pszOut),dwOut,pszTail);
94 return pszTail;
95 }
96
97 static HRESULT SHELL32_ParseNextElement(
98 HWND hwndOwner,
99 IShellFolder2 * psf,
100 LPITEMIDLIST * pidlInOut,
101 LPOLESTR szNext,
102 DWORD *pEaten,
103 DWORD *pdwAttributes)
104 {
105 HRESULT hr = E_OUTOFMEMORY;
106 LPITEMIDLIST pidlOut, pidlTemp = NULL;
107 IShellFolder *psfChild;
108
109 TRACE("(%p, %p, %s)\n",psf, pidlInOut ? *pidlInOut : NULL, debugstr_w(szNext));
110
111
112 /* get the shellfolder for the child pidl and let it analyse further */
113 hr = IShellFolder_BindToObject(psf, *pidlInOut, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
114
115 if (psfChild)
116 {
117 hr = IShellFolder_ParseDisplayName(psfChild, hwndOwner, NULL, szNext, pEaten, &pidlOut, pdwAttributes);
118 IShellFolder_Release(psfChild);
119
120 pidlTemp = ILCombine(*pidlInOut, pidlOut);
121
122 if (pidlOut)
123 ILFree(pidlOut);
124 }
125
126 ILFree(*pidlInOut);
127 *pidlInOut = pidlTemp;
128
129 TRACE("-- pidl=%p ret=0x%08lx\n", pidlInOut? *pidlInOut: NULL, hr);
130 return hr;
131 }
132
133 /***********************************************************************
134 * SHELL32_CoCreateInitSF
135 *
136 * creates a initialized shell folder
137 */
138 static HRESULT SHELL32_CoCreateInitSF (
139 LPITEMIDLIST pidlRoot,
140 LPITEMIDLIST pidlChild,
141 REFCLSID clsid,
142 REFIID iid,
143 LPVOID * ppvOut)
144 {
145 HRESULT hr;
146 LPITEMIDLIST absPidl;
147 IShellFolder2 *pShellFolder;
148 IPersistFolder *pPersistFolder;
149
150 TRACE("%p %p\n", pidlRoot, pidlChild);
151
152 *ppvOut = NULL;
153
154 /* we have to ask first for IPersistFolder, some special folders are expecting this */
155 hr = SHCoCreateInstance(NULL, clsid, NULL, &IID_IPersistFolder, (LPVOID*)&pPersistFolder);
156 if (SUCCEEDED(hr))
157 {
158 hr = IPersistFolder_QueryInterface(pPersistFolder, iid, (LPVOID*)&pShellFolder);
159 if (SUCCEEDED(hr))
160 {
161 absPidl = ILCombine (pidlRoot, pidlChild);
162 hr = IPersistFolder_Initialize(pPersistFolder, absPidl);
163 IPersistFolder_Release(pPersistFolder);
164 SHFree(absPidl);
165 *ppvOut = pShellFolder;
166 }
167 }
168
169 TRACE("-- ret=0x%08lx\n", hr);
170 return hr;
171 }
172
173 static HRESULT SHELL32_GetDisplayNameOfChild(
174 IShellFolder2 * psf,
175 LPCITEMIDLIST pidl,
176 DWORD dwFlags,
177 LPSTR szOut,
178 DWORD dwOutLen)
179 {
180 LPITEMIDLIST pidlFirst, pidlNext;
181 IShellFolder2 * psfChild;
182 HRESULT hr = E_OUTOFMEMORY;
183 STRRET strTemp;
184
185 TRACE("(%p)->(pidl=%p 0x%08lx %p 0x%08lx)\n",psf,pidl,dwFlags,szOut, dwOutLen);
186 pdump(pidl);
187
188 if ((pidlFirst = ILCloneFirst(pidl)))
189 {
190 hr = IShellFolder_BindToObject(psf, pidlFirst, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
191 if (SUCCEEDED(hr))
192 {
193 pidlNext = ILGetNext(pidl);
194
195 hr = IShellFolder_GetDisplayNameOf(psfChild, pidlNext, dwFlags | SHGDN_INFOLDER, &strTemp);
196 if (SUCCEEDED(hr))
197 {
198 hr = StrRetToStrNA(szOut, dwOutLen, &strTemp, pidlNext);
199 }
200
201 IShellFolder_Release(psfChild);
202 }
203 ILFree(pidlFirst);
204 }
205
206 TRACE("-- ret=0x%08lx %s\n", hr, szOut);
207
208 return hr;
209 }
210
211 /***********************************************************************
212 * IShellFolder implementation
213 */
214
215 typedef struct
216 {
217 ICOM_VFIELD(IUnknown);
218 DWORD ref;
219 ICOM_VTABLE(IShellFolder2)* lpvtblShellFolder;
220 ICOM_VTABLE(IPersistFolder2)* lpvtblPersistFolder2;
221 ICOM_VTABLE(IDropTarget)* lpvtblDropTarget;
222 ICOM_VTABLE(ISFHelper)* lpvtblSFHelper;
223
224 IUnknown *pUnkOuter; /* used for aggregation */
225
226 CLSID* pclsid;
227
228 LPSTR sMyPath;
229 LPITEMIDLIST absPidl; /* complete pidl */
230
231 UINT cfShellIDList; /* clipboardformat for IDropTarget */
232 BOOL fAcceptFmt; /* flag for pending Drop */
233 } IGenericSFImpl;
234
235 static struct ICOM_VTABLE(IUnknown) unkvt;
236 static struct ICOM_VTABLE(IShellFolder2) sfvt;
237 static struct ICOM_VTABLE(IPersistFolder2) psfvt;
238 static struct ICOM_VTABLE(IDropTarget) dtvt;
239 static struct ICOM_VTABLE(ISFHelper) shvt;
240
241 static IShellFolder * ISF_MyComputer_Constructor(void);
242
243 #define _IShellFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblShellFolder)))
244 #define _ICOM_THIS_From_IShellFolder2(class, name) class* This = (class*)(((char*)name)-_IShellFolder2_Offset);
245
246 #define _IPersistFolder_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblPersistFolder2)))
247 #define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder_Offset);
248
249 #define _IDropTarget_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblDropTarget)))
250 #define _ICOM_THIS_From_IDropTarget(class, name) class* This = (class*)(((char*)name)-_IDropTarget_Offset);
251
252 #define _ISFHelper_Offset ((int)(&(((IGenericSFImpl*)0)->lpvtblSFHelper)))
253 #define _ICOM_THIS_From_ISFHelper(class, name) class* This = (class*)(((char*)name)-_ISFHelper_Offset);
254 /*
255 converts This to a interface pointer
256 */
257 #define _IUnknown_(This) (IUnknown*)&(This->lpVtbl)
258 #define _IShellFolder_(This) (IShellFolder*)&(This->lpvtblShellFolder)
259 #define _IShellFolder2_(This) (IShellFolder2*)&(This->lpvtblShellFolder)
260 #define _IPersist_(This) (IPersist*)&(This->lpvtblPersistFolder2)
261 #define _IPersistFolder_(This) (IPersistFolder*)&(This->lpvtblPersistFolder2)
262 #define _IPersistFolder2_(This) (IPersistFolder2*)&(This->lpvtblPersistFolder2)
263 #define _IDropTarget_(This) (IDropTarget*)&(This->lpvtblDropTarget)
264 #define _ISFHelper_(This) (ISFHelper*)&(This->lpvtblSFHelper)
265 /**************************************************************************
266 * registers clipboardformat once
267 */
268 static void SF_RegisterClipFmt (IGenericSFImpl * This)
269 {
270 TRACE("(%p)\n", This);
271
272 if (!This->cfShellIDList)
273 {
274 This->cfShellIDList = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
275 }
276 }
277
278 /**************************************************************************
279 * we need a seperate IUnknown to handle aggregation
280 * (inner IUnknown)
281 */
282 static HRESULT WINAPI IUnknown_fnQueryInterface(
283 IUnknown * iface,
284 REFIID riid,
285 LPVOID *ppvObj)
286 {
287 ICOM_THIS(IGenericSFImpl, iface);
288
289 _CALL_TRACE
290 TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
291
292 *ppvObj = NULL;
293
294 if(IsEqualIID(riid, &IID_IUnknown)) *ppvObj = _IUnknown_(This);
295 else if(IsEqualIID(riid, &IID_IShellFolder)) *ppvObj = _IShellFolder_(This);
296 else if(IsEqualIID(riid, &IID_IShellFolder2)) *ppvObj = _IShellFolder_(This);
297 else if(IsEqualIID(riid, &IID_IPersist)) *ppvObj = _IPersist_(This);
298 else if(IsEqualIID(riid, &IID_IPersistFolder)) *ppvObj = _IPersistFolder_(This);
299 else if(IsEqualIID(riid, &IID_IPersistFolder2)) *ppvObj = _IPersistFolder2_(This);
300 else if(IsEqualIID(riid, &IID_ISFHelper)) *ppvObj = _ISFHelper_(This);
301 else if(IsEqualIID(riid, &IID_IDropTarget))
302 {
303 *ppvObj = _IDropTarget_(This);
304 SF_RegisterClipFmt(This);
305 }
306
307 if(*ppvObj)
308 {
309 IUnknown_AddRef((IUnknown*)(*ppvObj));
310 TRACE("-- Interface = %p\n", *ppvObj);
311 return S_OK;
312 }
313 TRACE("-- Interface: E_NOINTERFACE\n");
314 return E_NOINTERFACE;
315 }
316
317 static ULONG WINAPI IUnknown_fnAddRef(IUnknown * iface)
318 {
319 ICOM_THIS(IGenericSFImpl, iface);
320
321 _CALL_TRACE
322 TRACE("(%p)->(count=%lu)\n",This,This->ref);
323
324 shell32_ObjCount++;
325 return ++(This->ref);
326 }
327
328 static ULONG WINAPI IUnknown_fnRelease(IUnknown * iface)
329 {
330 ICOM_THIS(IGenericSFImpl, iface);
331
332 _CALL_TRACE
333 TRACE("(%p)->(count=%lu)\n",This,This->ref);
334
335 shell32_ObjCount--;
336 if (!--(This->ref))
337 {
338 TRACE("-- destroying IShellFolder(%p)\n",This);
339
340 if (pdesktopfolder == _IShellFolder_(This))
341 {
342 pdesktopfolder=NULL;
343 TRACE("-- destroyed IShellFolder(%p) was Desktopfolder\n",This);
344 }
345 if(This->absPidl) SHFree(This->absPidl);
346 if(This->sMyPath) SHFree(This->sMyPath);
347 HeapFree(GetProcessHeap(),0,This);
348 return 0;
349 }
350 return This->ref;
351 }
352
353 static ICOM_VTABLE(IUnknown) unkvt =
354 {
355 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
356 IUnknown_fnQueryInterface,
357 IUnknown_fnAddRef,
358 IUnknown_fnRelease,
359 };
360
361 static shvheader GenericSFHeader [] =
362 {
363 { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
364 { IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
365 { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
366 { IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12 },
367 { IDS_SHV_COLUMN5, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 5 }
368 };
369 #define GENERICSHELLVIEWCOLUMNS 5
370
371 /**************************************************************************
372 * IShellFolder_Constructor
373 *
374 * NOTES
375 * creating undocumented ShellFS_Folder as part of an aggregation
376 * {F3364BA0-65B9-11CE-A9BA-00AA004AE837}
377 *
378 * FIXME
379 * when pUnkOuter = 0 then rrid = IID_IShellFolder is returned
380 */
381 HRESULT IFSFolder_Constructor(
382 IUnknown * pUnkOuter,
383 REFIID riid,
384 LPVOID * ppv)
385 {
386 IGenericSFImpl * sf;
387 HRESULT hr = S_OK;
388
389 TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));
390
391 if(pUnkOuter && ! IsEqualIID(riid, &IID_IUnknown))
392 {
393 hr = CLASS_E_NOAGGREGATION; /* forbidden by definition */
394 }
395 else
396 {
397 sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
398 if (sf)
399 {
400 sf->ref=1;
401 ICOM_VTBL(sf)=&unkvt;
402 sf->lpvtblShellFolder=&sfvt;
403 sf->lpvtblPersistFolder2=&psfvt;
404 sf->lpvtblDropTarget=&dtvt;
405 sf->lpvtblSFHelper=&shvt;
406
407 sf->pclsid = (CLSID*)&CLSID_SFFile;
408 sf->pUnkOuter = pUnkOuter ? pUnkOuter : _IUnknown_(sf);
409 *ppv = _IUnknown_(sf);
410 hr = S_OK;
411 shell32_ObjCount++;
412 }
413 else
414 {
415 hr = E_OUTOFMEMORY;
416 }
417 }
418 return hr;
419 }
420 /**************************************************************************
421 * IShellFolder_Constructor
422 *
423 * NOTES
424 * THIS points to the parent folder
425 */
426
427 IShellFolder * IShellFolder_Constructor(
428 IShellFolder2 * iface,
429 LPITEMIDLIST pidl)
430 {
431 IGenericSFImpl * sf;
432 DWORD dwSize=0;
433
434 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
435
436 sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
437 sf->ref=1;
438
439 ICOM_VTBL(sf)=&unkvt;
440 sf->lpvtblShellFolder=&sfvt;
441 sf->lpvtblPersistFolder2=&psfvt;
442 sf->lpvtblDropTarget=&dtvt;
443 sf->lpvtblSFHelper=&shvt;
444
445 sf->pclsid = (CLSID*)&CLSID_SFFile;
446 sf->pUnkOuter = _IUnknown_(sf);
447
448 TRACE("(%p)->(parent=%p, pidl=%p)\n",sf,This, pidl);
449 pdump(pidl);
450
451 if(pidl && iface) /* do we have a pidl? */
452 {
453 int len;
454
455 sf->absPidl = ILCombine(This->absPidl, pidl); /* build a absolute pidl */
456
457 if (!_ILIsSpecialFolder(pidl)) /* only file system paths */
458 {
459 if(This->sMyPath) /* get the size of the parents path */
460 {
461 dwSize += strlen(This->sMyPath) ;
462 TRACE("-- (%p)->(parent's path=%s)\n",sf, debugstr_a(This->sMyPath));
463 }
464
465 dwSize += _ILSimpleGetText(pidl,NULL,0); /* add the size of our name*/
466 sf->sMyPath = SHAlloc(dwSize + 2); /* '\0' and backslash */
467
468 if(!sf->sMyPath) return NULL;
469 *(sf->sMyPath)=0x00;
470
471 if(This->sMyPath) /* if the parent has a path, get it*/
472 {
473 strcpy(sf->sMyPath, This->sMyPath);
474 PathAddBackslashA (sf->sMyPath);
475 }
476
477 len = strlen(sf->sMyPath);
478 _ILSimpleGetText(pidl, sf->sMyPath + len, dwSize+2 - len);
479 }
480
481 TRACE("-- (%p)->(my pidl=%p, my path=%s)\n",sf, sf->absPidl,debugstr_a(sf->sMyPath));
482
483 pdump (sf->absPidl);
484 }
485
486 shell32_ObjCount++;
487 return _IShellFolder_(sf);
488 }
489
490 /**************************************************************************
491 * IShellFolder_fnQueryInterface
492 *
493 * PARAMETERS
494 * REFIID riid [in ] Requested InterfaceID
495 * LPVOID* ppvObject [out] Interface* to hold the result
496 */
497 static HRESULT WINAPI IShellFolder_fnQueryInterface(
498 IShellFolder2 * iface,
499 REFIID riid,
500 LPVOID *ppvObj)
501 {
502 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
503
504 _CALL_TRACE
505 TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
506
507 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
508 }
509
510 /**************************************************************************
511 * IShellFolder_AddRef
512 */
513
514 static ULONG WINAPI IShellFolder_fnAddRef(IShellFolder2 * iface)
515 {
516 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
517
518 _CALL_TRACE
519 TRACE("(%p)->(count=%lu)\n",This,This->ref);
520
521 return IUnknown_AddRef(This->pUnkOuter);
522 }
523
524 /**************************************************************************
525 * IShellFolder_fnRelease
526 */
527 static ULONG WINAPI IShellFolder_fnRelease(IShellFolder2 * iface)
528 {
529 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
530
531 _CALL_TRACE
532 TRACE("(%p)->(count=%lu)\n",This,This->ref);
533
534 return IUnknown_Release(This->pUnkOuter);
535 }
536
537 /**************************************************************************
538 * IShellFolder_fnParseDisplayName
539 * PARAMETERS
540 * HWND hwndOwner, //[in ] Parent window for any message's
541 * LPBC pbc, //[in ] reserved
542 * LPOLESTR lpszDisplayName,//[in ] "Unicode" displayname.
543 * ULONG* pchEaten, //[out] (unicode) characters processed
544 * LPITEMIDLIST* ppidl, //[out] complex pidl to item
545 * ULONG* pdwAttributes //[out] items attributes
546 *
547 * NOTES
548 * every folder trys to parse only it's own (the leftmost) pidl and creates a
549 * subfolder to evaluate the remaining parts
550 * now we can parse into namespaces implemented by shell extensions
551 *
552 * behaviour on win98: lpszDisplayName=NULL -> chrash
553 * lpszDisplayName="" -> returns mycoputer-pidl
554 *
555 * FIXME:
556 * pdwAttributes: not set
557 * pchEaten: not set like in windows
558 */
559 static HRESULT WINAPI IShellFolder_fnParseDisplayName(
560 IShellFolder2 * iface,
561 HWND hwndOwner,
562 LPBC pbcReserved,
563 LPOLESTR lpszDisplayName,
564 DWORD *pchEaten,
565 LPITEMIDLIST *ppidl,
566 DWORD *pdwAttributes)
567 {
568 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
569
570 HRESULT hr = E_OUTOFMEMORY;
571 LPCWSTR szNext=NULL;
572 WCHAR szElement[MAX_PATH];
573 CHAR szTempA[MAX_PATH], szPath[MAX_PATH];
574 LPITEMIDLIST pidlTemp=NULL;
575
576 TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
577 This,hwndOwner,pbcReserved,lpszDisplayName,
578 debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
579
580 if (!lpszDisplayName || !ppidl) return E_INVALIDARG;
581
582 if (pchEaten) *pchEaten = 0; /* strange but like the original */
583
584 if (*lpszDisplayName)
585 {
586 /* get the next element */
587 szNext = GetNextElementW(lpszDisplayName, szElement, MAX_PATH);
588
589 /* build the full pathname to the element */
590 lstrcpynWtoA(szTempA, szElement, lstrlenW(szElement) + 1);
591 strcpy(szPath, This->sMyPath);
592 PathAddBackslashA(szPath);
593 strcat(szPath, szTempA);
594
595 /* get the pidl */
596 pidlTemp = SHSimpleIDListFromPathA(szPath);
597
598 if (pidlTemp)
599 {
600 /* try to analyse the next element */
601 if (szNext && *szNext)
602 {
603 hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
604 }
605 else
606 {
607 hr = S_OK;
608 }
609 }
610 }
611
612 *ppidl = pidlTemp;
613
614 TRACE("(%p)->(-- pidl=%p ret=0x%08lx)\n", This, ppidl? *ppidl:0, hr);
615
616 return hr;
617 }
618
619 /**************************************************************************
620 * IShellFolder_fnEnumObjects
621 * PARAMETERS
622 * HWND hwndOwner, //[in ] Parent Window
623 * DWORD grfFlags, //[in ] SHCONTF enumeration mask
624 * LPENUMIDLIST* ppenumIDList //[out] IEnumIDList interface
625 */
626 static HRESULT WINAPI IShellFolder_fnEnumObjects(
627 IShellFolder2 * iface,
628 HWND hwndOwner,
629 DWORD dwFlags,
630 LPENUMIDLIST* ppEnumIDList)
631 {
632 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
633
634 TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
635
636 *ppEnumIDList = NULL;
637 *ppEnumIDList = IEnumIDList_Constructor (This->sMyPath, dwFlags, EIDL_FILE);
638
639 TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
640
641 if(!*ppEnumIDList) return E_OUTOFMEMORY;
642
643 return S_OK;
644 }
645
646 /**************************************************************************
647 * IShellFolder_fnBindToObject
648 * PARAMETERS
649 * LPCITEMIDLIST pidl, //[in ] relative pidl to open
650 * LPBC pbc, //[in ] reserved
651 * REFIID riid, //[in ] Initial Interface
652 * LPVOID* ppvObject //[out] Interface*
653 */
654 static HRESULT WINAPI IShellFolder_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
655 LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
656 {
657 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
658 GUID const * iid;
659 IShellFolder *pShellFolder, *pSubFolder;
660 IPersistFolder *pPersistFolder;
661 LPITEMIDLIST absPidl;
662
663 TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
664
665 if(!pidl || !ppvOut) return E_INVALIDARG;
666
667 *ppvOut = NULL;
668
669 if ((iid=_ILGetGUIDPointer(pidl)))
670 {
671 /* we have to create a alien folder */
672 if ( SUCCEEDED(SHCoCreateInstance(NULL, iid, NULL, riid, (LPVOID*)&pShellFolder))
673 && SUCCEEDED(IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder, (LPVOID*)&pPersistFolder)))
674 {
675 absPidl = ILCombine (This->absPidl, pidl);
676 IPersistFolder_Initialize(pPersistFolder, absPidl);
677 IPersistFolder_Release(pPersistFolder);
678 SHFree(absPidl);
679 }
680 else
681 {
682 return E_FAIL;
683 }
684 }
685 else
686 {
687 LPITEMIDLIST pidltemp = ILCloneFirst(pidl);
688 pShellFolder = IShellFolder_Constructor(iface, pidltemp);
689 ILFree(pidltemp);
690 }
691
692 if (_ILIsPidlSimple(pidl))
693 {
694 *ppvOut = pShellFolder;
695 }
696 else
697 {
698 IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, &IID_IShellFolder, (LPVOID)&pSubFolder);
699 IShellFolder_Release(pShellFolder);
700 *ppvOut = pSubFolder;
701 }
702
703 TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
704
705 return S_OK;
706 }
707
708 /**************************************************************************
709 * IShellFolder_fnBindToStorage
710 * PARAMETERS
711 * LPCITEMIDLIST pidl, //[in ] complex pidl to store
712 * LPBC pbc, //[in ] reserved
713 * REFIID riid, //[in ] Initial storage interface
714 * LPVOID* ppvObject //[out] Interface* returned
715 */
716 static HRESULT WINAPI IShellFolder_fnBindToStorage(
717 IShellFolder2 * iface,
718 LPCITEMIDLIST pidl,
719 LPBC pbcReserved,
720 REFIID riid,
721 LPVOID *ppvOut)
722 {
723 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
724
725 FIXME("(%p)->(pidl=%p,%p,\n\tIID:%s,%p) stub\n",
726 This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
727
728 *ppvOut = NULL;
729 return E_NOTIMPL;
730 }
731
732 /**************************************************************************
733 * IShellFolder_fnCompareIDs
734 *
735 * PARMETERS
736 * LPARAM lParam, //[in ] Column?
737 * LPCITEMIDLIST pidl1, //[in ] simple pidl
738 * LPCITEMIDLIST pidl2) //[in ] simple pidl
739 *
740 * NOTES
741 * Special case - If one of the items is a Path and the other is a File,
742 * always make the Path come before the File.
743 *
744 * NOTES
745 * use SCODE_CODE() on the return value to get the result
746 */
747
748 static HRESULT WINAPI IShellFolder_fnCompareIDs(
749 IShellFolder2 * iface,
750 LPARAM lParam,
751 LPCITEMIDLIST pidl1,
752 LPCITEMIDLIST pidl2)
753 {
754 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
755
756 CHAR szTemp1[MAX_PATH];
757 CHAR szTemp2[MAX_PATH];
758 int nReturn;
759 IShellFolder * psf;
760 HRESULT hr = E_OUTOFMEMORY;
761 LPCITEMIDLIST pidlTemp;
762 PIDLTYPE pt1, pt2;
763
764 TRACE("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n",This,lParam,pidl1,pidl2);
765 pdump (pidl1);
766 pdump (pidl2);
767
768 if (!pidl1 && !pidl2)
769 {
770 hr = ResultFromShort(0);
771 }
772 else if (!pidl1)
773 {
774 hr = ResultFromShort(-1);
775 }
776 else if (!pidl2)
777 {
778 hr = ResultFromShort(1);
779 }
780 else
781 {
782 LPPIDLDATA pd1, pd2;
783 pd1 = _ILGetDataPointer(pidl1);
784 pd2 = _ILGetDataPointer(pidl2);
785
786 /* compate the types. sort order is the PT_* constant */
787 pt1 = ( pd1 ? pd1->type: PT_DESKTOP);
788 pt2 = ( pd2 ? pd2->type: PT_DESKTOP);
789
790 if (pt1 != pt2)
791 {
792 hr = ResultFromShort(pt1-pt2);
793 }
794 else /* same type of pidl */
795 {
796 _ILSimpleGetText(pidl1, szTemp1, MAX_PATH);
797 _ILSimpleGetText(pidl2, szTemp2, MAX_PATH);
798 nReturn = strcasecmp(szTemp1, szTemp2);
799
800 if (nReturn == 0) /* first pidl different ? */
801 {
802 pidl1 = ILGetNext(pidl1);
803
804 if (pidl1 && pidl1->mkid.cb) /* go deeper? */
805 {
806 pidlTemp = ILCloneFirst(pidl1);
807 pidl2 = ILGetNext(pidl2);
808
809 hr = IShellFolder_BindToObject(iface, pidlTemp, NULL, &IID_IShellFolder, (LPVOID*)&psf);
810 if (SUCCEEDED(hr))
811 {
812 nReturn = IShellFolder_CompareIDs(psf, 0, pidl1, pidl2);
813 IShellFolder_Release(psf);
814 hr = ResultFromShort(nReturn);
815 }
816 ILFree(pidlTemp);
817 }
818 else
819 {
820 hr = ResultFromShort(nReturn); /* two equal simple pidls */
821 }
822 }
823 else
824 {
825 hr = ResultFromShort(nReturn); /* two different simple pidls */
826 }
827 }
828 }
829
830 TRACE("-- res=0x%08lx\n", hr);
831 return hr;
832 }
833
834 /**************************************************************************
835 * IShellFolder_fnCreateViewObject
836 */
837 static HRESULT WINAPI IShellFolder_fnCreateViewObject(
838 IShellFolder2 * iface,
839 HWND hwndOwner,
840 REFIID riid,
841 LPVOID *ppvOut)
842 {
843 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
844
845 LPSHELLVIEW pShellView;
846 HRESULT hr = E_INVALIDARG;
847
848 TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
849
850 if(ppvOut)
851 {
852 *ppvOut = NULL;
853
854 if(IsEqualIID(riid, &IID_IDropTarget))
855 {
856 hr = IShellFolder_QueryInterface(iface, &IID_IDropTarget, ppvOut);
857 }
858 else if(IsEqualIID(riid, &IID_IContextMenu))
859 {
860 FIXME("IContextMenu not implemented\n");
861 hr = E_NOTIMPL;
862 }
863 else if(IsEqualIID(riid, &IID_IShellView))
864 {
865 pShellView = IShellView_Constructor((IShellFolder*)iface);
866 if(pShellView)
867 {
868 hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
869 IShellView_Release(pShellView);
870 }
871 }
872 }
873 TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
874 return hr;
875 }
876
877 /**************************************************************************
878 * IShellFolder_fnGetAttributesOf
879 *
880 * PARAMETERS
881 * UINT cidl, //[in ] num elements in pidl array
882 * LPCITEMIDLIST* apidl, //[in ] simple pidl array
883 * ULONG* rgfInOut) //[out] result array
884 *
885 */
886 static HRESULT WINAPI IShellFolder_fnGetAttributesOf(
887 IShellFolder2 * iface,
888 UINT cidl,
889 LPCITEMIDLIST *apidl,
890 DWORD *rgfInOut)
891 {
892 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
893
894 HRESULT hr = S_OK;
895
896 TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl,*rgfInOut);
897
898 if ( (!cidl) || (!apidl) || (!rgfInOut))
899 return E_INVALIDARG;
900
901 while (cidl > 0 && *apidl)
902 {
903 pdump (*apidl);
904 if (_ILIsFolder( *apidl))
905 {
906 *rgfInOut &= 0xe0000177;
907 goto next;
908 }
909 else if (_ILIsValue( *apidl))
910 {
911 *rgfInOut &= 0x40000177;
912 goto next;
913 }
914 hr = E_INVALIDARG;
915
916 next: apidl++;
917 cidl--;
918 }
919
920 TRACE("-- result=0x%08lx\n",*rgfInOut);
921
922 return hr;
923 }
924 /**************************************************************************
925 * IShellFolder_fnGetUIObjectOf
926 *
927 * PARAMETERS
928 * HWND hwndOwner, //[in ] Parent window for any output
929 * UINT cidl, //[in ] array size
930 * LPCITEMIDLIST* apidl, //[in ] simple pidl array
931 * REFIID riid, //[in ] Requested Interface
932 * UINT* prgfInOut, //[ ] reserved
933 * LPVOID* ppvObject) //[out] Resulting Interface
934 *
935 * NOTES
936 * This function gets asked to return "view objects" for one or more (multiple select)
937 * items:
938 * The viewobject typically is an COM object with one of the following interfaces:
939 * IExtractIcon,IDataObject,IContextMenu
940 * In order to support icon positions in the default Listview your DataObject
941 * must implement the SetData method (in addition to GetData :) - the shell passes
942 * a barely documented "Icon positions" structure to SetData when the drag starts,
943 * and GetData's it if the drop is in another explorer window that needs the positions.
944 */
945 static HRESULT WINAPI IShellFolder_fnGetUIObjectOf(
946 IShellFolder2 * iface,
947 HWND hwndOwner,
948 UINT cidl,
949 LPCITEMIDLIST * apidl,
950 REFIID riid,
951 UINT * prgfInOut,
952 LPVOID * ppvOut)
953 {
954 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
955
956 LPITEMIDLIST pidl;
957 IUnknown* pObj = NULL;
958 HRESULT hr = E_INVALIDARG;
959
960 TRACE("(%p)->(0x%04x,%u,apidl=%p,\n\tIID:%s,%p,%p)\n",
961 This,hwndOwner,cidl,apidl,debugstr_guid(riid),prgfInOut,ppvOut);
962
963 if (ppvOut)
964 {
965 *ppvOut = NULL;
966
967 if(IsEqualIID(riid, &IID_IContextMenu) && (cidl >= 1))
968 {
969 pObj = (LPUNKNOWN)ISvItemCm_Constructor((IShellFolder*)iface, This->absPidl, apidl, cidl);
970 hr = S_OK;
971 }
972 else if (IsEqualIID(riid, &IID_IDataObject) &&(cidl >= 1))
973 {
974 pObj = (LPUNKNOWN)IDataObject_Constructor (hwndOwner, This->absPidl, apidl, cidl);
975 hr = S_OK;
976 }
977 else if (IsEqualIID(riid, &IID_IExtractIconA) && (cidl == 1))
978 {
979 pidl = ILCombine(This->absPidl,apidl[0]);
980 pObj = (LPUNKNOWN)IExtractIconA_Constructor( pidl );
981 SHFree(pidl);
982 hr = S_OK;
983 }
984 else if (IsEqualIID(riid, &IID_IDropTarget) && (cidl >= 1))
985 {
986 hr = IShellFolder_QueryInterface(iface, &IID_IDropTarget, (LPVOID*)&pObj);
987 }
988 else
989 {
990 hr = E_NOINTERFACE;
991 }
992
993 if(!pObj)
994 hr = E_OUTOFMEMORY;
995
996 *ppvOut = pObj;
997 }
998 TRACE("(%p)->hr=0x%08lx\n",This, hr);
999 return hr;
1000 }
1001
1002 /**************************************************************************
1003 * IShellFolder_fnGetDisplayNameOf
1004 * Retrieves the display name for the specified file object or subfolder
1005 *
1006 * PARAMETERS
1007 * LPCITEMIDLIST pidl, //[in ] complex pidl to item
1008 * DWORD dwFlags, //[in ] SHGNO formatting flags
1009 * LPSTRRET lpName) //[out] Returned display name
1010 *
1011 * FIXME
1012 * if the name is in the pidl the ret value should be a STRRET_OFFSET
1013 */
1014 #define GET_SHGDN_FOR(dwFlags) ((DWORD)dwFlags & (DWORD)0x0000FF00)
1015 #define GET_SHGDN_RELATION(dwFlags) ((DWORD)dwFlags & (DWORD)0x000000FF)
1016
1017 static HRESULT WINAPI IShellFolder_fnGetDisplayNameOf(
1018 IShellFolder2 * iface,
1019 LPCITEMIDLIST pidl,
1020 DWORD dwFlags,
1021 LPSTRRET strRet)
1022 {
1023 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1024
1025 CHAR szPath[MAX_PATH]= "";
1026 int len = 0;
1027 BOOL bSimplePidl;
1028
1029 TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
1030 pdump(pidl);
1031
1032 if(!pidl || !strRet) return E_INVALIDARG;
1033
1034 bSimplePidl = _ILIsPidlSimple(pidl);
1035
1036 /* take names of special folders only if its only this folder */
1037 if (_ILIsSpecialFolder(pidl))
1038 {
1039 if ( bSimplePidl)
1040 {
1041 _ILSimpleGetText(pidl, szPath, MAX_PATH); /* append my own path */
1042 }
1043 }
1044 else
1045 {
1046 if (!(dwFlags & SHGDN_INFOLDER) && (dwFlags & SHGDN_FORPARSING) && This->sMyPath)
1047 {
1048 strcpy (szPath, This->sMyPath); /* get path to root*/
1049 PathAddBackslashA(szPath);
1050 len = strlen(szPath);
1051 }
1052 _ILSimpleGetText(pidl, szPath + len, MAX_PATH - len); /* append my own path */
1053 }
1054
1055 if ( (dwFlags & SHGDN_FORPARSING) && !bSimplePidl) /* go deeper if needed */
1056 {
1057 PathAddBackslashA(szPath);
1058 len = strlen(szPath);
1059
1060 if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, szPath + len, MAX_PATH - len)))
1061 return E_OUTOFMEMORY;
1062 }
1063 strRet->uType = STRRET_CSTRA;
1064 lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
1065
1066 TRACE("-- (%p)->(%s)\n", This, szPath);
1067 return S_OK;
1068 }
1069
1070 /**************************************************************************
1071 * IShellFolder_fnSetNameOf
1072 * Changes the name of a file object or subfolder, possibly changing its item
1073 * identifier in the process.
1074 *
1075 * PARAMETERS
1076 * HWND hwndOwner, //[in ] Owner window for output
1077 * LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
1078 * LPCOLESTR lpszName, //[in ] the items new display name
1079 * DWORD dwFlags, //[in ] SHGNO formatting flags
1080 * LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
1081 */
1082 static HRESULT WINAPI IShellFolder_fnSetNameOf(
1083 IShellFolder2 * iface,
1084 HWND hwndOwner,
1085 LPCITEMIDLIST pidl, /*simple pidl*/
1086 LPCOLESTR lpName,
1087 DWORD dwFlags,
1088 LPITEMIDLIST *pPidlOut)
1089 {
1090 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1091 char szSrc[MAX_PATH], szDest[MAX_PATH];
1092 int len;
1093 BOOL bIsFolder = _ILIsFolder(ILFindLastID(pidl));
1094
1095 TRACE("(%p)->(%u,pidl=%p,%s,%lu,%p)\n",
1096 This,hwndOwner,pidl,debugstr_w(lpName),dwFlags,pPidlOut);
1097
1098 /* build source path */
1099 if (dwFlags & SHGDN_INFOLDER)
1100 {
1101 strcpy(szSrc, This->sMyPath);
1102 PathAddBackslashA(szSrc);
1103 len = strlen (szSrc);
1104 _ILSimpleGetText(pidl, szSrc+len, MAX_PATH-len);
1105 }
1106 else
1107 {
1108 SHGetPathFromIDListA(pidl, szSrc);
1109 }
1110
1111 /* build destination path */
1112 strcpy(szDest, This->sMyPath);
1113 PathAddBackslashA(szDest);
1114 len = strlen (szDest);
1115 lstrcpynWtoA(szDest+len, lpName, MAX_PATH-len);
1116
1117 TRACE("src=%s dest=%s\n", szSrc, szDest);
1118 if ( MoveFileA(szSrc, szDest) )
1119 {
1120 if (pPidlOut) *pPidlOut = SHSimpleIDListFromPathA(szDest);
1121 SHChangeNotifyA( bIsFolder?SHCNE_RENAMEFOLDER:SHCNE_RENAMEITEM, SHCNF_PATHA, szSrc, szDest);
1122 return S_OK;
1123 }
1124 return E_FAIL;
1125 }
1126
1127 static HRESULT WINAPI IShellFolder_fnGetDefaultSearchGUID(
1128 IShellFolder2 * iface,
1129 GUID *pguid)
1130 {
1131 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1132 FIXME("(%p)\n",This);
1133 return E_NOTIMPL;
1134 }
1135 static HRESULT WINAPI IShellFolder_fnEnumSearches(
1136 IShellFolder2 * iface,
1137 IEnumExtraSearch **ppenum)
1138 {
1139 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1140 FIXME("(%p)\n",This);
1141 return E_NOTIMPL;
1142 }
1143 static HRESULT WINAPI IShellFolder_fnGetDefaultColumn(
1144 IShellFolder2 * iface,
1145 DWORD dwRes,
1146 ULONG *pSort,
1147 ULONG *pDisplay)
1148 {
1149 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1150
1151 TRACE("(%p)\n",This);
1152
1153 if (pSort) *pSort = 0;
1154 if (pDisplay) *pDisplay = 0;
1155
1156 return S_OK;
1157 }
1158 static HRESULT WINAPI IShellFolder_fnGetDefaultColumnState(
1159 IShellFolder2 * iface,
1160 UINT iColumn,
1161 DWORD *pcsFlags)
1162 {
1163 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1164
1165 TRACE("(%p)\n",This);
1166
1167 if (!pcsFlags || iColumn >= GENERICSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1168
1169 *pcsFlags = GenericSFHeader[iColumn].pcsFlags;
1170
1171 return S_OK;
1172 }
1173 static HRESULT WINAPI IShellFolder_fnGetDetailsEx(
1174 IShellFolder2 * iface,
1175 LPCITEMIDLIST pidl,
1176 const SHCOLUMNID *pscid,
1177 VARIANT *pv)
1178 {
1179 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1180 FIXME("(%p)\n",This);
1181
1182 return E_NOTIMPL;
1183 }
1184 static HRESULT WINAPI IShellFolder_fnGetDetailsOf(
1185 IShellFolder2 * iface,
1186 LPCITEMIDLIST pidl,
1187 UINT iColumn,
1188 SHELLDETAILS *psd)
1189 {
1190 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1191 HRESULT hr = E_FAIL;
1192
1193 TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
1194
1195 if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1196
1197 if (!pidl)
1198 {
1199 /* the header titles */
1200 psd->fmt = GenericSFHeader[iColumn].fmt;
1201 psd->cxChar = GenericSFHeader[iColumn].cxChar;
1202 psd->str.uType = STRRET_CSTRA;
1203 LoadStringA(shell32_hInstance, GenericSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
1204 return S_OK;
1205 }
1206 else
1207 {
1208 /* the data from the pidl */
1209 switch(iColumn)
1210 {
1211 case 0: /* name */
1212 hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
1213 break;
1214 case 1: /* size */
1215 _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
1216 break;
1217 case 2: /* type */
1218 _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
1219 break;
1220 case 3: /* date */
1221 _ILGetFileDate(pidl, psd->str.u.cStr, MAX_PATH);
1222 break;
1223 case 4: /* attributes */
1224 _ILGetFileAttributes(pidl, psd->str.u.cStr, MAX_PATH);
1225 break;
1226 }
1227 hr = S_OK;
1228 psd->str.uType = STRRET_CSTRA;
1229 }
1230
1231 return hr;
1232 }
1233 static HRESULT WINAPI IShellFolder_fnMapNameToSCID(
1234 IShellFolder2 * iface,
1235 LPCWSTR pwszName,
1236 SHCOLUMNID *pscid)
1237 {
1238 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1239 FIXME("(%p)\n",This);
1240 return E_NOTIMPL;
1241 }
1242
1243 static ICOM_VTABLE(IShellFolder2) sfvt =
1244 {
1245 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1246 IShellFolder_fnQueryInterface,
1247 IShellFolder_fnAddRef,
1248 IShellFolder_fnRelease,
1249 IShellFolder_fnParseDisplayName,
1250 IShellFolder_fnEnumObjects,
1251 IShellFolder_fnBindToObject,
1252 IShellFolder_fnBindToStorage,
1253 IShellFolder_fnCompareIDs,
1254 IShellFolder_fnCreateViewObject,
1255 IShellFolder_fnGetAttributesOf,
1256 IShellFolder_fnGetUIObjectOf,
1257 IShellFolder_fnGetDisplayNameOf,
1258 IShellFolder_fnSetNameOf,
1259
1260 /* ShellFolder2 */
1261 IShellFolder_fnGetDefaultSearchGUID,
1262 IShellFolder_fnEnumSearches,
1263 IShellFolder_fnGetDefaultColumn,
1264 IShellFolder_fnGetDefaultColumnState,
1265 IShellFolder_fnGetDetailsEx,
1266 IShellFolder_fnGetDetailsOf,
1267 IShellFolder_fnMapNameToSCID
1268 };
1269
1270 /****************************************************************************
1271 * ISFHelper for IShellFolder implementation
1272 */
1273
1274 static HRESULT WINAPI ISFHelper_fnQueryInterface(
1275 ISFHelper *iface,
1276 REFIID riid,
1277 LPVOID *ppvObj)
1278 {
1279 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1280
1281 TRACE("(%p)\n", This);
1282
1283 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
1284 }
1285
1286 static ULONG WINAPI ISFHelper_fnAddRef(
1287 ISFHelper *iface)
1288 {
1289 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1290
1291 TRACE("(%p)\n", This);
1292
1293 return IUnknown_AddRef(This->pUnkOuter);
1294 }
1295
1296 static ULONG WINAPI ISFHelper_fnRelease(
1297 ISFHelper *iface)
1298 {
1299 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1300
1301 TRACE("(%p)\n", This);
1302
1303 return IUnknown_Release(This->pUnkOuter);
1304 }
1305
1306
1307 /****************************************************************************
1308 * ISFHelper_fnAddFolder
1309 *
1310 * creates a unique folder name
1311 */
1312
1313 static HRESULT WINAPI ISFHelper_fnGetUniqueName(
1314 ISFHelper *iface,
1315 LPSTR lpName,
1316 UINT uLen)
1317 {
1318 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1319 IEnumIDList * penum;
1320 HRESULT hr;
1321 char szText[MAX_PATH];
1322 char * szNewFolder = "New Folder";
1323
1324 TRACE("(%p)(%s %u)\n", This, lpName, uLen);
1325
1326 if (uLen < strlen(szNewFolder) + 4) return E_POINTER;
1327
1328 strcpy(lpName, szNewFolder);
1329
1330 hr = IShellFolder_fnEnumObjects(_IShellFolder2_(This), 0, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penum);
1331 if (penum)
1332 {
1333 LPITEMIDLIST pidl;
1334 DWORD dwFetched;
1335 int i=1;
1336
1337 next: IEnumIDList_Reset(penum);
1338 while(S_OK == IEnumIDList_Next(penum, 1, &pidl, &dwFetched) && dwFetched)
1339 {
1340 _ILSimpleGetText(pidl, szText, MAX_PATH);
1341 if (0 == strcasecmp(szText, lpName))
1342 {
1343 sprintf(lpName, "%s %d", szNewFolder, i++);
1344 if (i > 99)
1345 {
1346 hr = E_FAIL;
1347 break;
1348 }
1349 goto next;
1350 }
1351 }
1352
1353 IEnumIDList_Release(penum);
1354 }
1355 return hr;
1356 }
1357
1358 /****************************************************************************
1359 * ISFHelper_fnAddFolder
1360 *
1361 * adds a new folder.
1362 */
1363
1364 static HRESULT WINAPI ISFHelper_fnAddFolder(
1365 ISFHelper *iface,
1366 HWND hwnd,
1367 LPCSTR lpName,
1368 LPITEMIDLIST* ppidlOut)
1369 {
1370 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1371 char lpstrNewDir[MAX_PATH];
1372 DWORD bRes;
1373 HRESULT hres = E_FAIL;
1374
1375 TRACE("(%p)(%s %p)\n", This, lpName, ppidlOut);
1376
1377 strcpy(lpstrNewDir, This->sMyPath);
1378 PathAddBackslashA(lpstrNewDir);
1379 strcat(lpstrNewDir, lpName);
1380
1381 bRes = CreateDirectoryA(lpstrNewDir, NULL);
1382
1383 if (bRes)
1384 {
1385 LPITEMIDLIST pidl, pidlitem;
1386
1387 pidlitem = SHSimpleIDListFromPathA(lpstrNewDir);
1388
1389 pidl = ILCombine(This->absPidl, pidlitem);
1390 SHChangeNotifyA(SHCNE_MKDIR, SHCNF_IDLIST, pidl, NULL);
1391 SHFree(pidl);
1392
1393 if (ppidlOut) *ppidlOut = pidlitem;
1394 hres = S_OK;
1395 }
1396 else
1397 {
1398 char lpstrText[128+MAX_PATH];
1399 char lpstrTempText[128];
1400 char lpstrCaption[256];
1401
1402 /* Cannot Create folder because of permissions */
1403 LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_DENIED, lpstrTempText, sizeof(lpstrTempText));
1404 LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_CAPTION, lpstrCaption, sizeof(lpstrCaption));
1405 sprintf(lpstrText,lpstrTempText, lpstrNewDir);
1406 MessageBoxA(hwnd,lpstrText, lpstrCaption, MB_OK | MB_ICONEXCLAMATION);
1407 }
1408
1409 return hres;
1410 }
1411
1412 /****************************************************************************
1413 * ISFHelper_fnDeleteItems
1414 *
1415 * deletes items in folder
1416 */
1417 static HRESULT WINAPI ISFHelper_fnDeleteItems(
1418 ISFHelper *iface,
1419 UINT cidl,
1420 LPCITEMIDLIST* apidl)
1421 {
1422 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface)
1423 int i;
1424 char szPath[MAX_PATH];
1425
1426 TRACE("(%p)(%u %p)\n", This, cidl, apidl);
1427
1428 for(i=0; i< cidl; i++)
1429 {
1430 strcpy(szPath, This->sMyPath);
1431 PathAddBackslashA(szPath);
1432 _ILSimpleGetText(apidl[i], szPath+strlen(szPath), MAX_PATH);
1433
1434 if (_ILIsFolder(apidl[i]))
1435 {
1436 LPITEMIDLIST pidl;
1437
1438 MESSAGE("delete %s\n", szPath);
1439 if (! RemoveDirectoryA(szPath)) return E_FAIL;
1440 pidl = ILCombine(This->absPidl, apidl[i]);
1441 SHChangeNotifyA(SHCNE_RMDIR, SHCNF_IDLIST, pidl, NULL);
1442 SHFree(pidl);
1443 }
1444 else if (_ILIsValue(apidl[i]))
1445 {
1446 LPITEMIDLIST pidl;
1447
1448 MESSAGE("delete %s\n", szPath);
1449 if (! DeleteFileA(szPath)) return E_FAIL;
1450 pidl = ILCombine(This->absPidl, apidl[i]);
1451 SHChangeNotifyA(SHCNE_DELETE, SHCNF_IDLIST, pidl, NULL);
1452 SHFree(pidl);
1453 }
1454
1455 }
1456 return S_OK;
1457 }
1458
1459 /****************************************************************************
1460 * ISFHelper_fnCopyItems
1461 *
1462 * copys items to this folder
1463 */
1464 static HRESULT WINAPI ISFHelper_fnCopyItems(
1465 ISFHelper *iface,
1466 IShellFolder* pSFFrom,
1467 UINT cidl,
1468 LPCITEMIDLIST *apidl)
1469 {
1470 int i;
1471 IPersistFolder2 * ppf2=NULL;
1472 char szSrcPath[MAX_PATH], szDstPath[MAX_PATH];
1473 _ICOM_THIS_From_ISFHelper(IGenericSFImpl,iface);
1474
1475 TRACE("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
1476
1477 IShellFolder_QueryInterface(pSFFrom, &IID_IPersistFolder2, (LPVOID*)&ppf2);
1478 if (ppf2)
1479 {
1480 LPITEMIDLIST pidl;
1481 if (SUCCEEDED(IPersistFolder2_GetCurFolder(ppf2, &pidl)))
1482 {
1483 for (i=0; i<cidl; i++)
1484 {
1485 SHGetPathFromIDListA(pidl, szSrcPath);
1486 PathAddBackslashA(szSrcPath);
1487 _ILSimpleGetText(apidl[i], szSrcPath+strlen(szSrcPath), MAX_PATH);
1488
1489 strcpy(szDstPath, This->sMyPath);
1490 PathAddBackslashA(szDstPath);
1491 _ILSimpleGetText(apidl[i], szDstPath+strlen(szDstPath), MAX_PATH);
1492 MESSAGE("would copy %s to %s\n", szSrcPath, szDstPath);
1493 }
1494 SHFree(pidl);
1495 }
1496 IPersistFolder2_Release(ppf2);
1497 }
1498 return S_OK;
1499 }
1500
1501 static ICOM_VTABLE(ISFHelper) shvt =
1502 {
1503 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1504 ISFHelper_fnQueryInterface,
1505 ISFHelper_fnAddRef,
1506 ISFHelper_fnRelease,
1507 ISFHelper_fnGetUniqueName,
1508 ISFHelper_fnAddFolder,
1509 ISFHelper_fnDeleteItems,
1510 ISFHelper_fnCopyItems,
1511 };
1512
1513 /***********************************************************************
1514 * [Desktopfolder] IShellFolder implementation
1515 */
1516 static struct ICOM_VTABLE(IShellFolder2) sfdvt;
1517
1518 static shvheader DesktopSFHeader [] =
1519 {
1520 { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
1521 { IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
1522 { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
1523 { IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12 },
1524 { IDS_SHV_COLUMN5, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 5 }
1525 };
1526 #define DESKTOPSHELLVIEWCOLUMNS 5
1527
1528 /**************************************************************************
1529 * ISF_Desktop_Constructor
1530 *
1531 */
1532 IShellFolder * ISF_Desktop_Constructor()
1533 {
1534 IGenericSFImpl * sf;
1535
1536 sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
1537 sf->ref=1;
1538 ICOM_VTBL(sf)=&unkvt;
1539 sf->lpvtblShellFolder=&sfdvt;
1540 sf->absPidl=_ILCreateDesktop(); /* my qualified pidl */
1541 sf->pUnkOuter = (IUnknown *) &sf->lpVtbl;
1542
1543 TRACE("(%p)\n",sf);
1544
1545 shell32_ObjCount++;
1546 return _IShellFolder_(sf);
1547 }
1548
1549 /**************************************************************************
1550 * ISF_Desktop_fnQueryInterface
1551 *
1552 * NOTES supports not IPersist/IPersistFolder
1553 */
1554 static HRESULT WINAPI ISF_Desktop_fnQueryInterface(
1555 IShellFolder2 * iface,
1556 REFIID riid,
1557 LPVOID *ppvObj)
1558 {
1559 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1560
1561 TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
1562
1563 *ppvObj = NULL;
1564
1565 if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
1566 {
1567 *ppvObj = _IUnknown_(This);
1568 }
1569 else if(IsEqualIID(riid, &IID_IShellFolder)) /*IShellFolder*/
1570 {
1571 *ppvObj = _IShellFolder_(This);
1572 }
1573 else if(IsEqualIID(riid, &IID_IShellFolder2)) /*IShellFolder2*/
1574 {
1575 *ppvObj = _IShellFolder_(This);
1576 }
1577
1578 if(*ppvObj)
1579 {
1580 IUnknown_AddRef((IUnknown*)(*ppvObj));
1581 TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
1582 return S_OK;
1583 }
1584 TRACE("-- Interface: E_NOINTERFACE\n");
1585 return E_NOINTERFACE;
1586 }
1587
1588 /**************************************************************************
1589 * ISF_Desktop_fnParseDisplayName
1590 *
1591 * NOTES
1592 * "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" and "" binds
1593 * to MyComputer
1594 */
1595 static HRESULT WINAPI ISF_Desktop_fnParseDisplayName(
1596 IShellFolder2 * iface,
1597 HWND hwndOwner,
1598 LPBC pbcReserved,
1599 LPOLESTR lpszDisplayName,
1600 DWORD *pchEaten,
1601 LPITEMIDLIST *ppidl,
1602 DWORD *pdwAttributes)
1603 {
1604 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1605
1606 LPCWSTR szNext=NULL;
1607 LPITEMIDLIST pidlTemp=NULL;
1608 HRESULT hr=E_OUTOFMEMORY;
1609
1610 TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
1611 This,hwndOwner,pbcReserved,lpszDisplayName,
1612 debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
1613
1614 *ppidl = 0;
1615 if (pchEaten) *pchEaten = 0; /* strange but like the original */
1616
1617 /* fixme no real parsing implemented */
1618 pidlTemp = _ILCreateMyComputer();
1619 szNext = lpszDisplayName;
1620
1621 if (szNext && *szNext)
1622 {
1623 hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
1624 }
1625 else
1626 {
1627 hr = S_OK;
1628 }
1629
1630 *ppidl = pidlTemp;
1631
1632 TRACE("(%p)->(-- ret=0x%08lx)\n", This, hr);
1633
1634 return hr;
1635 }
1636
1637 /**************************************************************************
1638 * ISF_Desktop_fnEnumObjects
1639 */
1640 static HRESULT WINAPI ISF_Desktop_fnEnumObjects(
1641 IShellFolder2 * iface,
1642 HWND hwndOwner,
1643 DWORD dwFlags,
1644 LPENUMIDLIST* ppEnumIDList)
1645 {
1646 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1647
1648 TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
1649
1650 *ppEnumIDList = NULL;
1651 *ppEnumIDList = IEnumIDList_Constructor (NULL, dwFlags, EIDL_DESK);
1652
1653 TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
1654
1655 if(!*ppEnumIDList) return E_OUTOFMEMORY;
1656
1657 return S_OK;
1658 }
1659
1660 /**************************************************************************
1661 * ISF_Desktop_fnBindToObject
1662 */
1663 static HRESULT WINAPI ISF_Desktop_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
1664 LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
1665 {
1666 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1667 GUID const * clsid;
1668 IShellFolder *pShellFolder, *pSubFolder;
1669
1670 TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",
1671 This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
1672
1673 *ppvOut = NULL;
1674
1675 if ((clsid=_ILGetGUIDPointer(pidl)))
1676 {
1677 if ( IsEqualIID(clsid, &CLSID_MyComputer))
1678 {
1679 pShellFolder = ISF_MyComputer_Constructor();
1680 }
1681 else
1682 {
1683 /* shell extension */
1684 if (!SUCCEEDED(SHELL32_CoCreateInitSF (This->absPidl, pidl, clsid, riid, (LPVOID*)&pShellFolder)))
1685 {
1686 return E_INVALIDARG;
1687 }
1688 }
1689 }
1690 else
1691 {
1692 /* file system folder on the desktop */
1693 LPITEMIDLIST deskpidl, firstpidl, completepidl;
1694 IPersistFolder * ppf;
1695
1696 /* combine pidls */
1697 SHGetSpecialFolderLocation(0, CSIDL_DESKTOPDIRECTORY, &deskpidl);
1698 firstpidl = ILCloneFirst(pidl);
1699 completepidl = ILCombine(deskpidl, firstpidl);
1700
1701 pShellFolder = IShellFolder_Constructor(NULL, NULL);
1702 if (SUCCEEDED(IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder, (LPVOID*)&ppf)))
1703 {
1704 IPersistFolder_Initialize(ppf, completepidl);
1705 IPersistFolder_Release(ppf);
1706 }
1707 ILFree(completepidl);
1708 ILFree(deskpidl);
1709 ILFree(firstpidl);
1710 }
1711
1712 if (_ILIsPidlSimple(pidl)) /* no sub folders */
1713 {
1714 *ppvOut = pShellFolder;
1715 }
1716 else /* go deeper */
1717 {
1718 IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, riid, (LPVOID)&pSubFolder);
1719 IShellFolder_Release(pShellFolder);
1720 *ppvOut = pSubFolder;
1721 }
1722
1723 TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
1724
1725 return S_OK;
1726 }
1727
1728 /**************************************************************************
1729 * ISF_Desktop_fnCreateViewObject
1730 */
1731 static HRESULT WINAPI ISF_Desktop_fnCreateViewObject( IShellFolder2 * iface,
1732 HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
1733 {
1734 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1735
1736 LPSHELLVIEW pShellView;
1737 HRESULT hr = E_INVALIDARG;
1738
1739 TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
1740
1741 if(ppvOut)
1742 {
1743 *ppvOut = NULL;
1744
1745 if(IsEqualIID(riid, &IID_IDropTarget))
1746 {
1747 FIXME("IDropTarget not implemented\n");
1748 hr = E_NOTIMPL;
1749 }
1750 else if(IsEqualIID(riid, &IID_IContextMenu))
1751 {
1752 FIXME("IContextMenu not implemented\n");
1753 hr = E_NOTIMPL;
1754 }
1755 else if(IsEqualIID(riid, &IID_IShellView))
1756 {
1757 pShellView = IShellView_Constructor((IShellFolder*)iface);
1758 if(pShellView)
1759 {
1760 hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
1761 IShellView_Release(pShellView);
1762 }
1763 }
1764 }
1765 TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
1766 return hr;
1767 }
1768
1769 /**************************************************************************
1770 * ISF_Desktop_fnGetAttributesOf
1771 */
1772 static HRESULT WINAPI ISF_Desktop_fnGetAttributesOf(IShellFolder2 * iface,UINT cidl,LPCITEMIDLIST *apidl,DWORD *rgfInOut)
1773 {
1774 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1775
1776 GUID const * clsid;
1777 DWORD attributes;
1778 HRESULT hr = S_OK;
1779
1780 TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl, *rgfInOut);
1781
1782 if ( (!cidl) || (!apidl) || (!rgfInOut))
1783 return E_INVALIDARG;
1784
1785 while (cidl > 0 && *apidl)
1786 {
1787 pdump (*apidl);
1788
1789 if ((clsid=_ILGetGUIDPointer(*apidl)))
1790 {
1791 if (IsEqualIID(clsid, &CLSID_MyComputer))
1792 {
1793 *rgfInOut &= 0xb0000154;
1794 goto next;
1795 }
1796 else if (HCR_GetFolderAttributes(clsid, &attributes))
1797 {
1798 *rgfInOut &= attributes;
1799 goto next;
1800 }
1801 else
1802 { /* some shell-extension */
1803 *rgfInOut &= 0xb0000154;
1804 }
1805 }
1806 else if (_ILIsFolder( *apidl))
1807 {
1808 *rgfInOut &= 0xe0000177;
1809 goto next;
1810 }
1811 else if (_ILIsValue( *apidl))
1812 {
1813 *rgfInOut &= 0x40000177;
1814 goto next;
1815 }
1816 hr = E_INVALIDARG;
1817
1818 next: apidl++;
1819 cidl--;
1820 }
1821
1822 TRACE("-- result=0x%08lx\n",*rgfInOut);
1823
1824 return hr;
1825 }
1826
1827 /**************************************************************************
1828 * ISF_Desktop_fnGetDisplayNameOf
1829 *
1830 * NOTES
1831 * special case: pidl = null gives desktop-name back
1832 */
1833 static HRESULT WINAPI ISF_Desktop_fnGetDisplayNameOf(
1834 IShellFolder2 * iface,
1835 LPCITEMIDLIST pidl,
1836 DWORD dwFlags,
1837 LPSTRRET strRet)
1838 {
1839 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1840
1841 CHAR szPath[MAX_PATH]= "";
1842
1843 TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
1844 pdump(pidl);
1845
1846 if(!strRet) return E_INVALIDARG;
1847
1848 if(!pidl)
1849 {
1850 HCR_GetClassName(&CLSID_ShellDesktop, szPath, MAX_PATH);
1851 }
1852 else if ( _ILIsPidlSimple(pidl) )
1853 {
1854 _ILSimpleGetText(pidl, szPath, MAX_PATH);
1855 }
1856 else
1857 {
1858 if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, szPath, MAX_PATH)))
1859 return E_OUTOFMEMORY;
1860 }
1861 strRet->uType = STRRET_CSTRA;
1862 lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
1863
1864
1865 TRACE("-- (%p)->(%s)\n", This, szPath);
1866 return S_OK;
1867 }
1868
1869 static HRESULT WINAPI ISF_Desktop_fnGetDefaultSearchGUID(
1870 IShellFolder2 * iface,
1871 GUID *pguid)
1872 {
1873 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1874 FIXME("(%p)\n",This);
1875 return E_NOTIMPL;
1876 }
1877 static HRESULT WINAPI ISF_Desktop_fnEnumSearches(
1878 IShellFolder2 * iface,
1879 IEnumExtraSearch **ppenum)
1880 {
1881 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1882 FIXME("(%p)\n",This);
1883 return E_NOTIMPL;
1884 }
1885 static HRESULT WINAPI ISF_Desktop_fnGetDefaultColumn(
1886 IShellFolder2 * iface,
1887 DWORD dwRes,
1888 ULONG *pSort,
1889 ULONG *pDisplay)
1890 {
1891 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1892
1893 TRACE("(%p)\n",This);
1894
1895 if (pSort) *pSort = 0;
1896 if (pDisplay) *pDisplay = 0;
1897
1898 return S_OK;
1899 }
1900 static HRESULT WINAPI ISF_Desktop_fnGetDefaultColumnState(
1901 IShellFolder2 * iface,
1902 UINT iColumn,
1903 DWORD *pcsFlags)
1904 {
1905 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1906
1907 TRACE("(%p)\n",This);
1908
1909 if (!pcsFlags || iColumn >= DESKTOPSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1910
1911 *pcsFlags = DesktopSFHeader[iColumn].pcsFlags;
1912
1913 return S_OK;
1914 }
1915 static HRESULT WINAPI ISF_Desktop_fnGetDetailsEx(
1916 IShellFolder2 * iface,
1917 LPCITEMIDLIST pidl,
1918 const SHCOLUMNID *pscid,
1919 VARIANT *pv)
1920 {
1921 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1922 FIXME("(%p)\n",This);
1923
1924 return E_NOTIMPL;
1925 }
1926 static HRESULT WINAPI ISF_Desktop_fnGetDetailsOf(
1927 IShellFolder2 * iface,
1928 LPCITEMIDLIST pidl,
1929 UINT iColumn,
1930 SHELLDETAILS *psd)
1931 {
1932 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1933 HRESULT hr = E_FAIL;;
1934
1935 TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
1936
1937 if (!psd || iColumn >= DESKTOPSHELLVIEWCOLUMNS ) return E_INVALIDARG;
1938
1939 if (!pidl)
1940 {
1941 psd->fmt = DesktopSFHeader[iColumn].fmt;
1942 psd->cxChar = DesktopSFHeader[iColumn].cxChar;
1943 psd->str.uType = STRRET_CSTRA;
1944 LoadStringA(shell32_hInstance, DesktopSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
1945 return S_OK;
1946 }
1947 else
1948 {
1949 /* the data from the pidl */
1950 switch(iColumn)
1951 {
1952 case 0: /* name */
1953 hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
1954 break;
1955 case 1: /* size */
1956 _ILGetFileSize (pidl, psd->str.u.cStr, MAX_PATH);
1957 break;
1958 case 2: /* type */
1959 _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
1960 break;
1961 case 3: /* date */
1962 _ILGetFileDate(pidl, psd->str.u.cStr, MAX_PATH);
1963 break;
1964 case 4: /* attributes */
1965 _ILGetFileAttributes(pidl, psd->str.u.cStr, MAX_PATH);
1966 break;
1967 }
1968 hr = S_OK;
1969 psd->str.uType = STRRET_CSTRA;
1970 }
1971
1972 return hr;
1973 }
1974 static HRESULT WINAPI ISF_Desktop_fnMapNameToSCID(
1975 IShellFolder2 * iface,
1976 LPCWSTR pwszName,
1977 SHCOLUMNID *pscid)
1978 {
1979 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
1980 FIXME("(%p)\n",This);
1981 return E_NOTIMPL;
1982 }
1983
1984 static ICOM_VTABLE(IShellFolder2) sfdvt =
1985 {
1986 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1987 ISF_Desktop_fnQueryInterface,
1988 IShellFolder_fnAddRef,
1989 IShellFolder_fnRelease,
1990 ISF_Desktop_fnParseDisplayName,
1991 ISF_Desktop_fnEnumObjects,
1992 ISF_Desktop_fnBindToObject,
1993 IShellFolder_fnBindToStorage,
1994 IShellFolder_fnCompareIDs,
1995 ISF_Desktop_fnCreateViewObject,
1996 ISF_Desktop_fnGetAttributesOf,
1997 IShellFolder_fnGetUIObjectOf,
1998 ISF_Desktop_fnGetDisplayNameOf,
1999 IShellFolder_fnSetNameOf,
2000
2001 /* ShellFolder2 */
2002 ISF_Desktop_fnGetDefaultSearchGUID,
2003 ISF_Desktop_fnEnumSearches,
2004 ISF_Desktop_fnGetDefaultColumn,
2005 ISF_Desktop_fnGetDefaultColumnState,
2006 ISF_Desktop_fnGetDetailsEx,
2007 ISF_Desktop_fnGetDetailsOf,
2008 ISF_Desktop_fnMapNameToSCID
2009 };
2010
2011
2012 /***********************************************************************
2013 * IShellFolder [MyComputer] implementation
2014 */
2015
2016 static struct ICOM_VTABLE(IShellFolder2) sfmcvt;
2017
2018 static shvheader MyComputerSFHeader [] =
2019 {
2020 { IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
2021 { IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2022 { IDS_SHV_COLUMN6, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2023 { IDS_SHV_COLUMN7, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
2024 };
2025 #define MYCOMPUTERSHELLVIEWCOLUMNS 4
2026
2027 /**************************************************************************
2028 * ISF_MyComputer_Constructor
2029 */
2030 static IShellFolder * ISF_MyComputer_Constructor(void)
2031 {
2032 IGenericSFImpl * sf;
2033
2034 sf=(IGenericSFImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGenericSFImpl));
2035 sf->ref=1;
2036
2037 ICOM_VTBL(sf)=&unkvt;
2038 sf->lpvtblShellFolder=&sfmcvt;
2039 sf->lpvtblPersistFolder2 = &psfvt;
2040 sf->pclsid = (CLSID*)&CLSID_SFMyComp;
2041 sf->absPidl=_ILCreateMyComputer(); /* my qualified pidl */
2042 sf->pUnkOuter = (IUnknown *) &sf->lpVtbl;
2043
2044 TRACE("(%p)\n",sf);
2045
2046 shell32_ObjCount++;
2047 return _IShellFolder_(sf);
2048 }
2049
2050 /**************************************************************************
2051 * ISF_MyComputer_fnParseDisplayName
2052 */
2053 static HRESULT WINAPI ISF_MyComputer_fnParseDisplayName(
2054 IShellFolder2 * iface,
2055 HWND hwndOwner,
2056 LPBC pbcReserved,
2057 LPOLESTR lpszDisplayName,
2058 DWORD *pchEaten,
2059 LPITEMIDLIST *ppidl,
2060 DWORD *pdwAttributes)
2061 {
2062 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2063
2064 HRESULT hr = E_OUTOFMEMORY;
2065 LPCWSTR szNext=NULL;
2066 WCHAR szElement[MAX_PATH];
2067 CHAR szTempA[MAX_PATH];
2068 LPITEMIDLIST pidlTemp;
2069
2070 TRACE("(%p)->(HWND=0x%08x,%p,%p=%s,%p,pidl=%p,%p)\n",
2071 This,hwndOwner,pbcReserved,lpszDisplayName,
2072 debugstr_w(lpszDisplayName),pchEaten,ppidl,pdwAttributes);
2073
2074 *ppidl = 0;
2075 if (pchEaten) *pchEaten = 0; /* strange but like the original */
2076
2077 if (PathIsRootW(lpszDisplayName))
2078 {
2079 szNext = GetNextElementW(lpszDisplayName, szElement, MAX_PATH);
2080 lstrcpynWtoA(szTempA, szElement, lstrlenW(szElement) + 1);
2081 pidlTemp = _ILCreateDrive(szTempA);
2082
2083 if (szNext && *szNext)
2084 {
2085 hr = SHELL32_ParseNextElement(hwndOwner, iface, &pidlTemp, (LPOLESTR)szNext, pchEaten, pdwAttributes);
2086 }
2087 else
2088 {
2089 hr = S_OK;
2090 }
2091 *ppidl = pidlTemp;
2092 }
2093
2094 TRACE("(%p)->(-- ret=0x%08lx)\n", This, hr);
2095
2096 return hr;
2097 }
2098
2099 /**************************************************************************
2100 * ISF_MyComputer_fnEnumObjects
2101 */
2102 static HRESULT WINAPI ISF_MyComputer_fnEnumObjects(
2103 IShellFolder2 * iface,
2104 HWND hwndOwner,
2105 DWORD dwFlags,
2106 LPENUMIDLIST* ppEnumIDList)
2107 {
2108 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2109
2110 TRACE("(%p)->(HWND=0x%08x flags=0x%08lx pplist=%p)\n",This,hwndOwner,dwFlags,ppEnumIDList);
2111
2112 *ppEnumIDList = NULL;
2113 *ppEnumIDList = IEnumIDList_Constructor (NULL, dwFlags, EIDL_MYCOMP);
2114
2115 TRACE("-- (%p)->(new ID List: %p)\n",This,*ppEnumIDList);
2116
2117 if(!*ppEnumIDList) return E_OUTOFMEMORY;
2118
2119 return S_OK;
2120 }
2121
2122 /**************************************************************************
2123 * ISF_MyComputer_fnBindToObject
2124 */
2125 static HRESULT WINAPI ISF_MyComputer_fnBindToObject( IShellFolder2 * iface, LPCITEMIDLIST pidl,
2126 LPBC pbcReserved, REFIID riid, LPVOID * ppvOut)
2127 {
2128 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2129 GUID const * clsid;
2130 IShellFolder *pShellFolder, *pSubFolder;
2131 LPITEMIDLIST pidltemp;
2132
2133 TRACE("(%p)->(pidl=%p,%p,\n\tIID:\t%s,%p)\n",
2134 This,pidl,pbcReserved,debugstr_guid(riid),ppvOut);
2135
2136 if(!pidl || !ppvOut) return E_INVALIDARG;
2137
2138 *ppvOut = NULL;
2139
2140 if ((clsid=_ILGetGUIDPointer(pidl)) && !IsEqualIID(clsid, &CLSID_MyComputer))
2141 {
2142 if (!SUCCEEDED(SHELL32_CoCreateInitSF (This->absPidl, pidl, clsid, riid, (LPVOID*)&pShellFolder)))
2143 {
2144 return E_FAIL;
2145 }
2146 }
2147 else
2148 {
2149 if (!_ILIsDrive(pidl)) return E_INVALIDARG;
2150
2151 pidltemp = ILCloneFirst(pidl);
2152 pShellFolder = IShellFolder_Constructor(iface, pidltemp);
2153 ILFree(pidltemp);
2154 }
2155
2156 if (_ILIsPidlSimple(pidl)) /* no sub folders */
2157 {
2158 *ppvOut = pShellFolder;
2159 }
2160 else /* go deeper */
2161 {
2162 IShellFolder_BindToObject(pShellFolder, ILGetNext(pidl), NULL, &IID_IShellFolder, (LPVOID)&pSubFolder);
2163 IShellFolder_Release(pShellFolder);
2164 *ppvOut = pSubFolder;
2165 }
2166
2167 TRACE("-- (%p) returning (%p)\n",This, *ppvOut);
2168
2169 return S_OK;
2170 }
2171
2172 /**************************************************************************
2173 * ISF_MyComputer_fnCreateViewObject
2174 */
2175 static HRESULT WINAPI ISF_MyComputer_fnCreateViewObject( IShellFolder2 * iface,
2176 HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
2177 {
2178 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2179
2180 LPSHELLVIEW pShellView;
2181 HRESULT hr = E_INVALIDARG;
2182
2183 TRACE("(%p)->(hwnd=0x%x,\n\tIID:\t%s,%p)\n",This,hwndOwner,debugstr_guid(riid),ppvOut);
2184
2185 if(ppvOut)
2186 {
2187 *ppvOut = NULL;
2188
2189 if(IsEqualIID(riid, &IID_IDropTarget))
2190 {
2191 FIXME("IDropTarget not implemented\n");
2192 hr = E_NOTIMPL;
2193 }
2194 else if(IsEqualIID(riid, &IID_IContextMenu))
2195 {
2196 FIXME("IContextMenu not implemented\n");
2197 hr = E_NOTIMPL;
2198 }
2199 else if(IsEqualIID(riid, &IID_IShellView))
2200 {
2201 pShellView = IShellView_Constructor((IShellFolder*)iface);
2202 if(pShellView)
2203 {
2204 hr = IShellView_QueryInterface(pShellView, riid, ppvOut);
2205 IShellView_Release(pShellView);
2206 }
2207 }
2208 }
2209 TRACE("-- (%p)->(interface=%p)\n",This, ppvOut);
2210 return hr;
2211 }
2212
2213 /**************************************************************************
2214 * ISF_MyComputer_fnGetAttributesOf
2215 */
2216 static HRESULT WINAPI ISF_MyComputer_fnGetAttributesOf(IShellFolder2 * iface,UINT cidl,LPCITEMIDLIST *apidl,DWORD *rgfInOut)
2217 {
2218 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2219
2220 GUID const * clsid;
2221 DWORD attributes;
2222 HRESULT hr = S_OK;
2223
2224 TRACE("(%p)->(cidl=%d apidl=%p mask=0x%08lx)\n",This,cidl,apidl,*rgfInOut);
2225
2226 if ( (!cidl) || (!apidl) || (!rgfInOut))
2227 return E_INVALIDARG;
2228
2229 *rgfInOut = 0xffffffff;
2230
2231 while (cidl > 0 && *apidl)
2232 {
2233 pdump (*apidl);
2234
2235 if (_ILIsDrive(*apidl))
2236 {
2237 *rgfInOut &= 0xf0000144;
2238 goto next;
2239 }
2240 else if ((clsid=_ILGetGUIDPointer(*apidl)))
2241 {
2242 if (HCR_GetFolderAttributes(clsid, &attributes))
2243 {
2244 *rgfInOut &= attributes;
2245 goto next;
2246 }
2247 }
2248 hr = E_INVALIDARG;
2249
2250 next: apidl++;
2251 cidl--;
2252 }
2253
2254 TRACE("-- result=0x%08lx\n",*rgfInOut);
2255 return hr;
2256 }
2257
2258 /**************************************************************************
2259 * ISF_MyComputer_fnGetDisplayNameOf
2260 *
2261 * NOTES
2262 * The desktopfolder creates only complete paths (SHGDN_FORPARSING).
2263 * SHGDN_INFOLDER makes no sense.
2264 */
2265 static HRESULT WINAPI ISF_MyComputer_fnGetDisplayNameOf(
2266 IShellFolder2 * iface,
2267 LPCITEMIDLIST pidl,
2268 DWORD dwFlags,
2269 LPSTRRET strRet)
2270 {
2271 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2272
2273 char szPath[MAX_PATH], szDrive[18];
2274 int len = 0;
2275 BOOL bSimplePidl;
2276
2277 TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n",This,pidl,dwFlags,strRet);
2278 pdump(pidl);
2279
2280 if(!strRet) return E_INVALIDARG;
2281
2282 szPath[0]=0x00; szDrive[0]=0x00;
2283
2284
2285 bSimplePidl = _ILIsPidlSimple(pidl);
2286
2287 if (_ILIsSpecialFolder(pidl))
2288 {
2289 /* take names of special folders only if its only this folder */
2290 if ( bSimplePidl )
2291 {
2292 _ILSimpleGetText(pidl, szPath, MAX_PATH); /* append my own path */
2293 }
2294 }
2295 else
2296 {
2297 if (!_ILIsDrive(pidl))
2298 {
2299 ERR("Wrong pidl type\n");
2300 return E_INVALIDARG;
2301 }
2302
2303 _ILSimpleGetText(pidl, szPath, MAX_PATH); /* append my own path */
2304
2305 /* long view "lw_name (C:)" */
2306 if ( bSimplePidl && !(dwFlags & SHGDN_FORPARSING))
2307 {
2308 DWORD dwVolumeSerialNumber,dwMaximumComponetLength,dwFileSystemFlags;
2309
2310 GetVolumeInformationA(szPath,szDrive,12,&dwVolumeSerialNumber,&dwMaximumComponetLength,&dwFileSystemFlags,NULL,0);
2311 strcat (szDrive," (");
2312 strncat (szDrive, szPath, 2);
2313 strcat (szDrive,")");
2314 strcpy (szPath, szDrive);
2315 }
2316 }
2317
2318 if (!bSimplePidl) /* go deeper if needed */
2319 {
2320 PathAddBackslashA(szPath);
2321 len = strlen(szPath);
2322
2323 if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags | SHGDN_FORPARSING, szPath + len, MAX_PATH - len)))
2324 return E_OUTOFMEMORY;
2325 }
2326 strRet->uType = STRRET_CSTRA;
2327 lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
2328
2329
2330 TRACE("-- (%p)->(%s)\n", This, szPath);
2331 return S_OK;
2332 }
2333
2334 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultSearchGUID(
2335 IShellFolder2 * iface,
2336 GUID *pguid)
2337 {
2338 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2339 FIXME("(%p)\n",This);
2340 return E_NOTIMPL;
2341 }
2342 static HRESULT WINAPI ISF_MyComputer_fnEnumSearches(
2343 IShellFolder2 * iface,
2344 IEnumExtraSearch **ppenum)
2345 {
2346 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2347 FIXME("(%p)\n",This);
2348 return E_NOTIMPL;
2349 }
2350 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumn(
2351 IShellFolder2 * iface,
2352 DWORD dwRes,
2353 ULONG *pSort,
2354 ULONG *pDisplay)
2355 {
2356 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2357
2358 TRACE("(%p)\n",This);
2359
2360 if (pSort) *pSort = 0;
2361 if (pDisplay) *pDisplay = 0;
2362
2363 return S_OK;
2364 }
2365 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumnState(
2366 IShellFolder2 * iface,
2367 UINT iColumn,
2368 DWORD *pcsFlags)
2369 {
2370 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2371
2372 TRACE("(%p)\n",This);
2373
2374 if (!pcsFlags || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS ) return E_INVALIDARG;
2375
2376 *pcsFlags = MyComputerSFHeader[iColumn].pcsFlags;
2377
2378 return S_OK;
2379 }
2380 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsEx(
2381 IShellFolder2 * iface,
2382 LPCITEMIDLIST pidl,
2383 const SHCOLUMNID *pscid,
2384 VARIANT *pv)
2385 {
2386 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2387 FIXME("(%p)\n",This);
2388
2389 return E_NOTIMPL;
2390 }
2391
2392 /* fixme: drive size >4GB is rolling over */
2393 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsOf(
2394 IShellFolder2 * iface,
2395 LPCITEMIDLIST pidl,
2396 UINT iColumn,
2397 SHELLDETAILS *psd)
2398 {
2399 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2400 HRESULT hr;
2401
2402 TRACE("(%p)->(%p %i %p)\n",This, pidl, iColumn, psd);
2403
2404 if (!psd || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS ) return E_INVALIDARG;
2405
2406 if (!pidl)
2407 {
2408 psd->fmt = MyComputerSFHeader[iColumn].fmt;
2409 psd->cxChar = MyComputerSFHeader[iColumn].cxChar;
2410 psd->str.uType = STRRET_CSTRA;
2411 LoadStringA(shell32_hInstance, MyComputerSFHeader[iColumn].colnameid, psd->str.u.cStr, MAX_PATH);
2412 return S_OK;
2413 }
2414 else
2415 {
2416 char szPath[MAX_PATH];
2417 ULARGE_INTEGER ulBytes;
2418
2419 psd->str.u.cStr[0] = 0x00;
2420 psd->str.uType = STRRET_CSTRA;
2421 switch(iColumn)
2422 {
2423 case 0: /* name */
2424 hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
2425 break;
2426 case 1: /* type */
2427 _ILGetFileType(pidl, psd->str.u.cStr, MAX_PATH);
2428 break;
2429 case 2: /* total size */
2430 if (_ILIsDrive(pidl))
2431 {
2432 _ILSimpleGetText(pidl, szPath, MAX_PATH);
2433 GetDiskFreeSpaceExA(szPath, NULL, &ulBytes, NULL);
2434 StrFormatByteSizeA(ulBytes.s.LowPart, psd->str.u.cStr, MAX_PATH);
2435 }
2436 break;
2437 case 3: /* free size */
2438 if (_ILIsDrive(pidl))
2439 {
2440 _ILSimpleGetText(pidl, szPath, MAX_PATH);
2441 GetDiskFreeSpaceExA(szPath, &ulBytes, NULL, NULL);
2442 StrFormatByteSizeA(ulBytes.s.LowPart, psd->str.u.cStr, MAX_PATH);
2443 }
2444 break;
2445 }
2446 hr = S_OK;
2447 }
2448
2449 return hr;
2450 }
2451 static HRESULT WINAPI ISF_MyComputer_fnMapNameToSCID(
2452 IShellFolder2 * iface,
2453 LPCWSTR pwszName,
2454 SHCOLUMNID *pscid)
2455 {
2456 _ICOM_THIS_From_IShellFolder2(IGenericSFImpl, iface)
2457 FIXME("(%p)\n",This);
2458 return E_NOTIMPL;
2459 }
2460
2461 static ICOM_VTABLE(IShellFolder2) sfmcvt =
2462 {
2463 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2464 IShellFolder_fnQueryInterface,
2465 IShellFolder_fnAddRef,
2466 IShellFolder_fnRelease,
2467 ISF_MyComputer_fnParseDisplayName,
2468 ISF_MyComputer_fnEnumObjects,
2469 ISF_MyComputer_fnBindToObject,
2470 IShellFolder_fnBindToStorage,
2471 IShellFolder_fnCompareIDs,
2472 ISF_MyComputer_fnCreateViewObject,
2473 ISF_MyComputer_fnGetAttributesOf,
2474 IShellFolder_fnGetUIObjectOf,
2475 ISF_MyComputer_fnGetDisplayNameOf,
2476 IShellFolder_fnSetNameOf,
2477
2478 /* ShellFolder2 */
2479 ISF_MyComputer_fnGetDefaultSearchGUID,
2480 ISF_MyComputer_fnEnumSearches,
2481 ISF_MyComputer_fnGetDefaultColumn,
2482 ISF_MyComputer_fnGetDefaultColumnState,
2483 ISF_MyComputer_fnGetDetailsEx,
2484 ISF_MyComputer_fnGetDetailsOf,
2485 ISF_MyComputer_fnMapNameToSCID
2486 };
2487
2488
2489 /************************************************************************
2490 * ISFPersistFolder_QueryInterface (IUnknown)
2491 *
2492 */
2493 static HRESULT WINAPI ISFPersistFolder2_QueryInterface(
2494 IPersistFolder2 * iface,
2495 REFIID iid,
2496 LPVOID* ppvObj)
2497 {
2498 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2499
2500 TRACE("(%p)\n", This);
2501
2502 return IUnknown_QueryInterface(This->pUnkOuter, iid, ppvObj);
2503 }
2504
2505 /************************************************************************
2506 * ISFPersistFolder_AddRef (IUnknown)
2507 *
2508 */
2509 static ULONG WINAPI ISFPersistFolder2_AddRef(
2510 IPersistFolder2 * iface)
2511 {
2512 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2513
2514 TRACE("(%p)\n", This);
2515
2516 return IUnknown_AddRef(This->pUnkOuter);
2517 }
2518
2519 /************************************************************************
2520 * ISFPersistFolder_Release (IUnknown)
2521 *
2522 */
2523 static ULONG WINAPI ISFPersistFolder2_Release(
2524 IPersistFolder2 * iface)
2525 {
2526 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2527
2528 TRACE("(%p)\n", This);
2529
2530 return IUnknown_Release(This->pUnkOuter);
2531 }
2532
2533 /************************************************************************
2534 * ISFPersistFolder_GetClassID (IPersist)
2535 */
2536 static HRESULT WINAPI ISFPersistFolder2_GetClassID(
2537 IPersistFolder2 * iface,
2538 CLSID * lpClassId)
2539 {
2540 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2541
2542 TRACE("(%p)\n", This);
2543
2544 if (!lpClassId) return E_POINTER;
2545 *lpClassId = *This->pclsid;
2546
2547 return S_OK;
2548 }
2549
2550 /************************************************************************
2551 * ISFPersistFolder_Initialize (IPersistFolder)
2552 *
2553 * NOTES
2554 * sMyPath is not set. Don't know how to handle in a non rooted environment.
2555 */
2556 static HRESULT WINAPI ISFPersistFolder2_Initialize(
2557 IPersistFolder2 * iface,
2558 LPCITEMIDLIST pidl)
2559 {
2560 char sTemp[MAX_PATH];
2561 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2562
2563 TRACE("(%p)->(%p)\n", This, pidl);
2564
2565 /* free the old stuff */
2566 if(This->absPidl)
2567 {
2568 SHFree(This->absPidl);
2569 This->absPidl = NULL;
2570 }
2571 if(This->sMyPath)
2572 {
2573 SHFree(This->sMyPath);
2574 This->sMyPath = NULL;
2575 }
2576
2577 /* set my pidl */
2578 This->absPidl = ILClone(pidl);
2579
2580 /* set my path */
2581 if (SHGetPathFromIDListA(pidl, sTemp))
2582 {
2583 This->sMyPath = SHAlloc(strlen(sTemp+1));
2584 strcpy(This->sMyPath, sTemp);
2585 }
2586
2587 TRACE("--(%p)->(%s)\n", This, This->sMyPath);
2588
2589 return S_OK;
2590 }
2591
2592 /**************************************************************************
2593 * IPersistFolder2_fnGetCurFolder
2594 */
2595 static HRESULT WINAPI ISFPersistFolder2_fnGetCurFolder(
2596 IPersistFolder2 * iface,
2597 LPITEMIDLIST * pidl)
2598 {
2599 _ICOM_THIS_From_IPersistFolder2(IGenericSFImpl, iface);
2600
2601 TRACE("(%p)->(%p)\n",This, pidl);
2602
2603 if (!pidl) return E_POINTER;
2604
2605 *pidl = ILClone(This->absPidl);
2606
2607 return S_OK;
2608 }
2609
2610 static ICOM_VTABLE(IPersistFolder2) psfvt =
2611 {
2612 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2613 ISFPersistFolder2_QueryInterface,
2614 ISFPersistFolder2_AddRef,
2615 ISFPersistFolder2_Release,
2616 ISFPersistFolder2_GetClassID,
2617 ISFPersistFolder2_Initialize,
2618 ISFPersistFolder2_fnGetCurFolder
2619 };
2620
2621 /****************************************************************************
2622 * ISFDropTarget implementation
2623 */
2624 static BOOL ISFDropTarget_QueryDrop(
2625 IDropTarget *iface,
2626 DWORD dwKeyState,
2627 LPDWORD pdwEffect)
2628 {
2629 DWORD dwEffect = *pdwEffect;
2630
2631 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2632
2633 *pdwEffect = DROPEFFECT_NONE;
2634
2635 if (This->fAcceptFmt)
2636 { /* Does our interpretation of the keystate ... */
2637 *pdwEffect = KeyStateToDropEffect(dwKeyState);
2638
2639 /* ... matches the desired effect ? */
2640 if (dwEffect & *pdwEffect)
2641 {
2642 return TRUE;
2643 }
2644 }
2645 return FALSE;
2646 }
2647
2648 static HRESULT WINAPI ISFDropTarget_QueryInterface(
2649 IDropTarget *iface,
2650 REFIID riid,
2651 LPVOID *ppvObj)
2652 {
2653 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2654
2655 TRACE("(%p)\n", This);
2656
2657 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObj);
2658 }
2659
2660 static ULONG WINAPI ISFDropTarget_AddRef( IDropTarget *iface)
2661 {
2662 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2663
2664 TRACE("(%p)\n", This);
2665
2666 return IUnknown_AddRef(This->pUnkOuter);
2667 }
2668
2669 static ULONG WINAPI ISFDropTarget_Release( IDropTarget *iface)
2670 {
2671 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2672
2673 TRACE("(%p)\n", This);
2674
2675 return IUnknown_Release(This->pUnkOuter);
2676 }
2677
2678 static HRESULT WINAPI ISFDropTarget_DragEnter(
2679 IDropTarget *iface,
2680 IDataObject *pDataObject,
2681 DWORD dwKeyState,
2682 POINTL pt,
2683 DWORD *pdwEffect)
2684 {
2685 FORMATETC fmt;
2686
2687 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2688
2689 TRACE("(%p)->(DataObject=%p)\n",This,pDataObject);
2690
2691 InitFormatEtc(fmt, This->cfShellIDList, TYMED_HGLOBAL);
2692
2693 This->fAcceptFmt = (S_OK == IDataObject_QueryGetData(pDataObject, &fmt)) ? TRUE : FALSE;
2694
2695 ISFDropTarget_QueryDrop(iface, dwKeyState, pdwEffect);
2696
2697 return S_OK;
2698 }
2699
2700 static HRESULT WINAPI ISFDropTarget_DragOver(
2701 IDropTarget *iface,
2702 DWORD dwKeyState,
2703 POINTL pt,
2704 DWORD *pdwEffect)
2705 {
2706 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2707
2708 TRACE("(%p)\n",This);
2709
2710 if(!pdwEffect) return E_INVALIDARG;
2711
2712 ISFDropTarget_QueryDrop(iface, dwKeyState, pdwEffect);
2713
2714 return S_OK;
2715 }
2716
2717 static HRESULT WINAPI ISFDropTarget_DragLeave(
2718 IDropTarget *iface)
2719 {
2720 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2721
2722 TRACE("(%p)\n",This);
2723
2724 This->fAcceptFmt = FALSE;
2725
2726 return S_OK;
2727 }
2728
2729 static HRESULT WINAPI ISFDropTarget_Drop(
2730 IDropTarget *iface,
2731 IDataObject* pDataObject,
2732 DWORD dwKeyState,
2733 POINTL pt,
2734 DWORD *pdwEffect)
2735 {
2736 _ICOM_THIS_From_IDropTarget(IGenericSFImpl,iface);
2737
2738 FIXME("(%p) object dropped\n",This);
2739
2740 return E_NOTIMPL;
2741 }
2742
2743 static struct ICOM_VTABLE(IDropTarget) dtvt =
2744 {
2745 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2746 ISFDropTarget_QueryInterface,
2747 ISFDropTarget_AddRef,
2748 ISFDropTarget_Release,
2749 ISFDropTarget_DragEnter,
2750 ISFDropTarget_DragOver,
2751 ISFDropTarget_DragLeave,
2752 ISFDropTarget_Drop
2753 };
Maarten's multimedia branch