projects / reactos.git / blob
? search:


b39fb249742df9de1409ca44bd1aeded6c650999
[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 * RETURNS
889 * Nothing
890 *
891 * NOTES
892 * exported by ordinal
893 */
894 void WINAPI ILFree(LPITEMIDLIST pidl)
895 {
896 TRACE("(pidl=%p)\n",pidl);
897 if (pidl)
898 SHFree(pidl);
899 }
900
901 /*************************************************************************
902 * ILGlobalFree [SHELL32.156]
903 *
904 * Frees memory (if not NULL) allocated by Alloc allocator
905 *
906 * PARAMS
907 * pidl [I]
908 *
909 * RETURNS
910 * Nothing
911 *
912 * NOTES
913 * exported by ordinal.
914 */
915 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
916 {
917 TRACE("%p\n", pidl);
918
919 if (pidl)
920 Free(pidl);
921 }
922
923 /*************************************************************************
924 * ILCreateFromPathA [SHELL32.189]
925 *
926 * Creates a complex ItemIDList from a path and returns it.
927 *
928 * PARAMS
929 * path [I]
930 *
931 * RETURNS
932 * the newly created complex ItemIDList or NULL if failed
933 *
934 * NOTES
935 * exported by ordinal.
936 */
937 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
938 {
939 LPITEMIDLIST pidlnew = NULL;
940
941 TRACE_(shell)("%s\n", debugstr_a(path));
942
943 if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
944 return pidlnew;
945 return NULL;
946 }
947
948 /*************************************************************************
949 * ILCreateFromPathW [SHELL32.190]
950 *
951 * See ILCreateFromPathA.
952 */
953 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
954 {
955 LPITEMIDLIST pidlnew = NULL;
956
957 TRACE_(shell)("%s\n", debugstr_w(path));
958
959 if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
960 return pidlnew;
961 return NULL;
962 }
963
964 /*************************************************************************
965 * ILCreateFromPath [SHELL32.157]
966 */
967 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
968 {
969 if ( SHELL_OsIsUnicode())
970 return ILCreateFromPathW (path);
971 return ILCreateFromPathA (path);
972 }
973
974 /*************************************************************************
975 * _ILParsePathW [internal]
976 *
977 * Creates an ItemIDList from a path and returns it.
978 *
979 * PARAMS
980 * path [I] path to parse and convert into an ItemIDList
981 * lpFindFile [I] pointer to buffer to initialize the FileSystem
982 * Bind Data object with
983 * bBindCtx [I] indicates to create a BindContext and assign a
984 * FileSystem Bind Data object
985 * ppidl [O] the newly create ItemIDList
986 * prgfInOut [I/O] requested attributes on input and actual
987 * attributes on return
988 *
989 * RETURNS
990 * NO_ERROR on success or an OLE error code
991 *
992 * NOTES
993 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
994 * creates a BindContext object and assigns a FileSystem Bind Data object
995 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
996 * IShellFolder uses that FileSystem Bind Data object of the BindContext
997 * to pass data about the current path element to the next object. This
998 * is used to avoid having to verify the current path element on disk, so
999 * that creating an ItemIDList from a nonexistent path still can work.
1000 */
1001 static HRESULT WINAPI _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
1002 BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
1003 {
1004 LPSHELLFOLDER pSF = NULL;
1005 LPBC pBC = NULL;
1006 HRESULT ret;
1007
1008 TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
1009 ppidl, ppidl ? *ppidl : NULL,
1010 prgfInOut, prgfInOut ? *prgfInOut : 0);
1011
1012 ret = SHGetDesktopFolder(&pSF);
1013 if (FAILED(ret))
1014 return ret;
1015
1016 if (lpFindFile || bBindCtx)
1017 ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1018
1019 if (SUCCEEDED(ret))
1020 {
1021 ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1022 }
1023
1024 if (pBC)
1025 {
1026 IBindCtx_Release(pBC);
1027 pBC = NULL;
1028 }
1029
1030 IShellFolder_Release(pSF);
1031
1032 if (!SUCCEEDED(ret) && ppidl)
1033 *ppidl = NULL;
1034
1035 TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1036
1037 return ret;
1038 }
1039
1040 /*************************************************************************
1041 * SHSimpleIDListFromPath [SHELL32.162]
1042 *
1043 * Creates a simple ItemIDList from a path and returns it. This function
1044 * does not fail on nonexistent paths.
1045 *
1046 * PARAMS
1047 * path [I] path to parse and convert into an ItemIDList
1048 *
1049 * RETURNS
1050 * the newly created simple ItemIDList
1051 *
1052 * NOTES
1053 * Simple in the name does not mean a relative ItemIDList but rather a
1054 * fully qualified list, where only the file name is filled in and the
1055 * directory flag for those ItemID elements this is known about, eg.
1056 * it is not the last element in the ItemIDList or the actual directory
1057 * exists on disk.
1058 * exported by ordinal.
1059 */
1060 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA(LPCSTR lpszPath)
1061 {
1062 LPITEMIDLIST pidl = NULL;
1063 LPWSTR wPath = NULL;
1064 int len;
1065
1066 TRACE("%s\n", debugstr_a(lpszPath));
1067
1068 if (lpszPath)
1069 {
1070 len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1071 wPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1072 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1073 }
1074
1075 _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1076
1077 HeapFree(GetProcessHeap(), 0, wPath);
1078 TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1079 return pidl;
1080 }
1081
1082 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1083 {
1084 LPITEMIDLIST pidl = NULL;
1085
1086 TRACE("%s\n", debugstr_w(lpszPath));
1087
1088 _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1089 TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1090 return pidl;
1091 }
1092
1093 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1094 {
1095 if ( SHELL_OsIsUnicode())
1096 return SHSimpleIDListFromPathW (lpszPath);
1097 return SHSimpleIDListFromPathA (lpszPath);
1098 }
1099
1100 /*************************************************************************
1101 * SHGetDataFromIDListA [SHELL32.247]
1102 *
1103 * NOTES
1104 * the pidl can be a simple one. since we can't get the path out of the pidl
1105 * we have to take all data from the pidl
1106 */
1107 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1108 int nFormat, LPVOID dest, int len)
1109 {
1110 LPSTR filename, shortname;
1111 WIN32_FIND_DATAA * pfd;
1112
1113 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1114
1115 pdump(pidl);
1116 if (!psf || !dest)
1117 return E_INVALIDARG;
1118
1119 switch (nFormat)
1120 {
1121 case SHGDFIL_FINDDATA:
1122 pfd = dest;
1123
1124 if (_ILIsDrive(pidl) || _ILIsSpecialFolder(pidl))
1125 return E_INVALIDARG;
1126
1127 if (len < sizeof(WIN32_FIND_DATAA))
1128 return E_INVALIDARG;
1129
1130 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1131 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1132 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1133 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1134
1135 filename = _ILGetTextPointer(pidl);
1136 shortname = _ILGetSTextPointer(pidl);
1137
1138 if (filename)
1139 lstrcpynA(pfd->cFileName, filename, MAX_PATH);
1140 else
1141 pfd->cFileName[0] = '\0';
1142
1143 if (shortname)
1144 lstrcpynA(pfd->cAlternateFileName, shortname, MAX_PATH);
1145 else
1146 pfd->cAlternateFileName[0] = '\0';
1147 return NOERROR;
1148
1149 case SHGDFIL_NETRESOURCE:
1150 case SHGDFIL_DESCRIPTIONID:
1151 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1152 break;
1153
1154 default:
1155 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1156 }
1157
1158 return E_INVALIDARG;
1159 }
1160
1161 /*************************************************************************
1162 * SHGetDataFromIDListW [SHELL32.248]
1163 *
1164 */
1165 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1166 int nFormat, LPVOID dest, int len)
1167 {
1168 LPSTR filename, shortname;
1169 WIN32_FIND_DATAW * pfd = dest;
1170
1171 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1172
1173 pdump(pidl);
1174
1175 if (!psf || !dest)
1176 return E_INVALIDARG;
1177
1178 switch (nFormat)
1179 {
1180 case SHGDFIL_FINDDATA:
1181 pfd = dest;
1182
1183 if (_ILIsDrive(pidl))
1184 return E_INVALIDARG;
1185
1186 if (len < sizeof(WIN32_FIND_DATAW))
1187 return E_INVALIDARG;
1188
1189 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1190 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1191 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1192 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1193
1194 filename = _ILGetTextPointer(pidl);
1195 shortname = _ILGetSTextPointer(pidl);
1196
1197 if (!filename)
1198 pfd->cFileName[0] = '\0';
1199 else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1200 pfd->cFileName[MAX_PATH-1] = 0;
1201
1202 if (!shortname)
1203 pfd->cAlternateFileName[0] = '\0';
1204 else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1205 pfd->cAlternateFileName[13] = 0;
1206 return NOERROR;
1207
1208 case SHGDFIL_NETRESOURCE:
1209 case SHGDFIL_DESCRIPTIONID:
1210 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1211 break;
1212
1213 default:
1214 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1215 }
1216
1217 return E_INVALIDARG;
1218 }
1219
1220 /*************************************************************************
1221 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1222 *
1223 * PARAMETERS
1224 * pidl, [IN] pidl
1225 * pszPath [OUT] path
1226 *
1227 * RETURNS
1228 * path from a passed PIDL.
1229 *
1230 * NOTES
1231 * NULL returns FALSE
1232 * desktop pidl gives path to desktop directory back
1233 * special pidls returning FALSE
1234 */
1235 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1236 {
1237 WCHAR wszPath[MAX_PATH];
1238 BOOL bSuccess;
1239
1240 bSuccess = SHGetPathFromIDListW(pidl, wszPath);
1241 if (bSuccess)
1242 WideCharToMultiByte(CP_ACP, 0, wszPath, -1, pszPath, MAX_PATH, NULL, NULL);
1243
1244 return bSuccess;
1245 }
1246
1247 /*************************************************************************
1248 * SHGetPathFromIDListW [SHELL32.@]
1249 *
1250 * See SHGetPathFromIDListA.
1251 */
1252 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1253 {
1254 HRESULT hr;
1255 LPCITEMIDLIST pidlLast;
1256 LPSHELLFOLDER psfFolder;
1257 DWORD dwAttributes;
1258 STRRET strret;
1259
1260 TRACE_(shell)("(pidl=%p,%p)\n", pidl, debugstr_w(pszPath));
1261 pdump(pidl);
1262
1263 if (!pidl)
1264 return FALSE;
1265
1266 hr = SHBindToParent(pidl, &IID_IShellFolder, (VOID**)&psfFolder, &pidlLast);
1267 if (FAILED(hr)) return FALSE;
1268
1269 dwAttributes = SFGAO_FILESYSTEM;
1270 hr = IShellFolder_GetAttributesOf(psfFolder, 1, &pidlLast, &dwAttributes);
1271 if (FAILED(hr) || !(dwAttributes & SFGAO_FILESYSTEM)) {
1272 IShellFolder_Release(psfFolder);
1273 return FALSE;
1274 }
1275
1276 hr = IShellFolder_GetDisplayNameOf(psfFolder, pidlLast, SHGDN_FORPARSING, &strret);
1277 IShellFolder_Release(psfFolder);
1278 if (FAILED(hr)) return FALSE;
1279
1280 hr = StrRetToBufW(&strret, pidlLast, pszPath, MAX_PATH);
1281
1282 TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(pszPath), hr);
1283 return SUCCEEDED(hr);
1284 }
1285
1286 /*************************************************************************
1287 * SHBindToParent [shell version 5.0]
1288 */
1289 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1290 {
1291 IShellFolder * psfDesktop;
1292 HRESULT hr=E_FAIL;
1293
1294 TRACE_(shell)("pidl=%p\n", pidl);
1295 pdump(pidl);
1296
1297 if (!pidl || !ppv)
1298 return E_INVALIDARG;
1299
1300 *ppv = NULL;
1301 if (ppidlLast)
1302 *ppidlLast = NULL;
1303
1304 hr = SHGetDesktopFolder(&psfDesktop);
1305 if (FAILED(hr))
1306 return hr;
1307
1308 if (_ILIsPidlSimple(pidl))
1309 {
1310 /* we are on desktop level */
1311 hr = IShellFolder_QueryInterface(psfDesktop, riid, ppv);
1312 }
1313 else
1314 {
1315 LPITEMIDLIST pidlParent = ILClone(pidl);
1316 ILRemoveLastID(pidlParent);
1317 hr = IShellFolder_BindToObject(psfDesktop, pidlParent, NULL, riid, ppv);
1318 SHFree (pidlParent);
1319 }
1320
1321 IShellFolder_Release(psfDesktop);
1322
1323 if (SUCCEEDED(hr) && ppidlLast)
1324 *ppidlLast = ILFindLastID(pidl);
1325
1326 TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1327 return hr;
1328 }
1329
1330 /**************************************************************************
1331 *
1332 * internal functions
1333 *
1334 * ### 1. section creating pidls ###
1335 *
1336 *************************************************************************
1337 */
1338 LPITEMIDLIST _ILAlloc(PIDLTYPE type, unsigned int size)
1339 {
1340 LPITEMIDLIST pidlOut = NULL;
1341
1342 pidlOut = SHAlloc(size + 5);
1343 if(pidlOut)
1344 {
1345 LPPIDLDATA pData;
1346 LPITEMIDLIST pidlNext;
1347
1348 ZeroMemory(pidlOut, size + 5);
1349 pidlOut->mkid.cb = size + 3;
1350
1351 pData = _ILGetDataPointer(pidlOut);
1352 if (pData)
1353 pData->type = type;
1354
1355 pidlNext = ILGetNext(pidlOut);
1356 if (pidlNext)
1357 pidlNext->mkid.cb = 0x00;
1358 TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1359 }
1360
1361 return pidlOut;
1362 }
1363
1364 LPITEMIDLIST _ILCreateDesktop()
1365 {
1366 LPITEMIDLIST ret;
1367
1368 TRACE("()\n");
1369 ret = SHAlloc(2);
1370 if (ret)
1371 ret->mkid.cb = 0;
1372 return ret;
1373 }
1374
1375 LPITEMIDLIST _ILCreateMyComputer()
1376 {
1377 TRACE("()\n");
1378 return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1379 }
1380
1381 LPITEMIDLIST _ILCreateIExplore()
1382 {
1383 TRACE("()\n");
1384 return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1385 }
1386
1387 LPITEMIDLIST _ILCreateControlPanel()
1388 {
1389 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1390
1391 TRACE("()\n");
1392 if (parent)
1393 {
1394 LPITEMIDLIST cpl = _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1395
1396 if (cpl)
1397 {
1398 ret = ILCombine(parent, cpl);
1399 SHFree(cpl);
1400 }
1401 SHFree(parent);
1402 }
1403 return ret;
1404 }
1405
1406 LPITEMIDLIST _ILCreatePrinters()
1407 {
1408 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1409
1410 TRACE("()\n");
1411 if (parent)
1412 {
1413 LPITEMIDLIST printers = _ILCreateGuid(PT_YAGUID, &CLSID_Printers);
1414
1415 if (printers)
1416 {
1417 ret = ILCombine(parent, printers);
1418 SHFree(printers);
1419 }
1420 SHFree(parent);
1421 }
1422 return ret;
1423 }
1424
1425 LPITEMIDLIST _ILCreateNetwork()
1426 {
1427 TRACE("()\n");
1428 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1429 }
1430
1431 LPITEMIDLIST _ILCreateBitBucket()
1432 {
1433 TRACE("()\n");
1434 return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1435 }
1436
1437 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1438 {
1439 LPITEMIDLIST pidlOut;
1440
1441 if (type == PT_SHELLEXT || type == PT_GUID || type == PT_YAGUID)
1442 {
1443 pidlOut = _ILAlloc(type, sizeof(GUIDStruct));
1444 if (pidlOut)
1445 {
1446 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1447
1448 memcpy(&(pData->u.guid.guid), guid, sizeof(GUID));
1449 TRACE("-- create GUID-pidl %s\n",
1450 debugstr_guid(&(pData->u.guid.guid)));
1451 }
1452 }
1453 else
1454 {
1455 WARN("%d: invalid type for GUID\n", type);
1456 pidlOut = NULL;
1457 }
1458 return pidlOut;
1459 }
1460
1461 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1462 {
1463 IID iid;
1464
1465 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID, &iid)))
1466 {
1467 ERR("%s is not a GUID\n", szGUID);
1468 return NULL;
1469 }
1470 return _ILCreateGuid(PT_GUID, &iid);
1471 }
1472
1473 LPITEMIDLIST _ILCreateGuidFromStrW(LPCWSTR szGUID)
1474 {
1475 IID iid;
1476
1477 if (!SUCCEEDED(SHCLSIDFromStringW(szGUID, &iid)))
1478 {
1479 ERR("%s is not a GUID\n", debugstr_w(szGUID));
1480 return NULL;
1481 }
1482 return _ILCreateGuid(PT_GUID, &iid);
1483 }
1484
1485 LPITEMIDLIST _ILCreateFromFindDataW( WIN32_FIND_DATAW *wfd )
1486 {
1487 /* FIXME: should make unicode PIDLs */
1488 WIN32_FIND_DATAA fda;
1489
1490 memset( &fda, 0, sizeof fda );
1491 fda.dwFileAttributes = wfd->dwFileAttributes;
1492 fda.ftCreationTime = wfd->ftCreationTime;
1493 fda.ftLastAccessTime = wfd->ftLastAccessTime;
1494 fda.ftLastWriteTime = wfd->ftLastWriteTime;
1495 fda.nFileSizeHigh = wfd->nFileSizeHigh;
1496 fda.nFileSizeLow = wfd->nFileSizeLow;
1497 fda.dwReserved0 = wfd->dwReserved0;
1498 fda.dwReserved1 = wfd->dwReserved1;
1499 WideCharToMultiByte( CP_ACP, 0, wfd->cFileName, -1,
1500 fda.cFileName, MAX_PATH, NULL, NULL );
1501 return _ILCreateFromFindDataA( &fda );
1502 }
1503
1504 LPITEMIDLIST _ILCreateFromFindDataA(WIN32_FIND_DATAA * stffile )
1505 {
1506 char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1507 char * pbuff = buff;
1508 size_t len, len1;
1509 LPITEMIDLIST pidl;
1510 PIDLTYPE type;
1511
1512 if (!stffile)
1513 return NULL;
1514
1515 TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1516
1517 /* prepare buffer with both names */
1518 len = strlen (stffile->cFileName) + 1;
1519 memcpy (pbuff, stffile->cFileName, len);
1520 pbuff += len;
1521
1522 len1 = strlen (stffile->cAlternateFileName)+1;
1523 memcpy (pbuff, stffile->cAlternateFileName, len1);
1524
1525 type = (stffile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
1526
1527 /*
1528 * FileStruct already has one byte for the first name, so use len - 1 in
1529 * size calculation
1530 */
1531 pidl = _ILAlloc(type, sizeof(FileStruct) + (len - 1) + len1);
1532 if (pidl)
1533 {
1534 LPPIDLDATA pData;
1535 LPSTR pszDest;
1536
1537 /* set attributes */
1538 pData = _ILGetDataPointer(pidl);
1539 if (pData)
1540 {
1541 pData->type = type;
1542 FileTimeToDosDateTime( &(stffile->ftLastWriteTime),
1543 &pData->u.file.uFileDate, &pData->u.file.uFileTime);
1544 pData->u.file.dwFileSize = stffile->nFileSizeLow;
1545 pData->u.file.uFileAttribs = (WORD)stffile->dwFileAttributes;
1546 }
1547 pszDest = _ILGetTextPointer(pidl);
1548 if (pszDest)
1549 {
1550 memcpy(pszDest, buff, len + len1);
1551 TRACE("-- create Value: %s\n",debugstr_a(pszDest));
1552 }
1553 }
1554 return pidl;
1555 }
1556
1557 HRESULT _ILCreateFromPathA(LPCSTR szPath, LPITEMIDLIST* ppidl)
1558 {
1559 HANDLE hFile;
1560 WIN32_FIND_DATAA stffile;
1561
1562 if (!ppidl)
1563 return E_INVALIDARG;
1564
1565 hFile = FindFirstFileA(szPath, &stffile);
1566 if (hFile == INVALID_HANDLE_VALUE)
1567 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1568
1569 FindClose(hFile);
1570
1571 *ppidl = _ILCreateFromFindDataA(&stffile);
1572
1573 return *ppidl ? S_OK : E_OUTOFMEMORY;
1574 }
1575
1576 HRESULT _ILCreateFromPathW(LPCWSTR szPath, LPITEMIDLIST* ppidl)
1577 {
1578 HANDLE hFile;
1579 WIN32_FIND_DATAW stffile;
1580
1581 if (!ppidl)
1582 return E_INVALIDARG;
1583
1584 hFile = FindFirstFileW(szPath, &stffile);
1585 if (hFile == INVALID_HANDLE_VALUE)
1586 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1587
1588 FindClose(hFile);
1589
1590 *ppidl = _ILCreateFromFindDataW(&stffile);
1591
1592 return *ppidl ? S_OK : E_OUTOFMEMORY;
1593 }
1594
1595 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
1596 {
1597 LPITEMIDLIST pidlOut;
1598
1599 TRACE("(%s)\n",debugstr_w(lpszNew));
1600
1601 pidlOut = _ILAlloc(PT_DRIVE, sizeof(DriveStruct));
1602 if (pidlOut)
1603 {
1604 LPSTR pszDest;
1605
1606 pszDest = _ILGetTextPointer(pidlOut);
1607 if (pszDest)
1608 {
1609 strcpy(pszDest, "x:\\");
1610 pszDest[0]=toupperW(lpszNew[0]);
1611 TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1612 }
1613 }
1614 return pidlOut;
1615 }
1616
1617 /**************************************************************************
1618 * _ILGetDrive()
1619 *
1620 * Gets the text for the drive eg. 'c:\'
1621 *
1622 * RETURNS
1623 * strlen (lpszText)
1624 */
1625 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1626 {
1627 TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1628
1629 if(_ILIsMyComputer(pidl))
1630 pidl = ILGetNext(pidl);
1631
1632 if (pidl && _ILIsDrive(pidl))
1633 return _ILSimpleGetText(pidl, pOut, uSize);
1634
1635 return 0;
1636 }
1637
1638 /**************************************************************************
1639 *
1640 * ### 2. section testing pidls ###
1641 *
1642 **************************************************************************
1643 * _ILIsDesktop()
1644 * _ILIsMyComputer()
1645 * _ILIsSpecialFolder()
1646 * _ILIsDrive()
1647 * _ILIsFolder()
1648 * _ILIsValue()
1649 * _ILIsPidlSimple()
1650 */
1651 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1652 {
1653 TRACE("(%p)\n",pidl);
1654
1655 return pidl && pidl->mkid.cb ? 0 : 1;
1656 }
1657
1658 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1659 {
1660 REFIID iid = _ILGetGUIDPointer(pidl);
1661
1662 TRACE("(%p)\n",pidl);
1663
1664 if (iid)
1665 return IsEqualIID(iid, &CLSID_MyComputer);
1666 return FALSE;
1667 }
1668
1669 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1670 {
1671 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1672
1673 TRACE("(%p)\n",pidl);
1674
1675 return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type || PT_YAGUID == lpPData->type)) ||
1676 (pidl && pidl->mkid.cb == 0x00)
1677 ));
1678 }
1679
1680 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1681 {
1682 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1683
1684 TRACE("(%p)\n",pidl);
1685
1686 return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1687 PT_DRIVE1 == lpPData->type ||
1688 PT_DRIVE2 == lpPData->type ||
1689 PT_DRIVE3 == lpPData->type));
1690 }
1691
1692 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1693 {
1694 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1695
1696 TRACE("(%p)\n",pidl);
1697
1698 return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1699 }
1700
1701 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1702 {
1703 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1704
1705 TRACE("(%p)\n",pidl);
1706
1707 return (pidl && lpPData && PT_VALUE == lpPData->type);
1708 }
1709
1710 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1711 {
1712 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1713
1714 TRACE("(%p)\n",pidl);
1715
1716 return (pidl && lpPData && (lpPData->type == 0));
1717 }
1718
1719 /**************************************************************************
1720 * _ILIsPidlSimple
1721 */
1722 BOOL _ILIsPidlSimple(LPCITEMIDLIST pidl)
1723 {
1724 BOOL ret = TRUE;
1725
1726 if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1727 {
1728 WORD len = pidl->mkid.cb;
1729 LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
1730
1731 if (pidlnext->mkid.cb)
1732 ret = FALSE;
1733 }
1734
1735 TRACE("%s\n", ret ? "Yes" : "No");
1736 return ret;
1737 }
1738
1739 /**************************************************************************
1740 *
1741 * ### 3. section getting values from pidls ###
1742 */
1743
1744 /**************************************************************************
1745 * _ILSimpleGetText
1746 *
1747 * gets the text for the first item in the pidl (eg. simple pidl)
1748 *
1749 * returns the length of the string
1750 */
1751 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1752 {
1753 DWORD dwReturn=0;
1754 LPSTR szSrc;
1755 GUID const * riid;
1756 char szTemp[MAX_PATH];
1757
1758 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1759
1760 if (!pidl)
1761 return 0;
1762
1763 if (szOut)
1764 *szOut = 0;
1765
1766 if (_ILIsDesktop(pidl))
1767 {
1768 /* desktop */
1769 if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1770 {
1771 if (szOut)
1772 lstrcpynA(szOut, szTemp, uOutSize);
1773
1774 dwReturn = strlen (szTemp);
1775 }
1776 }
1777 else if (( szSrc = _ILGetTextPointer(pidl) ))
1778 {
1779 /* filesystem */
1780 if (szOut)
1781 lstrcpynA(szOut, szSrc, uOutSize);
1782
1783 dwReturn = strlen(szSrc);
1784 }
1785 else if (( riid = _ILGetGUIDPointer(pidl) ))
1786 {
1787 /* special folder */
1788 if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1789 {
1790 if (szOut)
1791 lstrcpynA(szOut, szTemp, uOutSize);
1792
1793 dwReturn = strlen (szTemp);
1794 }
1795 }
1796 else
1797 {
1798 ERR("-- no text\n");
1799 }
1800
1801 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
1802 return dwReturn;
1803 }
1804
1805 /**************************************************************************
1806 * _ILSimpleGetTextW
1807 *
1808 * gets the text for the first item in the pidl (eg. simple pidl)
1809 *
1810 * returns the length of the string
1811 */
1812 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
1813 {
1814 DWORD dwReturn;
1815 char szTemp[MAX_PATH];
1816
1817 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1818
1819 dwReturn = _ILSimpleGetText(pidl, szTemp, uOutSize);
1820
1821 if (!MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szOut, MAX_PATH))
1822 *szOut = 0;
1823
1824 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
1825 return dwReturn;
1826 }
1827
1828 /**************************************************************************
1829 *
1830 * ### 4. getting pointers to parts of pidls ###
1831 *
1832 **************************************************************************
1833 * _ILGetDataPointer()
1834 */
1835 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
1836 {
1837 if(pidl && pidl->mkid.cb != 0x00)
1838 return (LPPIDLDATA) &(pidl->mkid.abID);
1839 return NULL;
1840 }
1841
1842 /**************************************************************************
1843 * _ILGetTextPointer()
1844 * gets a pointer to the long filename string stored in the pidl
1845 */
1846 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
1847 {
1848 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
1849
1850 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1851
1852 if (!pdata)
1853 return NULL;
1854
1855 switch (pdata->type)
1856 {
1857 case PT_GUID:
1858 case PT_SHELLEXT:
1859 case PT_YAGUID:
1860 return NULL;
1861
1862 case PT_DRIVE:
1863 case PT_DRIVE1:
1864 case PT_DRIVE2:
1865 case PT_DRIVE3:
1866 return (LPSTR)&(pdata->u.drive.szDriveName);
1867
1868 case PT_FOLDER:
1869 case PT_FOLDER1:
1870 case PT_VALUE:
1871 case PT_IESPECIAL1:
1872 case PT_IESPECIAL2:
1873 return (LPSTR)&(pdata->u.file.szNames);
1874
1875 case PT_WORKGRP:
1876 case PT_COMP:
1877 case PT_NETWORK:
1878 case PT_NETPROVIDER:
1879 case PT_SHARE:
1880 return (LPSTR)&(pdata->u.network.szNames);
1881 }
1882 return NULL;
1883 }
1884
1885 /**************************************************************************
1886 * _ILGetSTextPointer()
1887 * gets a pointer to the short filename string stored in the pidl
1888 */
1889 LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
1890 {
1891 /* TRACE(pidl,"(pidl%p)\n", pidl); */
1892
1893 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1894
1895 if (!pdata)
1896 return NULL;
1897
1898 switch (pdata->type)
1899 {
1900 case PT_FOLDER:
1901 case PT_VALUE:
1902 case PT_IESPECIAL1:
1903 case PT_IESPECIAL2:
1904 return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
1905
1906 case PT_WORKGRP:
1907 return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
1908 }
1909 return NULL;
1910 }
1911
1912 /**************************************************************************
1913 * _ILGetGUIDPointer()
1914 *
1915 * returns reference to guid stored in some pidls
1916 */
1917 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
1918 {
1919 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1920
1921 TRACE("%p\n", pidl);
1922
1923 if (!pdata)
1924 return NULL;
1925
1926 TRACE("pdata->type 0x%04x\n", pdata->type);
1927 switch (pdata->type)
1928 {
1929 case PT_SHELLEXT:
1930 case PT_GUID:
1931 case PT_YAGUID:
1932 return &(pdata->u.guid.guid);
1933
1934 default:
1935 TRACE("Unknown pidl type 0x%04x\n", pdata->type);
1936 break;
1937 }
1938 return NULL;
1939 }
1940
1941 /*************************************************************************
1942 * _ILGetFileDateTime
1943 *
1944 * Given the ItemIdList, get the FileTime
1945 *
1946 * PARAMS
1947 * pidl [I] The ItemIDList
1948 * pFt [I] the resulted FILETIME of the file
1949 *
1950 * RETURNS
1951 * True if Successful
1952 *
1953 * NOTES
1954 *
1955 */
1956 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
1957 {
1958 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1959
1960 if (!pdata)
1961 return FALSE;
1962
1963 switch (pdata->type)
1964 {
1965 case PT_FOLDER:
1966 case PT_VALUE:
1967 DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
1968 break;
1969 default:
1970 return FALSE;
1971 }
1972 return TRUE;
1973 }
1974
1975 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1976 {
1977 FILETIME ft,lft;
1978 SYSTEMTIME time;
1979 BOOL ret;
1980
1981 if (_ILGetFileDateTime( pidl, &ft ))
1982 {
1983 FileTimeToLocalFileTime(&ft, &lft);
1984 FileTimeToSystemTime (&lft, &time);
1985
1986 ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize);
1987 if (ret)
1988 {
1989 /* Append space + time without seconds */
1990 pOut[ret-1] = ' ';
1991 GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &pOut[ret], uOutSize - ret);
1992 }
1993 }
1994 else
1995 {
1996 pOut[0] = '\0';
1997 ret = FALSE;
1998 }
1999 return ret;
2000 }
2001
2002 /*************************************************************************
2003 * _ILGetFileSize
2004 *
2005 * Given the ItemIdList, get the FileSize
2006 *
2007 * PARAMS
2008 * pidl [I] The ItemIDList
2009 * pOut [I] The buffer to save the result
2010 * uOutsize [I] The size of the buffer
2011 *
2012 * RETURNS
2013 * The FileSize
2014 *
2015 * NOTES
2016 * pOut can be null when no string is needed
2017 *
2018 */
2019 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2020 {
2021 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2022 DWORD dwSize;
2023
2024 if (!pdata)
2025 return 0;
2026
2027 switch (pdata->type)
2028 {
2029 case PT_VALUE:
2030 dwSize = pdata->u.file.dwFileSize;
2031 if (pOut)
2032 StrFormatByteSizeA(dwSize, pOut, uOutSize);
2033 return dwSize;
2034 }
2035 if (pOut)
2036 *pOut = 0x00;
2037 return 0;
2038 }
2039
2040 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2041 {
2042 char szTemp[MAX_PATH];
2043 const char * pPoint;
2044 LPCITEMIDLIST pidlTemp=pidl;
2045
2046 TRACE("pidl=%p\n",pidl);
2047
2048 if (!pidl)
2049 return FALSE;
2050
2051 pidlTemp = ILFindLastID(pidl);
2052
2053 if (!_ILIsValue(pidlTemp))
2054 return FALSE;
2055 if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
2056 return FALSE;
2057
2058 pPoint = PathFindExtensionA(szTemp);
2059
2060 if (!*pPoint)
2061 return FALSE;
2062
2063 pPoint++;
2064 lstrcpynA(pOut, pPoint, uOutSize);
2065 TRACE("%s\n",pOut);
2066
2067 return TRUE;
2068 }
2069
2070 /*************************************************************************
2071 * _ILGetFileType
2072 *
2073 * Given the ItemIdList, get the file type description
2074 *
2075 * PARAMS
2076 * pidl [I] The ItemIDList (simple)
2077 * pOut [I] The buffer to save the result
2078 * uOutsize [I] The size of the buffer
2079 *
2080 * RETURNS
2081 * nothing
2082 *
2083 * NOTES
2084 * This function copies as much as possible into the buffer.
2085 */
2086 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2087 {
2088 if(_ILIsValue(pidl))
2089 {
2090 char sTemp[64];
2091
2092 if(uOutSize > 0)
2093 pOut[0] = 0;
2094 if (_ILGetExtension (pidl, sTemp, 64))
2095 {
2096 if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2097 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
2098 {
2099 lstrcpynA (pOut, sTemp, uOutSize - 6);
2100 strcat (pOut, "-file");
2101 }
2102 }
2103 }
2104 else
2105 lstrcpynA(pOut, "Folder", uOutSize);
2106 }
2107
2108 /*************************************************************************
2109 * _ILGetFileAttributes
2110 *
2111 * Given the ItemIdList, get the Attrib string format
2112 *
2113 * PARAMS
2114 * pidl [I] The ItemIDList
2115 * pOut [I] The buffer to save the result
2116 * uOutsize [I] The size of the Buffer
2117 *
2118 * RETURNS
2119 * Attributes
2120 *
2121 * FIXME
2122 * return value 0 in case of error is a valid return value
2123 *
2124 */
2125 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2126 {
2127 LPPIDLDATA pData = _ILGetDataPointer(pidl);
2128 WORD wAttrib = 0;
2129 int i;
2130
2131 if (!pData)
2132 return 0;
2133
2134 switch(pData->type)
2135 {
2136 case PT_FOLDER:
2137 case PT_VALUE:
2138 wAttrib = pData->u.file.uFileAttribs;
2139 break;
2140 }
2141
2142 if(uOutSize >= 6)
2143 {
2144 i=0;
2145 if(wAttrib & FILE_ATTRIBUTE_READONLY)
2146 pOut[i++] = 'R';
2147 if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2148 pOut[i++] = 'H';
2149 if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2150 pOut[i++] = 'S';
2151 if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2152 pOut[i++] = 'A';
2153 if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2154 pOut[i++] = 'C';
2155 pOut[i] = 0x00;
2156 }
2157 return wAttrib;
2158 }
2159
2160 /*************************************************************************
2161 * ILFreeaPidl
2162 *
2163 * free a aPidl struct
2164 */
2165 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2166 {
2167 UINT i;
2168
2169 if (apidl)
2170 {
2171 for (i = 0; i < cidl; i++)
2172 SHFree(apidl[i]);
2173 SHFree(apidl);
2174 }
2175 }
2176
2177 /*************************************************************************
2178 * ILCopyaPidl
2179 *
2180 * copies an aPidl struct
2181 */
2182 LPITEMIDLIST* _ILCopyaPidl(LPCITEMIDLIST * apidlsrc, UINT cidl)
2183 {
2184 UINT i;
2185 LPITEMIDLIST *apidldest;
2186
2187 apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
2188 if (!apidlsrc)
2189 return NULL;
2190
2191 for (i = 0; i < cidl; i++)
2192 apidldest[i] = ILClone(apidlsrc[i]);
2193
2194 return apidldest;
2195 }
2196
2197 /*************************************************************************
2198 * _ILCopyCidaToaPidl
2199 *
2200 * creates aPidl from CIDA
2201 */
2202 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPIDA cida)
2203 {
2204 UINT i;
2205 LPITEMIDLIST *dst;
2206
2207 dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2208 if (!dst)
2209 return NULL;
2210
2211 if (pidl)
2212 *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
2213
2214 for (i = 0; i < cida->cidl; i++)
2215 dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));
2216
2217 return dst;
2218 }
A free Windows-compatible Operating System