projects / reactos.git / blob
? search:


265c3641f3d2d2a51e5c6045750396ea5e753037
[reactos.git] / reactos / lib / shell32 / pidl.c
1 /*
2 * pidl Handling
3 *
4 * Copyright 1998 Juergen Schmied
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * NOTES
21 * a pidl == NULL means desktop and is legal
22 *
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <ctype.h>
29 #include <stdarg.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define COBJMACROS
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winreg.h"
40 #include "objbase.h"
41 #include "shlguid.h"
42 #include "winerror.h"
43 #include "winnls.h"
44 #include "undocshell.h"
45 #include "shell32_main.h"
46 #include "shellapi.h"
47 #include "shlwapi.h"
48
49 #include "pidl.h"
50 #include "wine/debug.h"
51
52 WINE_DEFAULT_DEBUG_CHANNEL(pidl);
53 WINE_DECLARE_DEBUG_CHANNEL(shell);
54
55 /* from comctl32.dll */
56 extern LPVOID WINAPI Alloc(INT);
57 extern BOOL WINAPI Free(LPVOID);
58
59 /*************************************************************************
60 * ILGetDisplayNameEx [SHELL32.186]
61 *
62 * Retrieves the display name of an ItemIDList
63 *
64 * PARAMS
65 * psf [I] Shell Folder to start with, if NULL the desktop is used
66 * pidl [I] ItemIDList relativ to the psf to get the display name for
67 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
68 * type [I] Type of display name to retrieve
69 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
70 * 1 = SHGDN_NORMAL relative to the root folder
71 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
72 *
73 * RETURNS
74 * True if the display name could be retrieved successfully, False otherwise
75 */
76 BOOL WINAPI ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
77 {
78 BOOL ret = FALSE;
79 WCHAR wPath[MAX_PATH];
80
81 TRACE("%p %p %p %ld\n", psf, pidl, path, type);
82
83 if (!pidl || !path)
84 return FALSE;
85
86 ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
87 WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
88 TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
89
90 return ret;
91 }
92
93 BOOL WINAPI ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
94 {
95 LPSHELLFOLDER psfParent, lsf = psf;
96 HRESULT ret = NO_ERROR;
97 LPCITEMIDLIST pidllast;
98 STRRET strret;
99 DWORD flag;
100
101 TRACE("%p %p %p %ld\n", psf, pidl, path, type);
102
103 if (!pidl || !path)
104 return FALSE;
105
106 if (!lsf)
107 {
108 ret = SHGetDesktopFolder(&lsf);
109 if (FAILED(ret))
110 return FALSE;
111 }
112
113 if (type >= 0 && type <= 2)
114 {
115 switch (type)
116 {
117 case ILGDN_FORPARSING:
118 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
119 break;
120 case ILGDN_NORMAL:
121 flag = SHGDN_NORMAL;
122 break;
123 case ILGDN_INFOLDER:
124 flag = SHGDN_INFOLDER;
125 break;
126 default:
127 FIXME("Unknown type parameter = %lx\n", type);
128 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
129 break;
130 }
131 if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
132 {
133 ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
134 if (SUCCEEDED(ret))
135 {
136 ret = StrRetToStrNW(path, MAX_PATH, &strret, pidl);
137 }
138 }
139 else
140 {
141 ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
142 if (SUCCEEDED(ret))
143 {
144 ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
145 if (SUCCEEDED(ret))
146 {
147 ret = StrRetToStrNW(path, MAX_PATH, &strret, pidllast);
148 }
149 IShellFolder_Release(psfParent);
150 }
151 }
152 }
153
154 TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
155
156 if (!psf)
157 IShellFolder_Release(lsf);
158 return SUCCEEDED(ret);
159 }
160
161 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
162 {
163 TRACE_(shell)("%p %p %p %ld\n", psf, pidl, path, type);
164
165 if (SHELL_OsIsUnicode())
166 return ILGetDisplayNameExW(psf, pidl, path, type);
167 return ILGetDisplayNameExA(psf, pidl, path, type);
168 }
169
170 /*************************************************************************
171 * ILGetDisplayName [SHELL32.15]
172 */
173 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
174 {
175 TRACE_(shell)("%p %p\n", pidl, path);
176
177 if (SHELL_OsIsUnicode())
178 return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
179 return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
180 }
181
182 /*************************************************************************
183 * ILFindLastID [SHELL32.16]
184 *
185 * NOTES
186 * observed: pidl=Desktop return=pidl
187 */
188 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
189 {
190 LPCITEMIDLIST pidlLast = pidl;
191
192 TRACE("(pidl=%p)\n",pidl);
193
194 if (!pidl)
195 return NULL;
196
197 while (pidl->mkid.cb)
198 {
199 pidlLast = pidl;
200 pidl = ILGetNext(pidl);
201 }
202 return (LPITEMIDLIST)pidlLast;
203 }
204
205 /*************************************************************************
206 * ILRemoveLastID [SHELL32.17]
207 *
208 * NOTES
209 * when pidl=Desktop return=FALSE
210 */
211 BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
212 {
213 TRACE_(shell)("pidl=%p\n",pidl);
214
215 if (!pidl || !pidl->mkid.cb)
216 return 0;
217 ILFindLastID(pidl)->mkid.cb = 0;
218 return 1;
219 }
220
221 /*************************************************************************
222 * ILClone [SHELL32.18]
223 *
224 * NOTES
225 * duplicate an idlist
226 */
227 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
228 {
229 DWORD len;
230 LPITEMIDLIST newpidl;
231
232 if (!pidl)
233 return NULL;
234
235 len = ILGetSize(pidl);
236 newpidl = (LPITEMIDLIST)SHAlloc(len);
237 if (newpidl)
238 memcpy(newpidl,pidl,len);
239
240 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
241 pdump(pidl);
242
243 return newpidl;
244 }
245
246 /*************************************************************************
247 * ILCloneFirst [SHELL32.19]
248 *
249 * NOTES
250 * duplicates the first idlist of a complex pidl
251 */
252 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
253 {
254 DWORD len;
255 LPITEMIDLIST pidlNew = NULL;
256
257 TRACE("pidl=%p \n",pidl);
258 pdump(pidl);
259
260 if (pidl)
261 {
262 len = pidl->mkid.cb;
263 pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
264 if (pidlNew)
265 {
266 memcpy(pidlNew,pidl,len+2); /* 2 -> mind a desktop pidl */
267
268 if (len)
269 ILGetNext(pidlNew)->mkid.cb = 0x00;
270 }
271 }
272 TRACE("-- newpidl=%p\n",pidlNew);
273
274 return pidlNew;
275 }
276
277 /*************************************************************************
278 * ILLoadFromStream (SHELL32.26)
279 *
280 * NOTES
281 * the first two bytes are the len, the pidl is following then
282 */
283 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
284 {
285 WORD wLen = 0;
286 DWORD dwBytesRead;
287 HRESULT ret = E_FAIL;
288
289
290 TRACE_(shell)("%p %p\n", pStream , ppPidl);
291
292 if (*ppPidl)
293 {
294 SHFree(*ppPidl);
295 *ppPidl = NULL;
296 }
297
298 IStream_AddRef (pStream);
299
300 if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
301 {
302 TRACE("PIDL length is %d\n", wLen);
303 if (wLen != 0)
304 {
305 *ppPidl = SHAlloc (wLen);
306 if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
307 {
308 TRACE("Stream read OK\n");
309 ret = S_OK;
310 }
311 else
312 {
313 WARN("reading pidl failed\n");
314 SHFree(*ppPidl);
315 *ppPidl = NULL;
316 }
317 }
318 else
319 {
320 *ppPidl = NULL;
321 ret = S_OK;
322 }
323 }
324
325 /* we are not yet fully compatible */
326 if (*ppPidl && !pcheck(*ppPidl))
327 {
328 WARN("Check failed\n");
329 SHFree(*ppPidl);
330 *ppPidl = NULL;
331 }
332
333 IStream_Release (pStream);
334 TRACE("done\n");
335 return ret;
336 }
337
338 /*************************************************************************
339 * ILSaveToStream (SHELL32.27)
340 *
341 * NOTES
342 * the first two bytes are the len, the pidl is following then
343 */
344 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
345 {
346 LPCITEMIDLIST pidl;
347 WORD wLen = 0;
348 HRESULT ret = E_FAIL;
349
350 TRACE_(shell)("%p %p\n", pStream, pPidl);
351
352 IStream_AddRef (pStream);
353
354 pidl = pPidl;
355 while (pidl->mkid.cb)
356 {
357 wLen += sizeof(WORD) + pidl->mkid.cb;
358 pidl = ILGetNext(pidl);
359 }
360
361 if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
362 {
363 if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
364 ret = S_OK;
365 }
366 IStream_Release (pStream);
367
368 return ret;
369 }
370
371 /*************************************************************************
372 * SHILCreateFromPath [SHELL32.28]
373 *
374 * Create an ItemIDList from a path
375 *
376 * PARAMS
377 * path [I]
378 * ppidl [O]
379 * attributes [I/O] requested attributes on call and actual attributes when
380 * the function returns
381 *
382 * RETURNS
383 * NO_ERROR if successful, or an OLE errer code otherwise
384 *
385 * NOTES
386 * Wrapper for IShellFolder_ParseDisplayName().
387 */
388 HRESULT WINAPI SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
389 {
390 WCHAR lpszDisplayName[MAX_PATH];
391
392 TRACE_(shell)("%s %p 0x%08lx\n", path, ppidl, attributes ? *attributes : 0);
393
394 if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
395 lpszDisplayName[MAX_PATH-1] = 0;
396
397 return SHILCreateFromPathW(lpszDisplayName, ppidl, attributes);
398 }
399
400 HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
401 {
402 LPSHELLFOLDER sf;
403 DWORD pchEaten;
404 HRESULT ret = E_FAIL;
405
406 TRACE_(shell)("%s %p 0x%08lx\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
407
408 if (SUCCEEDED (SHGetDesktopFolder(&sf)))
409 {
410 ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
411 IShellFolder_Release(sf);
412 }
413 return ret;
414 }
415
416 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
417 {
418 if ( SHELL_OsIsUnicode())
419 return SHILCreateFromPathW (path, ppidl, attributes);
420 return SHILCreateFromPathA (path, ppidl, attributes);
421 }
422
423 /*************************************************************************
424 * SHCloneSpecialIDList [SHELL32.89]
425 *
426 * Create an ItemIDList to one of the special folders.
427
428 * PARAMS
429 * hwndOwner [in]
430 * nFolder [in] CSIDL_xxxxx
431 * fCreate [in] Create folder if it does not exist
432 *
433 * RETURNS
434 * Success: The newly created pidl
435 * Failure: NULL, if inputs are invalid.
436 *
437 * NOTES
438 * exported by ordinal.
439 * Caller is responsible for deallocating the returned ItemIDList with the
440 * shells IMalloc interface, aka ILFree.
441 */
442 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
443 {
444 LPITEMIDLIST ppidl;
445 TRACE_(shell)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
446
447 if (fCreate)
448 nFolder |= CSIDL_FLAG_CREATE;
449
450 SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
451 return ppidl;
452 }
453
454 /*************************************************************************
455 * ILGlobalClone [SHELL32.20]
456 *
457 * Clones an ItemIDList using Alloc.
458 *
459 * PARAMS
460 * pidl [I] ItemIDList to clone
461 *
462 * RETURNS
463 * Newly allocated ItemIDList.
464 *
465 * NOTES
466 * exported by ordinal.
467 */
468 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
469 {
470 DWORD len;
471 LPITEMIDLIST newpidl;
472
473 if (!pidl)
474 return NULL;
475
476 len = ILGetSize(pidl);
477 newpidl = (LPITEMIDLIST)Alloc(len);
478 if (newpidl)
479 memcpy(newpidl,pidl,len);
480
481 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
482 pdump(pidl);
483
484 return newpidl;
485 }
486
487 /*************************************************************************
488 * ILIsEqual [SHELL32.21]
489 *
490 */
491 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
492 {
493 char szData1[MAX_PATH];
494 char szData2[MAX_PATH];
495
496 LPCITEMIDLIST pidltemp1 = pidl1;
497 LPCITEMIDLIST pidltemp2 = pidl2;
498
499 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
500
501 /*
502 * Explorer reads from registry directly (StreamMRU),
503 * so we can only check here
504 */
505 if (!pcheck(pidl1) || !pcheck (pidl2))
506 return FALSE;
507
508 pdump (pidl1);
509 pdump (pidl2);
510
511 if (!pidl1 || !pidl2)
512 return FALSE;
513
514 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
515 {
516 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
517 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
518
519 if (strcasecmp( szData1, szData2 ))
520 return FALSE;
521
522 pidltemp1 = ILGetNext(pidltemp1);
523 pidltemp2 = ILGetNext(pidltemp2);
524 }
525
526 if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
527 return TRUE;
528
529 return FALSE;
530 }
531
532 /*************************************************************************
533 * ILIsParent [SHELL32.23]
534 *
535 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
536 *
537 * PARAMS
538 * pidlParent [I]
539 * pidlChild [I]
540 * bImmediate [I] only return true if the parent is the direct parent
541 * of the child
542 *
543 * RETURNS
544 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
545 * False otherwise.
546 *
547 * NOTES
548 * parent = a/b, child = a/b/c -> true, c is in folder a/b
549 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
550 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
551 */
552 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
553 {
554 char szData1[MAX_PATH];
555 char szData2[MAX_PATH];
556 LPCITEMIDLIST pParent = pidlParent;
557 LPCITEMIDLIST pChild = pidlChild;
558
559 TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
560
561 if (!pParent || !pChild)
562 return FALSE;
563
564 while (pParent->mkid.cb && pChild->mkid.cb)
565 {
566 _ILSimpleGetText(pParent, szData1, MAX_PATH);
567 _ILSimpleGetText(pChild, szData2, MAX_PATH);
568
569 if (strcasecmp( szData1, szData2 ))
570 return FALSE;
571
572 pParent = ILGetNext(pParent);
573 pChild = ILGetNext(pChild);
574 }
575
576 /* child shorter or has equal length to parent */
577 if (pParent->mkid.cb || !pChild->mkid.cb)
578 return FALSE;
579
580 /* not immediate descent */
581 if ( ILGetNext(pChild)->mkid.cb && bImmediate)
582 return FALSE;
583
584 return TRUE;
585 }
586
587 /*************************************************************************
588 * ILFindChild [SHELL32.24]
589 *
590 * Compares elements from pidl1 and pidl2.
591 *
592 * PARAMS
593 * pidl1 [I]
594 * pidl2 [I]
595 *
596 * RETURNS
597 * pidl1 is desktop pidl2
598 * pidl1 shorter pidl2 pointer to first different element of pidl2
599 * if there was at least one equal element
600 * pidl2 shorter pidl1 0
601 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
602 *
603 * NOTES
604 * exported by ordinal.
605 */
606 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
607 {
608 char szData1[MAX_PATH];
609 char szData2[MAX_PATH];
610
611 LPCITEMIDLIST pidltemp1 = pidl1;
612 LPCITEMIDLIST pidltemp2 = pidl2;
613 LPCITEMIDLIST ret=NULL;
614
615 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
616
617 /* explorer reads from registry directly (StreamMRU),
618 so we can only check here */
619 if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
620 return FALSE;
621
622 pdump (pidl1);
623 pdump (pidl2);
624
625 if (_ILIsDesktop(pidl1))
626 {
627 ret = pidl2;
628 }
629 else
630 {
631 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
632 {
633 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
634 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
635
636 if (strcasecmp(szData1,szData2))
637 break;
638
639 pidltemp1 = ILGetNext(pidltemp1);
640 pidltemp2 = ILGetNext(pidltemp2);
641 ret = pidltemp2;
642 }
643
644 if (pidltemp1->mkid.cb)
645 ret = NULL; /* elements of pidl1 left*/
646 }
647 TRACE_(shell)("--- %p\n", ret);
648 return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
649 }
650
651 /*************************************************************************
652 * ILCombine [SHELL32.25]
653 *
654 * Concatenates two complex ItemIDLists.
655 *
656 * PARAMS
657 * pidl1 [I] first complex ItemIDLists
658 * pidl2 [I] complex ItemIDLists to append
659 *
660 * RETURNS
661 * if both pidl's == NULL NULL
662 * if pidl1 == NULL cloned pidl2
663 * if pidl2 == NULL cloned pidl1
664 * otherwise new pidl with pidl2 appended to pidl1
665 *
666 * NOTES
667 * exported by ordinal.
668 * Does not destroy the passed in ItemIDLists!
669 */
670 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
671 {
672 DWORD len1,len2;
673 LPITEMIDLIST pidlNew;
674
675 TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
676
677 if (!pidl1 && !pidl2) return NULL;
678
679 pdump (pidl1);
680 pdump (pidl2);
681
682 if (!pidl1)
683 {
684 pidlNew = ILClone(pidl2);
685 return pidlNew;
686 }
687
688 if (!pidl2)
689 {
690 pidlNew = ILClone(pidl1);
691 return pidlNew;
692 }
693
694 len1 = ILGetSize(pidl1)-2;
695 len2 = ILGetSize(pidl2);
696 pidlNew = SHAlloc(len1+len2);
697
698 if (pidlNew)
699 {
700 memcpy(pidlNew,pidl1,len1);
701 memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
702 }
703
704 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
705 return pidlNew;
706 }
707
708 /*************************************************************************
709 * SHGetRealIDL [SHELL32.98]
710 *
711 * NOTES
712 */
713 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
714 {
715 IDataObject* pDataObj;
716 HRESULT hr;
717
718 hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple,
719 &IID_IDataObject, 0, (LPVOID*)&pDataObj);
720 if (SUCCEEDED(hr))
721 {
722 STGMEDIUM medium;
723 FORMATETC fmt;
724
725 fmt.cfFormat = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
726 fmt.ptd = NULL;
727 fmt.dwAspect = DVASPECT_CONTENT;
728 fmt.lindex = -1;
729 fmt.tymed = TYMED_HGLOBAL;
730
731 hr = IDataObject_GetData(pDataObj, &fmt, &medium);
732
733 IDataObject_Release(pDataObj);
734
735 if (SUCCEEDED(hr))
736 {
737 /*assert(pida->cidl==1);*/
738 LPIDA pida = (LPIDA)GlobalLock(medium.u.hGlobal);
739
740 LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
741 LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
742
743 *pidlReal = ILCombine(pidl_folder, pidl_child);
744
745 if (!*pidlReal)
746 hr = E_OUTOFMEMORY;
747
748 GlobalUnlock(medium.u.hGlobal);
749 GlobalFree(medium.u.hGlobal);
750 }
751 }
752
753 return hr;
754 }
755
756 /*************************************************************************
757 * SHLogILFromFSIL [SHELL32.95]
758 *
759 * NOTES
760 * pild = CSIDL_DESKTOP ret = 0
761 * pild = CSIDL_DRIVES ret = 0
762 */
763 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
764 {
765 FIXME("(pidl=%p)\n",pidl);
766
767 pdump(pidl);
768
769 return 0;
770 }
771
772 /*************************************************************************
773 * ILGetSize [SHELL32.152]
774 *
775 * Gets the byte size of an ItemIDList including zero terminator
776 *
777 * PARAMS
778 * pidl [I] ItemIDList
779 *
780 * RETURNS
781 * size of pidl in bytes
782 *
783 * NOTES
784 * exported by ordinal
785 */
786 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
787 {
788 LPCSHITEMID si = &(pidl->mkid);
789 UINT len=0;
790
791 if (pidl)
792 {
793 while (si->cb)
794 {
795 len += si->cb;
796 si = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
797 }
798 len += 2;
799 }
800 TRACE("pidl=%p size=%u\n",pidl, len);
801 return len;
802 }
803
804 /*************************************************************************
805 * ILGetNext [SHELL32.153]
806 *
807 * Gets the next ItemID of an ItemIDList
808 *
809 * PARAMS
810 * pidl [I] ItemIDList
811 *
812 * RETURNS
813 * null -> null
814 * desktop -> null
815 * simple pidl -> pointer to 0x0000 element
816 *
817 * NOTES
818 * exported by ordinal.
819 */
820 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
821 {
822 WORD len;
823
824 TRACE("%p\n", pidl);
825
826 if (pidl)
827 {
828 len = pidl->mkid.cb;
829 if (len)
830 {
831 pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
832 TRACE("-- %p\n", pidl);
833 return (LPITEMIDLIST)pidl;
834 }
835 }
836 return NULL;
837 }
838
839 /*************************************************************************
840 * ILAppend [SHELL32.154]
841 *
842 * Adds the single ItemID item to the ItemIDList indicated by pidl.
843 * If bEnd is FALSE, inserts the item in the front of the list,
844 * otherwise it adds the item to the end. (???)
845 *
846 * PARAMS
847 * pidl [I] ItemIDList to extend
848 * item [I] ItemID to prepend/append
849 * bEnd [I] Indicates if the item should be appended
850 *
851 * NOTES
852 * Destroys the passed in idlist! (???)
853 */
854 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl, LPCITEMIDLIST item, BOOL bEnd)
855 {
856 LPITEMIDLIST idlRet;
857
858 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
859
860 pdump (pidl);
861 pdump (item);
862
863 if (_ILIsDesktop(pidl))
864 {
865 idlRet = ILClone(item);
866 if (pidl)
867 SHFree (pidl);
868 return idlRet;
869 }
870
871 if (bEnd)
872 idlRet = ILCombine(pidl, item);
873 else
874 idlRet = ILCombine(item, pidl);
875
876 SHFree(pidl);
877 return idlRet;
878 }
879
880 /*************************************************************************
881 * ILFree [SHELL32.155]
882 *
883 * Frees memory (if not NULL) allocated by SHMalloc allocator
884 *
885 * PARAMS
886 * pidl [I]
887 *
888 * NOTES
889 * exported by ordinal
890 */
891 void WINAPI ILFree(LPITEMIDLIST pidl)
892 {
893 TRACE("(pidl=%p)\n",pidl);
894 if (pidl)
895 SHFree(pidl);
896 }
897
898 /*************************************************************************
899 * ILGlobalFree [SHELL32.156]
900 *
901 * Frees memory (if not NULL) allocated by Alloc allocator
902 *
903 * PARAMS
904 * pidl [I]
905 *
906 * NOTES
907 * exported by ordinal.
908 */
909 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
910 {
911 TRACE("%p\n", pidl);
912
913 if (pidl)
914 Free(pidl);
915 }
916
917 /*************************************************************************
918 * ILCreateFromPathA [SHELL32.189]
919 *
920 * Creates a complex ItemIDList from a path and returns it.
921 *
922 * PARAMS
923 * path [I]
924 *
925 * RETURNS
926 * the newly created complex ItemIDList or NULL if failed
927 *
928 * NOTES
929 * exported by ordinal.
930 */
931 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
932 {
933 LPITEMIDLIST pidlnew = NULL;
934
935 TRACE_(shell)("%s\n", debugstr_a(path));
936
937 if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
938 return pidlnew;
939 return NULL;
940 }
941
942 /*************************************************************************
943 * ILCreateFromPathW [SHELL32.190]
944 */
945 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
946 {
947 LPITEMIDLIST pidlnew = NULL;
948
949 TRACE_(shell)("%s\n", debugstr_w(path));
950
951 if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
952 return pidlnew;
953 return NULL;
954 }
955
956 /*************************************************************************
957 * ILCreateFromPath [SHELL32.157]
958 */
959 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
960 {
961 if ( SHELL_OsIsUnicode())
962 return ILCreateFromPathW (path);
963 return ILCreateFromPathA (path);
964 }
965
966 /*************************************************************************
967 * _ILParsePathW [internal]
968 *
969 * Creates an ItemIDList from a path and returns it.
970 *
971 * PARAMS
972 * path [I] path to parse and convert into an ItemIDList
973 * lpFindFile [I] pointer to buffer to initialize the FileSystem
974 * Bind Data object with
975 * bBindCtx [I] indicates to create a BindContext and assign a
976 * FileSystem Bind Data object
977 * ppidl [O] the newly create ItemIDList
978 * prgfInOut [I/O] requested attributes on input and actual
979 * attributes on return
980 *
981 * RETURNS
982 * NO_ERROR on success or an OLE error code
983 *
984 * NOTES
985 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
986 * creates a BindContext object and assigns a FileSystem Bind Data object
987 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
988 * IShellFolder uses that FileSystem Bind Data object of the BindContext
989 * to pass data about the current path element to the next object. This
990 * is used to avoid having to verify the current path element on disk, so
991 * that creating an ItemIDList from a nonexistent path still can work.
992 */
993 static HRESULT WINAPI _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
994 BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
995 {
996 LPSHELLFOLDER pSF = NULL;
997 LPBC pBC = NULL;
998 HRESULT ret;
999
1000 TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
1001 ppidl, ppidl ? *ppidl : NULL,
1002 prgfInOut, prgfInOut ? *prgfInOut : 0);
1003
1004 ret = SHGetDesktopFolder(&pSF);
1005 if (FAILED(ret))
1006 return ret;
1007
1008 if (lpFindFile || bBindCtx)
1009 ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1010
1011 if (SUCCEEDED(ret))
1012 {
1013 ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1014 }
1015
1016 if (pBC)
1017 {
1018 IBindCtx_Release(pBC);
1019 pBC = NULL;
1020 }
1021
1022 IShellFolder_Release(pSF);
1023
1024 if (!SUCCEEDED(ret) && ppidl)
1025 *ppidl = NULL;
1026
1027 TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1028
1029 return ret;
1030 }
1031
1032 /*************************************************************************
1033 * SHSimpleIDListFromPath [SHELL32.162]
1034 *
1035 * Creates a simple ItemIDList from a path and returns it. This function
1036 * does not fail on nonexistent paths.
1037 *
1038 * PARAMS
1039 * path [I] path to parse and convert into an ItemIDList
1040 *
1041 * RETURNS
1042 * the newly created simple ItemIDList
1043 *
1044 * NOTES
1045 * Simple in the name does not mean a relative ItemIDList but rather a
1046 * fully qualified list, where only the file name is filled in and the
1047 * directory flag for those ItemID elements this is known about, eg.
1048 * it is not the last element in the ItemIDList or the actual directory
1049 * exists on disk.
1050 * exported by ordinal.
1051 */
1052 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA(LPCSTR lpszPath)
1053 {
1054 LPITEMIDLIST pidl = NULL;
1055 LPWSTR wPath = NULL;
1056 int len;
1057
1058 TRACE("%s\n", debugstr_a(lpszPath));
1059
1060 if (lpszPath)
1061 {
1062 len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1063 wPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1064 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1065 }
1066
1067 _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1068
1069 HeapFree(GetProcessHeap(), 0, wPath);
1070 TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1071 return pidl;
1072 }
1073
1074 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1075 {
1076 LPITEMIDLIST pidl = NULL;
1077
1078 TRACE("%s\n", debugstr_w(lpszPath));
1079
1080 _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1081 TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1082 return pidl;
1083 }
1084
1085 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1086 {
1087 if ( SHELL_OsIsUnicode())
1088 return SHSimpleIDListFromPathW (lpszPath);
1089 return SHSimpleIDListFromPathA (lpszPath);
1090 }
1091
1092 /*************************************************************************
1093 * SHGetDataFromIDListA [SHELL32.247]
1094 *
1095 * NOTES
1096 * the pidl can be a simple one. since we can't get the path out of the pidl
1097 * we have to take all data from the pidl
1098 */
1099 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1100 int nFormat, LPVOID dest, int len)
1101 {
1102 LPSTR filename, shortname;
1103 WIN32_FIND_DATAA * pfd;
1104
1105 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1106
1107 pdump(pidl);
1108 if (!psf || !dest)
1109 return E_INVALIDARG;
1110
1111 switch (nFormat)
1112 {
1113 case SHGDFIL_FINDDATA:
1114 pfd = dest;
1115
1116 if (_ILIsDrive(pidl))
1117 return E_INVALIDARG;
1118
1119 if (len < sizeof(WIN32_FIND_DATAA))
1120 return E_INVALIDARG;
1121
1122 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1123 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1124 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1125 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1126
1127 filename = _ILGetTextPointer(pidl);
1128 shortname = _ILGetSTextPointer(pidl);
1129
1130 if (filename)
1131 lstrcpynA(pfd->cFileName, filename, MAX_PATH);
1132 else
1133 pfd->cFileName[0] = '\0';
1134
1135 if (shortname)
1136 lstrcpynA(pfd->cAlternateFileName, shortname, MAX_PATH);
1137 else
1138 pfd->cAlternateFileName[0] = '\0';
1139 return NOERROR;
1140
1141 case SHGDFIL_NETRESOURCE:
1142 case SHGDFIL_DESCRIPTIONID:
1143 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1144 break;
1145
1146 default:
1147 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1148 }
1149
1150 return E_INVALIDARG;
1151 }
1152
1153 /*************************************************************************
1154 * SHGetDataFromIDListW [SHELL32.248]
1155 *
1156 */
1157 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1158 int nFormat, LPVOID dest, int len)
1159 {
1160 LPSTR filename, shortname;
1161 WIN32_FIND_DATAW * pfd = dest;
1162
1163 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1164
1165 pdump(pidl);
1166
1167 if (!psf || !dest)
1168 return E_INVALIDARG;
1169
1170 switch (nFormat)
1171 {
1172 case SHGDFIL_FINDDATA:
1173 pfd = dest;
1174
1175 if (_ILIsDrive(pidl))
1176 return E_INVALIDARG;
1177
1178 if (len < sizeof(WIN32_FIND_DATAW))
1179 return E_INVALIDARG;
1180
1181 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1182 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1183 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1184 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1185
1186 filename = _ILGetTextPointer(pidl);
1187 shortname = _ILGetSTextPointer(pidl);
1188
1189 if (!filename)
1190 pfd->cFileName[0] = '\0';
1191 else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1192 pfd->cFileName[MAX_PATH-1] = 0;
1193
1194 if (!shortname)
1195 pfd->cAlternateFileName[0] = '\0';
1196 else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1197 pfd->cAlternateFileName[13] = 0;
1198 return NOERROR;
1199
1200 case SHGDFIL_NETRESOURCE:
1201 case SHGDFIL_DESCRIPTIONID:
1202 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1203 break;
1204
1205 default:
1206 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1207 }
1208
1209 return E_INVALIDARG;
1210 }
1211
1212 /*************************************************************************
1213 * SHELL_GetPathFromIDListA
1214 */
1215 HRESULT SHELL_GetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath, UINT uOutSize)
1216 {
1217 HRESULT hr = S_OK;
1218
1219 pszPath[0]=0;
1220
1221 /* One case is a PIDL rooted at desktop level */
1222 if (_ILIsValue(pidl) || _ILIsFolder(pidl))
1223 {
1224 hr = SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOP, FALSE);
1225
1226 if (SUCCEEDED(hr))
1227 PathAddBackslashA(pszPath);
1228 }
1229 /* The only other valid case is an item ID list beginning at "My Computer" */
1230 else if (_ILIsMyComputer(pidl))
1231 pidl = ILGetNext(pidl);
1232
1233 if (SUCCEEDED(hr))
1234 {
1235 LPSTR txt;
1236
1237 while(pidl && pidl->mkid.cb)
1238 {
1239 if (_ILIsSpecialFolder(pidl))
1240 {
1241 hr = E_INVALIDARG;
1242 break;
1243 }
1244
1245 txt = _ILGetTextPointer(pidl);
1246 if (!txt)
1247 {
1248 hr = E_INVALIDARG;
1249 break;
1250 }
1251
1252 if (lstrlenA(txt) > pidl->mkid.cb)
1253 ERR("pidl %p is borked\n",pidl);
1254
1255 /* make sure there's enough space for the next segment */
1256 if ((lstrlenA(txt) + lstrlenA(pszPath)) > uOutSize)
1257 {
1258 hr = E_INVALIDARG;
1259 break;
1260 }
1261 lstrcatA( pszPath, txt );
1262
1263 pidl = ILGetNext(pidl);
1264 if (!pidl)
1265 {
1266 hr = E_INVALIDARG;
1267 break;
1268 }
1269
1270 /* Are we at the end and successfully converted the complete PIDL? */
1271 if (!pidl->mkid.cb)
1272 break;
1273
1274 if ((lstrlenA(pszPath) + 1) > uOutSize)
1275 {
1276 hr = E_INVALIDARG;
1277 break;
1278 }
1279 if (!PathAddBackslashA(pszPath))
1280 {
1281 hr = E_INVALIDARG;
1282 break;
1283 }
1284 }
1285 }
1286 else
1287 hr = E_INVALIDARG;
1288
1289 TRACE_(shell)("-- %s, 0x%08lx\n", pszPath, hr);
1290 return hr;
1291 }
1292
1293 /*************************************************************************
1294 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1295 *
1296 * PARAMETERS
1297 * pidl, [IN] pidl
1298 * pszPath [OUT] path
1299 *
1300 * RETURNS
1301 * path from a passed PIDL.
1302 *
1303 * NOTES
1304 * NULL returns FALSE
1305 * desktop pidl gives path to desktop directory back
1306 * special pidls returning FALSE
1307 */
1308 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1309 {
1310 HRESULT hr;
1311
1312 TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
1313 pdump(pidl);
1314
1315 if (!pidl)
1316 return FALSE;
1317
1318 hr = SHELL_GetPathFromIDListA(pidl, pszPath, MAX_PATH);
1319
1320 return SUCCEEDED(hr);
1321 }
1322
1323 /*************************************************************************
1324 * SHELL_GetPathFromIDListW
1325 */
1326 HRESULT SHELL_GetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
1327 {
1328 HRESULT hr = S_OK;
1329 UINT len;
1330
1331 pszPath[0]=0;
1332
1333 /* One case is a PIDL rooted at desktop level */
1334 if (_ILIsValue(pidl) || _ILIsFolder(pidl))
1335 {
1336 hr = SHGetSpecialFolderPathW(0, pszPath, CSIDL_DESKTOP, FALSE);
1337
1338 if (SUCCEEDED(hr))
1339 PathAddBackslashW(pszPath);
1340 }
1341 /* The only other valid case is an item ID list beginning at "My Computer" */
1342 else if (_ILIsMyComputer(pidl))
1343 pidl = ILGetNext(pidl);
1344
1345 if (SUCCEEDED(hr))
1346 {
1347 LPSTR txt;
1348
1349 while(pidl && pidl->mkid.cb)
1350 {
1351 if (_ILIsSpecialFolder(pidl))
1352 {
1353 hr = E_INVALIDARG;
1354 break;
1355 }
1356
1357 txt = _ILGetTextPointer(pidl);
1358 if (!txt)
1359 {
1360 hr = E_INVALIDARG;
1361 break;
1362 }
1363
1364 if (lstrlenA(txt) > pidl->mkid.cb)
1365 ERR("pidl %p is borked\n",pidl);
1366 len = MultiByteToWideChar(CP_ACP, 0, txt, -1, NULL, 0);
1367 if ( (lstrlenW(pszPath) + len) > uOutSize )
1368 {
1369 hr = E_INVALIDARG;
1370 break;
1371 }
1372
1373 MultiByteToWideChar(CP_ACP, 0, txt, -1,
1374 &pszPath[lstrlenW(pszPath)], len);
1375
1376 pidl = ILGetNext(pidl);
1377 if (!pidl)
1378 {
1379 hr = E_INVALIDARG;
1380 break;
1381 }
1382
1383 /* Are we at the end and successfully converted the complete PIDL? */
1384 if (!pidl->mkid.cb)
1385 break;
1386
1387 if ((lstrlenW(pszPath) + 1) > uOutSize )
1388 {
1389 hr = E_INVALIDARG;
1390 break;
1391 }
1392 if (!PathAddBackslashW(pszPath))
1393 {
1394 hr = E_INVALIDARG;
1395 break;
1396 }
1397 }
1398 }
1399 else
1400 hr = E_INVALIDARG;
1401
1402 TRACE_(shell)("-- %s, 0x%08lx\n", debugstr_w(pszPath), hr);
1403 return hr;
1404 }
1405
1406 /*************************************************************************
1407 * SHGetPathFromIDListW [SHELL32.@]
1408 */
1409 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1410 {
1411 HRESULT hr;
1412
1413 TRACE_(shell)("(pidl=%p,%p)\n", pidl, debugstr_w(pszPath));
1414 pdump(pidl);
1415
1416 if (!pidl)
1417 return FALSE;
1418
1419 hr = SHELL_GetPathFromIDListW(pidl, pszPath, MAX_PATH);
1420
1421 TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(pszPath), hr);
1422 return SUCCEEDED(hr);
1423 }
1424
1425 /*************************************************************************
1426 * SHBindToParent [shell version 5.0]
1427 */
1428 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1429 {
1430 IShellFolder * psf;
1431 LPITEMIDLIST pidlChild, pidlParent;
1432 HRESULT hr=E_FAIL;
1433
1434 TRACE_(shell)("pidl=%p\n", pidl);
1435 pdump(pidl);
1436
1437 *ppv = NULL;
1438 if (ppidlLast)
1439 *ppidlLast = NULL;
1440
1441 if (_ILIsPidlSimple(pidl))
1442 {
1443 IShellFolder* desktop;
1444
1445 /* we are on desktop level */
1446 hr = SHGetDesktopFolder(&desktop);
1447
1448 if (SUCCEEDED(hr))
1449 {
1450 hr = IShellFolder_QueryInterface(desktop, riid, ppv);
1451
1452 if (SUCCEEDED(hr) && ppidlLast)
1453 *ppidlLast = ILClone(pidl);
1454
1455 IShellFolder_Release(desktop);
1456 }
1457 }
1458 else
1459 {
1460 pidlChild = ILClone(ILFindLastID(pidl));
1461 pidlParent = ILClone(pidl);
1462 ILRemoveLastID(pidlParent);
1463
1464 hr = SHGetDesktopFolder(&psf);
1465
1466 if (SUCCEEDED(hr))
1467 hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
1468
1469 if (SUCCEEDED(hr) && ppidlLast)
1470 *ppidlLast = pidlChild;
1471 else
1472 ILFree (pidlChild);
1473
1474 SHFree (pidlParent);
1475 if (psf)
1476 IShellFolder_Release(psf);
1477 }
1478
1479 TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1480 return hr;
1481 }
1482
1483 /**************************************************************************
1484 *
1485 * internal functions
1486 *
1487 * ### 1. section creating pidls ###
1488 *
1489 *************************************************************************
1490 */
1491 LPITEMIDLIST _ILAlloc(PIDLTYPE type, size_t size)
1492 {
1493 LPITEMIDLIST pidlOut = NULL;
1494
1495 pidlOut = SHAlloc(size + 5);
1496 if(pidlOut)
1497 {
1498 LPPIDLDATA pData;
1499 LPITEMIDLIST pidlNext;
1500
1501 ZeroMemory(pidlOut, size + 5);
1502 pidlOut->mkid.cb = size + 3;
1503
1504 pData = _ILGetDataPointer(pidlOut);
1505 if (pData)
1506 pData->type = type;
1507
1508 pidlNext = ILGetNext(pidlOut);
1509 if (pidlNext)
1510 pidlNext->mkid.cb = 0x00;
1511 TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1512 }
1513
1514 return pidlOut;
1515 }
1516
1517 LPITEMIDLIST _ILCreateDesktop()
1518 {
1519 LPITEMIDLIST ret;
1520
1521 TRACE("()\n");
1522 ret = SHAlloc(2);
1523 if (ret)
1524 ret->mkid.cb = 0;
1525 return ret;
1526 }
1527
1528 LPITEMIDLIST _ILCreateMyComputer()
1529 {
1530 TRACE("()\n");
1531 return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1532 }
1533
1534 LPITEMIDLIST _ILCreateIExplore()
1535 {
1536 TRACE("()\n");
1537 return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1538 }
1539
1540 LPITEMIDLIST _ILCreateControlPanel()
1541 {
1542 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1543
1544 TRACE("()\n");
1545 if (parent)
1546 {
1547 LPITEMIDLIST cpl = _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1548
1549 if (cpl)
1550 {
1551 ret = ILCombine(parent, cpl);
1552 SHFree(cpl);
1553 }
1554 SHFree(parent);
1555 }
1556 return ret;
1557 }
1558
1559 LPITEMIDLIST _ILCreatePrinters()
1560 {
1561 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1562
1563 TRACE("()\n");
1564 if (parent)
1565 {
1566 LPITEMIDLIST printers = _ILCreateGuid(PT_YAGUID, &CLSID_Printers);
1567
1568 if (printers)
1569 {
1570 ret = ILCombine(parent, printers);
1571 SHFree(printers);
1572 }
1573 SHFree(parent);
1574 }
1575 return ret;
1576 }
1577
1578 LPITEMIDLIST _ILCreateNetwork()
1579 {
1580 TRACE("()\n");
1581 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1582 }
1583
1584 LPITEMIDLIST _ILCreateBitBucket()
1585 {
1586 TRACE("()\n");
1587 return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1588 }
1589
1590 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1591 {
1592 LPITEMIDLIST pidlOut;
1593
1594 if (type == PT_SHELLEXT || type == PT_GUID || type == PT_YAGUID)
1595 {
1596 pidlOut = _ILAlloc(type, sizeof(GUIDStruct));
1597 if (pidlOut)
1598 {
1599 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1600
1601 memcpy(&(pData->u.guid.guid), guid, sizeof(GUID));
1602 TRACE("-- create GUID-pidl %s\n",
1603 debugstr_guid(&(pData->u.guid.guid)));
1604 }
1605 }
1606 else
1607 {
1608 WARN("%d: invalid type for GUID\n", type);
1609 pidlOut = NULL;
1610 }
1611 return pidlOut;
1612 }
1613
1614 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1615 {
1616 IID iid;
1617
1618 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID, &iid)))
1619 {
1620 ERR("%s is not a GUID\n", szGUID);
1621 return NULL;
1622 }
1623 return _ILCreateGuid(PT_GUID, &iid);
1624 }
1625
1626 LPITEMIDLIST _ILCreateGuidFromStrW(LPCWSTR szGUID)
1627 {
1628 IID iid;
1629
1630 if (!SUCCEEDED(SHCLSIDFromStringW(szGUID, &iid)))
1631 {
1632 ERR("%s is not a GUID\n", debugstr_w(szGUID));
1633 return NULL;
1634 }
1635 return _ILCreateGuid(PT_GUID, &iid);
1636 }
1637
1638 LPITEMIDLIST _ILCreateFromFindDataW( WIN32_FIND_DATAW *wfd )
1639 {
1640 /* FIXME: should make unicode PIDLs */
1641 WIN32_FIND_DATAA fda;
1642
1643 memset( &fda, 0, sizeof fda );
1644 fda.dwFileAttributes = wfd->dwFileAttributes;
1645 fda.ftCreationTime = wfd->ftCreationTime;
1646 fda.ftLastAccessTime = wfd->ftLastAccessTime;
1647 fda.ftLastWriteTime = wfd->ftLastWriteTime;
1648 fda.nFileSizeHigh = wfd->nFileSizeHigh;
1649 fda.nFileSizeLow = wfd->nFileSizeLow;
1650 fda.dwReserved0 = wfd->dwReserved0;
1651 fda.dwReserved1 = wfd->dwReserved1;
1652 WideCharToMultiByte( CP_ACP, 0, wfd->cFileName, -1,
1653 fda.cFileName, MAX_PATH, NULL, NULL );
1654 return _ILCreateFromFindDataA( &fda );
1655 }
1656
1657 LPITEMIDLIST _ILCreateFromFindDataA(WIN32_FIND_DATAA * stffile )
1658 {
1659 char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1660 char * pbuff = buff;
1661 size_t len, len1;
1662 LPITEMIDLIST pidl;
1663 PIDLTYPE type;
1664
1665 if (!stffile)
1666 return NULL;
1667
1668 TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1669
1670 /* prepare buffer with both names */
1671 len = strlen (stffile->cFileName) + 1;
1672 memcpy (pbuff, stffile->cFileName, len);
1673 pbuff += len;
1674
1675 len1 = strlen (stffile->cAlternateFileName)+1;
1676 memcpy (pbuff, stffile->cAlternateFileName, len1);
1677
1678 type = (stffile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
1679
1680 /*
1681 * FileStruct already has one byte for the first name, so use len - 1 in
1682 * size calculation
1683 */
1684 pidl = _ILAlloc(type, sizeof(FileStruct) + (len - 1) + len1);
1685 if (pidl)
1686 {
1687 LPPIDLDATA pData;
1688 LPSTR pszDest;
1689
1690 /* set attributes */
1691 pData = _ILGetDataPointer(pidl);
1692 if (pData)
1693 {
1694 pData->type = type;
1695 FileTimeToDosDateTime( &(stffile->ftLastWriteTime),
1696 &pData->u.file.uFileDate, &pData->u.file.uFileTime);
1697 pData->u.file.dwFileSize = stffile->nFileSizeLow;
1698 pData->u.file.uFileAttribs = (WORD)stffile->dwFileAttributes;
1699 }
1700 pszDest = _ILGetTextPointer(pidl);
1701 if (pszDest)
1702 {
1703 memcpy(pszDest, buff, len + len1);
1704 TRACE("-- create Value: %s\n",debugstr_a(pszDest));
1705 }
1706 }
1707 return pidl;
1708 }
1709
1710 HRESULT _ILCreateFromPathA(LPCSTR szPath, LPITEMIDLIST* ppidl)
1711 {
1712 HANDLE hFile;
1713 WIN32_FIND_DATAA stffile;
1714
1715 if (!ppidl)
1716 return E_INVALIDARG;
1717
1718 hFile = FindFirstFileA(szPath, &stffile);
1719 if (hFile == INVALID_HANDLE_VALUE)
1720 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1721
1722 FindClose(hFile);
1723
1724 *ppidl = _ILCreateFromFindDataA(&stffile);
1725
1726 return *ppidl ? S_OK : E_OUTOFMEMORY;
1727 }
1728
1729 HRESULT _ILCreateFromPathW(LPCWSTR szPath, LPITEMIDLIST* ppidl)
1730 {
1731 HANDLE hFile;
1732 WIN32_FIND_DATAW stffile;
1733
1734 if (!ppidl)
1735 return E_INVALIDARG;
1736
1737 hFile = FindFirstFileW(szPath, &stffile);
1738 if (hFile == INVALID_HANDLE_VALUE)
1739 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1740
1741 FindClose(hFile);
1742
1743 *ppidl = _ILCreateFromFindDataW(&stffile);
1744
1745 return *ppidl ? S_OK : E_OUTOFMEMORY;
1746 }
1747
1748 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
1749 {
1750 LPITEMIDLIST pidlOut;
1751
1752 TRACE("(%s)\n",debugstr_w(lpszNew));
1753
1754 pidlOut = _ILAlloc(PT_DRIVE, sizeof(DriveStruct));
1755 if (pidlOut)
1756 {
1757 LPSTR pszDest;
1758
1759 pszDest = _ILGetTextPointer(pidlOut);
1760 if (pszDest)
1761 {
1762 strcpy(pszDest, "x:\\");
1763 pszDest[0]=toupperW(lpszNew[0]);
1764 TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1765 }
1766 }
1767 return pidlOut;
1768 }
1769
1770 /**************************************************************************
1771 * _ILGetDrive()
1772 *
1773 * Gets the text for the drive eg. 'c:\'
1774 *
1775 * RETURNS
1776 * strlen (lpszText)
1777 */
1778 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1779 {
1780 TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1781
1782 if(_ILIsMyComputer(pidl))
1783 pidl = ILGetNext(pidl);
1784
1785 if (pidl && _ILIsDrive(pidl))
1786 return _ILSimpleGetText(pidl, pOut, uSize);
1787
1788 return 0;
1789 }
1790
1791 /**************************************************************************
1792 *
1793 * ### 2. section testing pidls ###
1794 *
1795 **************************************************************************
1796 * _ILIsDesktop()
1797 * _ILIsMyComputer()
1798 * _ILIsSpecialFolder()
1799 * _ILIsDrive()
1800 * _ILIsFolder()
1801 * _ILIsValue()
1802 * _ILIsPidlSimple()
1803 */
1804 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1805 {
1806 TRACE("(%p)\n",pidl);
1807
1808 return pidl && pidl->mkid.cb ? 0 : 1;
1809 }
1810
1811 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1812 {
1813 REFIID iid = _ILGetGUIDPointer(pidl);
1814
1815 TRACE("(%p)\n",pidl);
1816
1817 if (iid)
1818 return IsEqualIID(iid, &CLSID_MyComputer);
1819 return FALSE;
1820 }
1821
1822 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1823 {
1824 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1825
1826 TRACE("(%p)\n",pidl);
1827
1828 return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type || PT_YAGUID == lpPData->type)) ||
1829 (pidl && pidl->mkid.cb == 0x00)
1830 ));
1831 }
1832
1833 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1834 {
1835 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1836
1837 TRACE("(%p)\n",pidl);
1838
1839 return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1840 PT_DRIVE1 == lpPData->type ||
1841 PT_DRIVE2 == lpPData->type ||
1842 PT_DRIVE3 == lpPData->type));
1843 }
1844
1845 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1846 {
1847 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1848
1849 TRACE("(%p)\n",pidl);
1850
1851 return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1852 }
1853
1854 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1855 {
1856 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1857
1858 TRACE("(%p)\n",pidl);
1859
1860 return (pidl && lpPData && PT_VALUE == lpPData->type);
1861 }
1862
1863 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1864 {
1865 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1866
1867 TRACE("(%p)\n",pidl);
1868
1869 return (pidl && lpPData && (lpPData->type == 0));
1870 }
1871
1872 /**************************************************************************
1873 * _ILIsPidlSimple
1874 */
1875 BOOL _ILIsPidlSimple(LPCITEMIDLIST pidl)
1876 {
1877 BOOL ret = TRUE;
1878
1879 if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1880 {
1881 WORD len = pidl->mkid.cb;
1882 LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
1883
1884 if (pidlnext->mkid.cb)
1885 ret = FALSE;
1886 }
1887
1888 TRACE("%s\n", ret ? "Yes" : "No");
1889 return ret;
1890 }
1891
1892 /**************************************************************************
1893 *
1894 * ### 3. section getting values from pidls ###
1895 */
1896
1897 /**************************************************************************
1898 * _ILSimpleGetText
1899 *
1900 * gets the text for the first item in the pidl (eg. simple pidl)
1901 *
1902 * returns the length of the string
1903 */
1904 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1905 {
1906 DWORD dwReturn=0;
1907 LPSTR szSrc;
1908 GUID const * riid;
1909 char szTemp[MAX_PATH];
1910
1911 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1912
1913 if (!pidl)
1914 return 0;
1915
1916 if (szOut)
1917 *szOut = 0;
1918
1919 if (_ILIsDesktop(pidl))
1920 {
1921 /* desktop */
1922 if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1923 {
1924 if (szOut)
1925 lstrcpynA(szOut, szTemp, uOutSize);
1926
1927 dwReturn = strlen (szTemp);
1928 }
1929 }
1930 else if (( szSrc = _ILGetTextPointer(pidl) ))
1931 {
1932 /* filesystem */
1933 if (szOut)
1934 lstrcpynA(szOut, szSrc, uOutSize);
1935
1936 dwReturn = strlen(szSrc);
1937 }
1938 else if (( riid = _ILGetGUIDPointer(pidl) ))
1939 {
1940 /* special folder */
1941 if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1942 {
1943 if (szOut)
1944 lstrcpynA(szOut, szTemp, uOutSize);
1945
1946 dwReturn = strlen (szTemp);
1947 }
1948 }
1949 else
1950 {
1951 ERR("-- no text\n");
1952 }
1953
1954 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
1955 return dwReturn;
1956 }
1957
1958 /**************************************************************************
1959 * _ILSimpleGetTextW
1960 *
1961 * gets the text for the first item in the pidl (eg. simple pidl)
1962 *
1963 * returns the length of the string
1964 */
1965 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
1966 {
1967 DWORD dwReturn;
1968 char szTemp[MAX_PATH];
1969
1970 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1971
1972 dwReturn = _ILSimpleGetText(pidl, szTemp, uOutSize);
1973
1974 if (!MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szOut, MAX_PATH))
1975 *szOut = 0;
1976
1977 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
1978 return dwReturn;
1979 }
1980
1981 /**************************************************************************
1982 *
1983 * ### 4. getting pointers to parts of pidls ###
1984 *
1985 **************************************************************************
1986 * _ILGetDataPointer()
1987 */
1988 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
1989 {
1990 if(pidl && pidl->mkid.cb != 0x00)
1991 return (LPPIDLDATA) &(pidl->mkid.abID);
1992 return NULL;
1993 }
1994
1995 /**************************************************************************
1996 * _ILGetTextPointer()
1997 * gets a pointer to the long filename string stored in the pidl
1998 */
1999 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
2000 {
2001 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
2002
2003 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2004
2005 if (!pdata)
2006 return NULL;
2007
2008 switch (pdata->type)
2009 {
2010 case PT_GUID:
2011 case PT_SHELLEXT:
2012 case PT_YAGUID:
2013 return NULL;
2014
2015 case PT_DRIVE:
2016 case PT_DRIVE1:
2017 case PT_DRIVE2:
2018 case PT_DRIVE3:
2019 return (LPSTR)&(pdata->u.drive.szDriveName);
2020
2021 case PT_FOLDER:
2022 case PT_FOLDER1:
2023 case PT_VALUE:
2024 case PT_IESPECIAL1:
2025 case PT_IESPECIAL2:
2026 return (LPSTR)&(pdata->u.file.szNames);
2027
2028 case PT_WORKGRP:
2029 case PT_COMP:
2030 case PT_NETWORK:
2031 case PT_NETPROVIDER:
2032 case PT_SHARE:
2033 return (LPSTR)&(pdata->u.network.szNames);
2034 }
2035 return NULL;
2036 }
2037
2038 /**************************************************************************
2039 * _ILGetSTextPointer()
2040 * gets a pointer to the short filename string stored in the pidl
2041 */
2042 LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
2043 {
2044 /* TRACE(pidl,"(pidl%p)\n", pidl); */
2045
2046 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2047
2048 if (!pdata)
2049 return NULL;
2050
2051 switch (pdata->type)
2052 {
2053 case PT_FOLDER:
2054 case PT_VALUE:
2055 case PT_IESPECIAL1:
2056 case PT_IESPECIAL2:
2057 return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
2058
2059 case PT_WORKGRP:
2060 return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
2061 }
2062 return NULL;
2063 }
2064
2065 /**************************************************************************
2066 * _ILGetGUIDPointer()
2067 *
2068 * returns reference to guid stored in some pidls
2069 */
2070 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
2071 {
2072 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2073
2074 TRACE("%p\n", pidl);
2075
2076 if (!pdata)
2077 return NULL;
2078
2079 TRACE("pdata->type 0x%04x\n", pdata->type);
2080 switch (pdata->type)
2081 {
2082 case PT_SHELLEXT:
2083 case PT_GUID:
2084 case PT_YAGUID:
2085 return &(pdata->u.guid.guid);
2086
2087 default:
2088 TRACE("Unknown pidl type 0x%04x\n", pdata->type);
2089 break;
2090 }
2091 return NULL;
2092 }
2093
2094 /*************************************************************************
2095 * _ILGetFileDateTime
2096 *
2097 * Given the ItemIdList, get the FileTime
2098 *
2099 * PARAMS
2100 * pidl [I] The ItemIDList
2101 * pFt [I] the resulted FILETIME of the file
2102 *
2103 * RETURNS
2104 * True if Successful
2105 *
2106 * NOTES
2107 *
2108 */
2109 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
2110 {
2111 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2112
2113 if (!pdata)
2114 return FALSE;
2115
2116 switch (pdata->type)
2117 {
2118 case PT_FOLDER:
2119 case PT_VALUE:
2120 DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
2121 break;
2122 default:
2123 return FALSE;
2124 }
2125 return TRUE;
2126 }
2127
2128 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2129 {
2130 FILETIME ft,lft;
2131 SYSTEMTIME time;
2132 BOOL ret;
2133
2134 if (_ILGetFileDateTime( pidl, &ft ))
2135 {
2136 FileTimeToLocalFileTime(&ft, &lft);
2137 FileTimeToSystemTime (&lft, &time);
2138 ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize);
2139 }
2140 else
2141 {
2142 pOut[0] = '\0';
2143 ret = FALSE;
2144 }
2145 return ret;
2146 }
2147
2148 /*************************************************************************
2149 * _ILGetFileSize
2150 *
2151 * Given the ItemIdList, get the FileSize
2152 *
2153 * PARAMS
2154 * pidl [I] The ItemIDList
2155 * pOut [I] The buffer to save the result
2156 * uOutsize [I] The size of the buffer
2157 *
2158 * RETURNS
2159 * The FileSize
2160 *
2161 * NOTES
2162 * pOut can be null when no string is needed
2163 *
2164 */
2165 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2166 {
2167 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2168 DWORD dwSize;
2169
2170 if (!pdata)
2171 return 0;
2172
2173 switch (pdata->type)
2174 {
2175 case PT_VALUE:
2176 dwSize = pdata->u.file.dwFileSize;
2177 if (pOut)
2178 StrFormatByteSizeA(dwSize, pOut, uOutSize);
2179 return dwSize;
2180 }
2181 if (pOut)
2182 *pOut = 0x00;
2183 return 0;
2184 }
2185
2186 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2187 {
2188 char szTemp[MAX_PATH];
2189 const char * pPoint;
2190 LPCITEMIDLIST pidlTemp=pidl;
2191
2192 TRACE("pidl=%p\n",pidl);
2193
2194 if (!pidl)
2195 return FALSE;
2196
2197 pidlTemp = ILFindLastID(pidl);
2198
2199 if (!_ILIsValue(pidlTemp))
2200 return FALSE;
2201 if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
2202 return FALSE;
2203
2204 pPoint = PathFindExtensionA(szTemp);
2205
2206 if (!*pPoint)
2207 return FALSE;
2208
2209 pPoint++;
2210 lstrcpynA(pOut, pPoint, uOutSize);
2211 TRACE("%s\n",pOut);
2212
2213 return TRUE;
2214 }
2215
2216 /*************************************************************************
2217 * _ILGetFileType
2218 *
2219 * Given the ItemIdList, get the file type description
2220 *
2221 * PARAMS
2222 * pidl [I] The ItemIDList (simple)
2223 * pOut [I] The buffer to save the result
2224 * uOutsize [I] The size of the buffer
2225 *
2226 * RETURNS
2227 * nothing
2228 *
2229 * NOTES
2230 * This function copies as much as possible into the buffer.
2231 */
2232 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2233 {
2234 if(_ILIsValue(pidl))
2235 {
2236 char sTemp[64];
2237
2238 if(uOutSize > 0)
2239 pOut[0] = 0;
2240 if (_ILGetExtension (pidl, sTemp, 64))
2241 {
2242 if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2243 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
2244 {
2245 lstrcpynA (pOut, sTemp, uOutSize - 6);
2246 strcat (pOut, "-file");
2247 }
2248 }
2249 }
2250 else
2251 lstrcpynA(pOut, "Folder", uOutSize);
2252 }
2253
2254 /*************************************************************************
2255 * _ILGetFileAttributes
2256 *
2257 * Given the ItemIdList, get the Attrib string format
2258 *
2259 * PARAMS
2260 * pidl [I] The ItemIDList
2261 * pOut [I] The buffer to save the result
2262 * uOutsize [I] The size of the Buffer
2263 *
2264 * RETURNS
2265 * Attributes
2266 *
2267 * FIXME
2268 * return value 0 in case of error is a valid return value
2269 *
2270 */
2271 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2272 {
2273 LPPIDLDATA pData = _ILGetDataPointer(pidl);
2274 WORD wAttrib = 0;
2275 int i;
2276
2277 if (!pData)
2278 return 0;
2279
2280 switch(pData->type)
2281 {
2282 case PT_FOLDER:
2283 case PT_VALUE:
2284 wAttrib = pData->u.file.uFileAttribs;
2285 break;
2286 }
2287
2288 if(uOutSize >= 6)
2289 {
2290 i=0;
2291 if(wAttrib & FILE_ATTRIBUTE_READONLY)
2292 pOut[i++] = 'R';
2293 if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2294 pOut[i++] = 'H';
2295 if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2296 pOut[i++] = 'S';
2297 if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2298 pOut[i++] = 'A';
2299 if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2300 pOut[i++] = 'C';
2301 pOut[i] = 0x00;
2302 }
2303 return wAttrib;
2304 }
2305
2306 /*************************************************************************
2307 * ILFreeaPidl
2308 *
2309 * free a aPidl struct
2310 */
2311 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2312 {
2313 UINT i;
2314
2315 if (apidl)
2316 {
2317 for (i = 0; i < cidl; i++)
2318 SHFree(apidl[i]);
2319 SHFree(apidl);
2320 }
2321 }
2322
2323 /*************************************************************************
2324 * ILCopyaPidl
2325 *
2326 * copies an aPidl struct
2327 */
2328 LPITEMIDLIST* _ILCopyaPidl(LPCITEMIDLIST * apidlsrc, UINT cidl)
2329 {
2330 UINT i;
2331 LPITEMIDLIST *apidldest;
2332
2333 apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
2334 if (!apidlsrc)
2335 return NULL;
2336
2337 for (i = 0; i < cidl; i++)
2338 apidldest[i] = ILClone(apidlsrc[i]);
2339
2340 return apidldest;
2341 }
2342
2343 /*************************************************************************
2344 * _ILCopyCidaToaPidl
2345 *
2346 * creates aPidl from CIDA
2347 */
2348 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPIDA cida)
2349 {
2350 UINT i;
2351 LPITEMIDLIST *dst;
2352
2353 dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2354 if (!dst)
2355 return NULL;
2356
2357 if (pidl)
2358 *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
2359
2360 for (i = 0; i < cida->cidl; i++)
2361 dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
2362
2363 return dst;
2364 }
A free Windows-compatible Operating System