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