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