push 6e61d6ca5bcaf95ac09a664b4ba4f88238c927be
[wine/hacks.git] / dlls / shell32 / pidl.c
blob99bbed8c673ce63de21ae62c133c7277770330f0
1 /*
2 * pidl Handling
4 * Copyright 1998 Juergen Schmied
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.
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.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * NOTES
21 * a pidl == NULL means desktop and is legal
25 #include "config.h"
26 #include "wine/port.h"
28 #include <ctype.h>
29 #include <stdarg.h>
30 #include <stdlib.h>
31 #include <string.h>
33 #define COBJMACROS
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
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 "shlwapi.h"
48 #include "pidl.h"
49 #include "wine/debug.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(pidl);
52 WINE_DECLARE_DEBUG_CHANNEL(shell);
54 /* from comctl32.dll */
55 extern LPVOID WINAPI Alloc(INT);
56 extern BOOL WINAPI Free(LPVOID);
58 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl);
59 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl);
61 /*************************************************************************
62 * ILGetDisplayNameExA
64 * Retrieves the display name of an ItemIDList
66 * PARAMS
67 * psf [I] Shell Folder to start with, if NULL the desktop is used
68 * pidl [I] ItemIDList relative to the psf to get the display name for
69 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
70 * type [I] Type of display name to retrieve
71 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
72 * 1 = SHGDN_NORMAL relative to the root folder
73 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
75 * RETURNS
76 * True if the display name could be retrieved successfully, False otherwise
78 static BOOL ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
80 BOOL ret = FALSE;
81 WCHAR wPath[MAX_PATH];
83 TRACE("%p %p %p %d\n", psf, pidl, path, type);
85 if (!pidl || !path)
86 return FALSE;
88 ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
89 WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
90 TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
92 return ret;
95 BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
97 LPSHELLFOLDER psfParent, lsf = psf;
98 HRESULT ret = NO_ERROR;
99 LPCITEMIDLIST pidllast;
100 STRRET strret;
101 DWORD flag;
103 TRACE("%p %p %p %x\n", psf, pidl, path, type);
105 if (!pidl || !path)
106 return FALSE;
108 if (!lsf)
110 ret = SHGetDesktopFolder(&lsf);
111 if (FAILED(ret))
112 return FALSE;
115 switch (type)
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 = %x\n", type);
128 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
129 break;
132 if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
134 ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
135 if (SUCCEEDED(ret))
137 if(!StrRetToStrNW(path, MAX_PATH, &strret, pidl))
138 ret = E_FAIL;
141 else
143 ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
144 if (SUCCEEDED(ret))
146 ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
147 if (SUCCEEDED(ret))
149 if(!StrRetToStrNW(path, MAX_PATH, &strret, pidllast))
150 ret = E_FAIL;
152 IShellFolder_Release(psfParent);
156 TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
158 if (!psf)
159 IShellFolder_Release(lsf);
160 return SUCCEEDED(ret);
163 /*************************************************************************
164 * ILGetDisplayNameEx [SHELL32.186]
166 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
168 TRACE_(shell)("%p %p %p %d\n", psf, pidl, path, type);
170 if (SHELL_OsIsUnicode())
171 return ILGetDisplayNameExW(psf, pidl, path, type);
172 return ILGetDisplayNameExA(psf, pidl, path, type);
175 /*************************************************************************
176 * ILGetDisplayName [SHELL32.15]
178 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
180 TRACE_(shell)("%p %p\n", pidl, path);
182 if (SHELL_OsIsUnicode())
183 return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
184 return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
187 /*************************************************************************
188 * ILFindLastID [SHELL32.16]
190 * NOTES
191 * observed: pidl=Desktop return=pidl
193 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
195 LPCITEMIDLIST pidlLast = pidl;
197 TRACE("(pidl=%p)\n",pidl);
199 if (!pidl)
200 return NULL;
202 while (pidl->mkid.cb)
204 pidlLast = pidl;
205 pidl = ILGetNext(pidl);
207 return (LPITEMIDLIST)pidlLast;
210 /*************************************************************************
211 * ILRemoveLastID [SHELL32.17]
213 * NOTES
214 * when pidl=Desktop return=FALSE
216 BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
218 TRACE_(shell)("pidl=%p\n",pidl);
220 if (!pidl || !pidl->mkid.cb)
221 return 0;
222 ILFindLastID(pidl)->mkid.cb = 0;
223 return 1;
226 /*************************************************************************
227 * ILClone [SHELL32.18]
229 * NOTES
230 * duplicate an idlist
232 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
234 DWORD len;
235 LPITEMIDLIST newpidl;
237 if (!pidl)
238 return NULL;
240 len = ILGetSize(pidl);
241 newpidl = SHAlloc(len);
242 if (newpidl)
243 memcpy(newpidl,pidl,len);
245 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
246 pdump(pidl);
248 return newpidl;
251 /*************************************************************************
252 * ILCloneFirst [SHELL32.19]
254 * NOTES
255 * duplicates the first idlist of a complex pidl
257 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
259 DWORD len;
260 LPITEMIDLIST pidlNew = NULL;
262 TRACE("pidl=%p\n", pidl);
263 pdump(pidl);
265 if (pidl)
267 len = pidl->mkid.cb;
268 pidlNew = SHAlloc(len+2);
269 if (pidlNew)
271 memcpy(pidlNew,pidl,len+2); /* 2 -> mind a desktop pidl */
273 if (len)
274 ILGetNext(pidlNew)->mkid.cb = 0x00;
277 TRACE("-- newpidl=%p\n",pidlNew);
279 return pidlNew;
282 /*************************************************************************
283 * ILLoadFromStream (SHELL32.26)
285 * NOTES
286 * the first two bytes are the len, the pidl is following then
288 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
290 WORD wLen = 0;
291 DWORD dwBytesRead;
292 HRESULT ret = E_FAIL;
295 TRACE_(shell)("%p %p\n", pStream , ppPidl);
297 SHFree(*ppPidl);
298 *ppPidl = NULL;
300 IStream_AddRef (pStream);
302 if (SUCCEEDED(IStream_Read(pStream, &wLen, 2, &dwBytesRead)))
304 TRACE("PIDL length is %d\n", wLen);
305 if (wLen != 0)
307 *ppPidl = SHAlloc (wLen);
308 if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
310 TRACE("Stream read OK\n");
311 ret = S_OK;
313 else
315 WARN("reading pidl failed\n");
316 SHFree(*ppPidl);
317 *ppPidl = NULL;
320 else
322 *ppPidl = NULL;
323 ret = S_OK;
327 /* we are not yet fully compatible */
328 if (*ppPidl && !pcheck(*ppPidl))
330 WARN("Check failed\n");
331 SHFree(*ppPidl);
332 *ppPidl = NULL;
335 IStream_Release (pStream);
336 TRACE("done\n");
337 return ret;
340 /*************************************************************************
341 * ILSaveToStream (SHELL32.27)
343 * NOTES
344 * the first two bytes are the len, the pidl is following then
346 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
348 WORD wLen = 0;
349 HRESULT ret = E_FAIL;
351 TRACE_(shell)("%p %p\n", pStream, pPidl);
353 IStream_AddRef (pStream);
355 wLen = ILGetSize(pPidl);
357 if (SUCCEEDED(IStream_Write(pStream, &wLen, 2, NULL)))
359 if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
360 ret = S_OK;
362 IStream_Release (pStream);
364 return ret;
367 /*************************************************************************
368 * SHILCreateFromPath [SHELL32.28]
370 * Create an ItemIDList from a path
372 * PARAMS
373 * path [I]
374 * ppidl [O]
375 * attributes [I/O] requested attributes on call and actual attributes when
376 * the function returns
378 * RETURNS
379 * NO_ERROR if successful, or an OLE errer code otherwise
381 * NOTES
382 * Wrapper for IShellFolder_ParseDisplayName().
384 static HRESULT SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
386 WCHAR lpszDisplayName[MAX_PATH];
388 TRACE_(shell)("%s %p 0x%08x\n", path, ppidl, attributes ? *attributes : 0);
390 if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
391 lpszDisplayName[MAX_PATH-1] = 0;
393 return SHILCreateFromPathW(lpszDisplayName, ppidl, attributes);
396 HRESULT SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
398 LPSHELLFOLDER sf;
399 DWORD pchEaten;
400 HRESULT ret = E_FAIL;
402 TRACE_(shell)("%s %p 0x%08x\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
404 if (SUCCEEDED (SHGetDesktopFolder(&sf)))
406 ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
407 IShellFolder_Release(sf);
409 return ret;
412 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
414 if ( SHELL_OsIsUnicode())
415 return SHILCreateFromPathW (path, ppidl, attributes);
416 return SHILCreateFromPathA (path, ppidl, attributes);
419 /*************************************************************************
420 * SHCloneSpecialIDList [SHELL32.89]
422 * Create an ItemIDList to one of the special folders.
424 * PARAMS
425 * hwndOwner [in]
426 * nFolder [in] CSIDL_xxxxx
427 * fCreate [in] Create folder if it does not exist
429 * RETURNS
430 * Success: The newly created pidl
431 * Failure: NULL, if inputs are invalid.
433 * NOTES
434 * exported by ordinal.
435 * Caller is responsible for deallocating the returned ItemIDList with the
436 * shells IMalloc interface, aka ILFree.
438 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
440 LPITEMIDLIST ppidl;
441 TRACE_(shell)("(hwnd=%p,csidl=0x%x,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
443 if (fCreate)
444 nFolder |= CSIDL_FLAG_CREATE;
446 SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
447 return ppidl;
450 /*************************************************************************
451 * ILGlobalClone [SHELL32.20]
453 * Clones an ItemIDList using Alloc.
455 * PARAMS
456 * pidl [I] ItemIDList to clone
458 * RETURNS
459 * Newly allocated ItemIDList.
461 * NOTES
462 * exported by ordinal.
464 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
466 DWORD len;
467 LPITEMIDLIST newpidl;
469 if (!pidl)
470 return NULL;
472 len = ILGetSize(pidl);
473 newpidl = Alloc(len);
474 if (newpidl)
475 memcpy(newpidl,pidl,len);
477 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
478 pdump(pidl);
480 return newpidl;
483 /*************************************************************************
484 * ILIsEqual [SHELL32.21]
487 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
489 char szData1[MAX_PATH];
490 char szData2[MAX_PATH];
492 LPCITEMIDLIST pidltemp1 = pidl1;
493 LPCITEMIDLIST pidltemp2 = pidl2;
495 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
498 * Explorer reads from registry directly (StreamMRU),
499 * so we can only check here
501 if (!pcheck(pidl1) || !pcheck (pidl2))
502 return FALSE;
504 pdump (pidl1);
505 pdump (pidl2);
507 if (!pidl1 || !pidl2)
508 return FALSE;
510 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
512 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
513 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
515 if (strcasecmp( szData1, szData2 ))
516 return FALSE;
518 pidltemp1 = ILGetNext(pidltemp1);
519 pidltemp2 = ILGetNext(pidltemp2);
522 if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
523 return TRUE;
525 return FALSE;
528 /*************************************************************************
529 * ILIsParent [SHELL32.23]
531 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
533 * PARAMS
534 * pidlParent [I]
535 * pidlChild [I]
536 * bImmediate [I] only return true if the parent is the direct parent
537 * of the child
539 * RETURNS
540 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
541 * False otherwise.
543 * NOTES
544 * parent = a/b, child = a/b/c -> true, c is in folder a/b
545 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
546 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
548 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
550 char szData1[MAX_PATH];
551 char szData2[MAX_PATH];
552 LPCITEMIDLIST pParent = pidlParent;
553 LPCITEMIDLIST pChild = pidlChild;
555 TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
557 if (!pParent || !pChild)
558 return FALSE;
560 while (pParent->mkid.cb && pChild->mkid.cb)
562 _ILSimpleGetText(pParent, szData1, MAX_PATH);
563 _ILSimpleGetText(pChild, szData2, MAX_PATH);
565 if (strcasecmp( szData1, szData2 ))
566 return FALSE;
568 pParent = ILGetNext(pParent);
569 pChild = ILGetNext(pChild);
572 /* child shorter or has equal length to parent */
573 if (pParent->mkid.cb || !pChild->mkid.cb)
574 return FALSE;
576 /* not immediate descent */
577 if ( ILGetNext(pChild)->mkid.cb && bImmediate)
578 return FALSE;
580 return TRUE;
583 /*************************************************************************
584 * ILFindChild [SHELL32.24]
586 * Compares elements from pidl1 and pidl2.
588 * PARAMS
589 * pidl1 [I]
590 * pidl2 [I]
592 * RETURNS
593 * pidl1 is desktop pidl2
594 * pidl1 shorter pidl2 pointer to first different element of pidl2
595 * if there was at least one equal element
596 * pidl2 shorter pidl1 0
597 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
599 * NOTES
600 * exported by ordinal.
602 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
604 char szData1[MAX_PATH];
605 char szData2[MAX_PATH];
607 LPCITEMIDLIST pidltemp1 = pidl1;
608 LPCITEMIDLIST pidltemp2 = pidl2;
609 LPCITEMIDLIST ret=NULL;
611 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
613 /* explorer reads from registry directly (StreamMRU),
614 so we can only check here */
615 if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
616 return FALSE;
618 pdump (pidl1);
619 pdump (pidl2);
621 if (_ILIsDesktop(pidl1))
623 ret = pidl2;
625 else
627 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
629 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
630 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
632 if (strcasecmp(szData1,szData2))
633 break;
635 pidltemp1 = ILGetNext(pidltemp1);
636 pidltemp2 = ILGetNext(pidltemp2);
637 ret = pidltemp2;
640 if (pidltemp1->mkid.cb)
641 ret = NULL; /* elements of pidl1 left*/
643 TRACE_(shell)("--- %p\n", ret);
644 return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
647 /*************************************************************************
648 * ILCombine [SHELL32.25]
650 * Concatenates two complex ItemIDLists.
652 * PARAMS
653 * pidl1 [I] first complex ItemIDLists
654 * pidl2 [I] complex ItemIDLists to append
656 * RETURNS
657 * if both pidl's == NULL NULL
658 * if pidl1 == NULL cloned pidl2
659 * if pidl2 == NULL cloned pidl1
660 * otherwise new pidl with pidl2 appended to pidl1
662 * NOTES
663 * exported by ordinal.
664 * Does not destroy the passed in ItemIDLists!
666 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
668 DWORD len1,len2;
669 LPITEMIDLIST pidlNew;
671 TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
673 if (!pidl1 && !pidl2) return NULL;
675 pdump (pidl1);
676 pdump (pidl2);
678 if (!pidl1)
680 pidlNew = ILClone(pidl2);
681 return pidlNew;
684 if (!pidl2)
686 pidlNew = ILClone(pidl1);
687 return pidlNew;
690 len1 = ILGetSize(pidl1)-2;
691 len2 = ILGetSize(pidl2);
692 pidlNew = SHAlloc(len1+len2);
694 if (pidlNew)
696 memcpy(pidlNew,pidl1,len1);
697 memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
700 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
701 return pidlNew;
704 /*************************************************************************
705 * SHGetRealIDL [SHELL32.98]
707 * NOTES
709 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
711 IDataObject* pDataObj;
712 HRESULT hr;
714 hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple,
715 &IID_IDataObject, 0, (LPVOID*)&pDataObj);
716 if (SUCCEEDED(hr))
718 STGMEDIUM medium;
719 FORMATETC fmt;
721 fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
722 fmt.ptd = NULL;
723 fmt.dwAspect = DVASPECT_CONTENT;
724 fmt.lindex = -1;
725 fmt.tymed = TYMED_HGLOBAL;
727 hr = IDataObject_GetData(pDataObj, &fmt, &medium);
729 IDataObject_Release(pDataObj);
731 if (SUCCEEDED(hr))
733 /*assert(pida->cidl==1);*/
734 LPIDA pida = GlobalLock(medium.u.hGlobal);
736 LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
737 LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
739 *pidlReal = ILCombine(pidl_folder, pidl_child);
741 if (!*pidlReal)
742 hr = E_OUTOFMEMORY;
744 GlobalUnlock(medium.u.hGlobal);
745 GlobalFree(medium.u.hGlobal);
749 return hr;
752 /*************************************************************************
753 * SHLogILFromFSIL [SHELL32.95]
755 * NOTES
756 * pild = CSIDL_DESKTOP ret = 0
757 * pild = CSIDL_DRIVES ret = 0
759 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
761 FIXME("(pidl=%p)\n",pidl);
763 pdump(pidl);
765 return 0;
768 /*************************************************************************
769 * ILGetSize [SHELL32.152]
771 * Gets the byte size of an ItemIDList including zero terminator
773 * PARAMS
774 * pidl [I] ItemIDList
776 * RETURNS
777 * size of pidl in bytes
779 * NOTES
780 * exported by ordinal
782 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
784 LPCSHITEMID si = &(pidl->mkid);
785 UINT len=0;
787 if (pidl)
789 while (si->cb)
791 len += si->cb;
792 si = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
794 len += 2;
796 TRACE("pidl=%p size=%u\n",pidl, len);
797 return len;
800 /*************************************************************************
801 * ILGetNext [SHELL32.153]
803 * Gets the next ItemID of an ItemIDList
805 * PARAMS
806 * pidl [I] ItemIDList
808 * RETURNS
809 * null -> null
810 * desktop -> null
811 * simple pidl -> pointer to 0x0000 element
813 * NOTES
814 * exported by ordinal.
816 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
818 WORD len;
820 TRACE("%p\n", pidl);
822 if (pidl)
824 len = pidl->mkid.cb;
825 if (len)
827 pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
828 TRACE("-- %p\n", pidl);
829 return (LPITEMIDLIST)pidl;
832 return NULL;
835 /*************************************************************************
836 * ILAppend [SHELL32.154]
838 * Adds the single ItemID item to the ItemIDList indicated by pidl.
839 * If bEnd is FALSE, inserts the item in the front of the list,
840 * otherwise it adds the item to the end. (???)
842 * PARAMS
843 * pidl [I] ItemIDList to extend
844 * item [I] ItemID to prepend/append
845 * bEnd [I] Indicates if the item should be appended
847 * NOTES
848 * Destroys the passed in idlist! (???)
850 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl, LPCITEMIDLIST item, BOOL bEnd)
852 LPITEMIDLIST idlRet;
854 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
856 pdump (pidl);
857 pdump (item);
859 if (_ILIsDesktop(pidl))
861 idlRet = ILClone(item);
862 SHFree (pidl);
863 return idlRet;
866 if (bEnd)
867 idlRet = ILCombine(pidl, item);
868 else
869 idlRet = ILCombine(item, pidl);
871 SHFree(pidl);
872 return idlRet;
875 /*************************************************************************
876 * ILFree [SHELL32.155]
878 * Frees memory (if not NULL) allocated by SHMalloc allocator
880 * PARAMS
881 * pidl [I]
883 * RETURNS
884 * Nothing
886 * NOTES
887 * exported by ordinal
889 void WINAPI ILFree(LPITEMIDLIST pidl)
891 TRACE("(pidl=%p)\n",pidl);
892 SHFree(pidl);
895 /*************************************************************************
896 * ILGlobalFree [SHELL32.156]
898 * Frees memory (if not NULL) allocated by Alloc allocator
900 * PARAMS
901 * pidl [I]
903 * RETURNS
904 * Nothing
906 * NOTES
907 * exported by ordinal.
909 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
911 TRACE("%p\n", pidl);
913 Free(pidl);
916 /*************************************************************************
917 * ILCreateFromPathA [SHELL32.189]
919 * Creates a complex ItemIDList from a path and returns it.
921 * PARAMS
922 * path [I]
924 * RETURNS
925 * the newly created complex ItemIDList or NULL if failed
927 * NOTES
928 * exported by ordinal.
930 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
932 LPITEMIDLIST pidlnew = NULL;
934 TRACE_(shell)("%s\n", debugstr_a(path));
936 if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
937 return pidlnew;
938 return NULL;
941 /*************************************************************************
942 * ILCreateFromPathW [SHELL32.190]
944 * See ILCreateFromPathA.
946 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
948 LPITEMIDLIST pidlnew = NULL;
950 TRACE_(shell)("%s\n", debugstr_w(path));
952 if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
953 return pidlnew;
954 return NULL;
957 /*************************************************************************
958 * ILCreateFromPath [SHELL32.157]
960 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
962 if ( SHELL_OsIsUnicode())
963 return ILCreateFromPathW (path);
964 return ILCreateFromPathA (path);
967 /*************************************************************************
968 * _ILParsePathW [internal]
970 * Creates an ItemIDList from a path and returns it.
972 * PARAMS
973 * path [I] path to parse and convert into an ItemIDList
974 * lpFindFile [I] pointer to buffer to initialize the FileSystem
975 * Bind Data object with
976 * bBindCtx [I] indicates to create a BindContext and assign a
977 * FileSystem Bind Data object
978 * ppidl [O] the newly create ItemIDList
979 * prgfInOut [I/O] requested attributes on input and actual
980 * attributes on return
982 * RETURNS
983 * NO_ERROR on success or an OLE error code
985 * NOTES
986 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
987 * creates a BindContext object and assigns a FileSystem Bind Data object
988 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
989 * IShellFolder uses that FileSystem Bind Data object of the BindContext
990 * to pass data about the current path element to the next object. This
991 * is used to avoid having to verify the current path element on disk, so
992 * that creating an ItemIDList from a nonexistent path still can work.
994 static HRESULT _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
995 BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
997 LPSHELLFOLDER pSF = NULL;
998 LPBC pBC = NULL;
999 HRESULT ret;
1001 TRACE("%s %p %d (%p)->%p (%p)->0x%x\n", debugstr_w(path), lpFindFile, bBindCtx,
1002 ppidl, ppidl ? *ppidl : NULL,
1003 prgfInOut, prgfInOut ? *prgfInOut : 0);
1005 ret = SHGetDesktopFolder(&pSF);
1006 if (FAILED(ret))
1007 return ret;
1009 if (lpFindFile || bBindCtx)
1010 ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1012 if (SUCCEEDED(ret))
1014 ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1017 if (pBC)
1019 IBindCtx_Release(pBC);
1020 pBC = NULL;
1023 IShellFolder_Release(pSF);
1025 if (FAILED(ret) && ppidl)
1026 *ppidl = NULL;
1028 TRACE("%s %p 0x%x\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1030 return ret;
1033 /*************************************************************************
1034 * SHSimpleIDListFromPath [SHELL32.162]
1036 * Creates a simple ItemIDList from a path and returns it. This function
1037 * does not fail on nonexistent paths.
1039 * PARAMS
1040 * path [I] path to parse and convert into an ItemIDList
1042 * RETURNS
1043 * the newly created simple ItemIDList
1045 * NOTES
1046 * Simple in the name does not mean a relative ItemIDList but rather a
1047 * fully qualified list, where only the file name is filled in and the
1048 * directory flag for those ItemID elements this is known about, eg.
1049 * it is not the last element in the ItemIDList or the actual directory
1050 * exists on disk.
1051 * exported by ordinal.
1053 LPITEMIDLIST SHSimpleIDListFromPathA(LPCSTR lpszPath)
1055 LPITEMIDLIST pidl = NULL;
1056 LPWSTR wPath = NULL;
1057 int len;
1059 TRACE("%s\n", debugstr_a(lpszPath));
1061 if (lpszPath)
1063 len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1064 wPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1065 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1068 _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1070 HeapFree(GetProcessHeap(), 0, wPath);
1071 TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1072 return pidl;
1075 LPITEMIDLIST SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1077 LPITEMIDLIST pidl = NULL;
1079 TRACE("%s\n", debugstr_w(lpszPath));
1081 _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1082 TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1083 return pidl;
1086 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1088 if ( SHELL_OsIsUnicode())
1089 return SHSimpleIDListFromPathW (lpszPath);
1090 return SHSimpleIDListFromPathA (lpszPath);
1093 /*************************************************************************
1094 * SHGetDataFromIDListA [SHELL32.247]
1096 * NOTES
1097 * the pidl can be a simple one. since we can't get the path out of the pidl
1098 * we have to take all data from the pidl
1100 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1101 int nFormat, LPVOID dest, int len)
1103 LPSTR filename, shortname;
1104 WIN32_FIND_DATAA * pfd;
1106 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1108 pdump(pidl);
1109 if (!psf || !dest)
1110 return E_INVALIDARG;
1112 switch (nFormat)
1114 case SHGDFIL_FINDDATA:
1115 pfd = dest;
1117 if (_ILIsDrive(pidl) || _ILIsSpecialFolder(pidl))
1118 return E_INVALIDARG;
1120 if (len < sizeof(WIN32_FIND_DATAA))
1121 return E_INVALIDARG;
1123 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1124 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1125 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1126 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1128 filename = _ILGetTextPointer(pidl);
1129 shortname = _ILGetSTextPointer(pidl);
1131 if (filename)
1132 lstrcpynA(pfd->cFileName, filename, sizeof(pfd->cFileName));
1133 else
1134 pfd->cFileName[0] = '\0';
1136 if (shortname)
1137 lstrcpynA(pfd->cAlternateFileName, shortname, sizeof(pfd->cAlternateFileName));
1138 else
1139 pfd->cAlternateFileName[0] = '\0';
1140 return NOERROR;
1142 case SHGDFIL_NETRESOURCE:
1143 case SHGDFIL_DESCRIPTIONID:
1144 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1145 break;
1147 default:
1148 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1151 return E_INVALIDARG;
1154 /*************************************************************************
1155 * SHGetDataFromIDListW [SHELL32.248]
1158 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1159 int nFormat, LPVOID dest, int len)
1161 LPSTR filename, shortname;
1162 WIN32_FIND_DATAW * pfd = dest;
1164 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1166 pdump(pidl);
1168 if (!psf || !dest)
1169 return E_INVALIDARG;
1171 switch (nFormat)
1173 case SHGDFIL_FINDDATA:
1174 pfd = dest;
1176 if (_ILIsDrive(pidl))
1177 return E_INVALIDARG;
1179 if (len < sizeof(WIN32_FIND_DATAW))
1180 return E_INVALIDARG;
1182 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1183 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1184 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1185 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1187 filename = _ILGetTextPointer(pidl);
1188 shortname = _ILGetSTextPointer(pidl);
1190 if (!filename)
1191 pfd->cFileName[0] = '\0';
1192 else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1193 pfd->cFileName[MAX_PATH-1] = 0;
1195 if (!shortname)
1196 pfd->cAlternateFileName[0] = '\0';
1197 else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1198 pfd->cAlternateFileName[13] = 0;
1199 return NOERROR;
1201 case SHGDFIL_NETRESOURCE:
1202 case SHGDFIL_DESCRIPTIONID:
1203 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1204 break;
1206 default:
1207 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1210 return E_INVALIDARG;
1213 /*************************************************************************
1214 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1216 * PARAMETERS
1217 * pidl, [IN] pidl
1218 * pszPath [OUT] path
1220 * RETURNS
1221 * path from a passed PIDL.
1223 * NOTES
1224 * NULL returns FALSE
1225 * desktop pidl gives path to desktop directory back
1226 * special pidls returning FALSE
1228 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1230 WCHAR wszPath[MAX_PATH];
1231 BOOL bSuccess;
1233 bSuccess = SHGetPathFromIDListW(pidl, wszPath);
1234 WideCharToMultiByte(CP_ACP, 0, wszPath, -1, pszPath, MAX_PATH, NULL, NULL);
1236 return bSuccess;
1239 /*************************************************************************
1240 * SHGetPathFromIDListW [SHELL32.@]
1242 * See SHGetPathFromIDListA.
1244 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1246 HRESULT hr;
1247 LPCITEMIDLIST pidlLast;
1248 LPSHELLFOLDER psfFolder;
1249 DWORD dwAttributes;
1250 STRRET strret;
1252 TRACE_(shell)("(pidl=%p,%p)\n", pidl, pszPath);
1253 pdump(pidl);
1255 *pszPath = '\0';
1256 if (!pidl)
1257 return FALSE;
1259 hr = SHBindToParent(pidl, &IID_IShellFolder, (VOID**)&psfFolder, &pidlLast);
1260 if (FAILED(hr)) return FALSE;
1262 dwAttributes = SFGAO_FILESYSTEM;
1263 hr = IShellFolder_GetAttributesOf(psfFolder, 1, &pidlLast, &dwAttributes);
1264 if (FAILED(hr) || !(dwAttributes & SFGAO_FILESYSTEM)) {
1265 IShellFolder_Release(psfFolder);
1266 return FALSE;
1269 hr = IShellFolder_GetDisplayNameOf(psfFolder, pidlLast, SHGDN_FORPARSING, &strret);
1270 IShellFolder_Release(psfFolder);
1271 if (FAILED(hr)) return FALSE;
1273 hr = StrRetToBufW(&strret, pidlLast, pszPath, MAX_PATH);
1275 TRACE_(shell)("-- %s, 0x%08x\n",debugstr_w(pszPath), hr);
1276 return SUCCEEDED(hr);
1279 /*************************************************************************
1280 * SHBindToParent [shell version 5.0]
1282 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1284 IShellFolder * psfDesktop;
1285 HRESULT hr=E_FAIL;
1287 TRACE_(shell)("pidl=%p\n", pidl);
1288 pdump(pidl);
1290 if (!pidl || !ppv)
1291 return E_INVALIDARG;
1293 *ppv = NULL;
1294 if (ppidlLast)
1295 *ppidlLast = NULL;
1297 hr = SHGetDesktopFolder(&psfDesktop);
1298 if (FAILED(hr))
1299 return hr;
1301 if (_ILIsPidlSimple(pidl))
1303 /* we are on desktop level */
1304 hr = IShellFolder_QueryInterface(psfDesktop, riid, ppv);
1306 else
1308 LPITEMIDLIST pidlParent = ILClone(pidl);
1309 ILRemoveLastID(pidlParent);
1310 hr = IShellFolder_BindToObject(psfDesktop, pidlParent, NULL, riid, ppv);
1311 SHFree (pidlParent);
1314 IShellFolder_Release(psfDesktop);
1316 if (SUCCEEDED(hr) && ppidlLast)
1317 *ppidlLast = ILFindLastID(pidl);
1319 TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08x\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1320 return hr;
1323 /*************************************************************************
1324 * SHParseDisplayName [SHELL32.@]
1326 HRESULT WINAPI SHParseDisplayName(LPCWSTR name, IBindCtx *bindctx, LPITEMIDLIST *pidlist,
1327 SFGAOF attr_in, SFGAOF *attr_out)
1329 IShellFolder *desktop;
1330 HRESULT hr;
1332 TRACE("%s %p %p %d %p\n", debugstr_w(name), bindctx, pidlist, attr_in, attr_out);
1334 *pidlist = NULL;
1336 if (!name) return E_INVALIDARG;
1338 hr = SHGetDesktopFolder(&desktop);
1339 if (hr != S_OK) return hr;
1341 hr = IShellFolder_ParseDisplayName(desktop, NULL, bindctx, (LPWSTR)name, NULL, pidlist, &attr_in);
1342 if (attr_out) *attr_out = attr_in;
1344 IShellFolder_Release(desktop);
1346 return hr;
1349 /**************************************************************************
1351 * internal functions
1353 * ### 1. section creating pidls ###
1355 *************************************************************************
1358 /* Basic PIDL constructor. Allocates size + 5 bytes, where:
1359 * - two bytes are SHITEMID.cb
1360 * - one byte is PIDLDATA.type
1361 * - two bytes are the NULL PIDL terminator
1362 * Sets type of the returned PIDL to type.
1364 static LPITEMIDLIST _ILAlloc(PIDLTYPE type, unsigned int size)
1366 LPITEMIDLIST pidlOut = NULL;
1368 pidlOut = SHAlloc(size + 5);
1369 if(pidlOut)
1371 LPPIDLDATA pData;
1372 LPITEMIDLIST pidlNext;
1374 ZeroMemory(pidlOut, size + 5);
1375 pidlOut->mkid.cb = size + 3;
1377 pData = _ILGetDataPointer(pidlOut);
1378 if (pData)
1379 pData->type = type;
1381 pidlNext = ILGetNext(pidlOut);
1382 if (pidlNext)
1383 pidlNext->mkid.cb = 0x00;
1384 TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1387 return pidlOut;
1390 LPITEMIDLIST _ILCreateDesktop(void)
1392 LPITEMIDLIST ret;
1394 TRACE("()\n");
1395 ret = SHAlloc(2);
1396 if (ret)
1397 ret->mkid.cb = 0;
1398 return ret;
1401 LPITEMIDLIST _ILCreateMyComputer(void)
1403 TRACE("()\n");
1404 return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1407 LPITEMIDLIST _ILCreateMyDocuments(void)
1409 TRACE("()\n");
1410 return _ILCreateGuid(PT_GUID, &CLSID_MyDocuments);
1413 LPITEMIDLIST _ILCreateIExplore(void)
1415 TRACE("()\n");
1416 return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1419 LPITEMIDLIST _ILCreateControlPanel(void)
1421 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1423 TRACE("()\n");
1424 if (parent)
1426 LPITEMIDLIST cpl = _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1428 if (cpl)
1430 ret = ILCombine(parent, cpl);
1431 SHFree(cpl);
1433 SHFree(parent);
1435 return ret;
1438 LPITEMIDLIST _ILCreatePrinters(void)
1440 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1442 TRACE("()\n");
1443 if (parent)
1445 LPITEMIDLIST printers = _ILCreateGuid(PT_YAGUID, &CLSID_Printers);
1447 if (printers)
1449 ret = ILCombine(parent, printers);
1450 SHFree(printers);
1452 SHFree(parent);
1454 return ret;
1457 LPITEMIDLIST _ILCreateNetwork(void)
1459 TRACE("()\n");
1460 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1463 LPITEMIDLIST _ILCreateBitBucket(void)
1465 TRACE("()\n");
1466 return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1469 LPITEMIDLIST _ILCreateNetHood(void)
1471 TRACE("()\n");
1472 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1475 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1477 LPITEMIDLIST pidlOut;
1479 if (type == PT_SHELLEXT || type == PT_GUID || type == PT_YAGUID)
1481 pidlOut = _ILAlloc(type, sizeof(GUIDStruct));
1482 if (pidlOut)
1484 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1486 pData->u.guid.guid = *guid;
1487 TRACE("-- create GUID-pidl %s\n",
1488 debugstr_guid(&(pData->u.guid.guid)));
1491 else
1493 WARN("%d: invalid type for GUID\n", type);
1494 pidlOut = NULL;
1496 return pidlOut;
1499 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1501 IID iid;
1503 if (FAILED(SHCLSIDFromStringA(szGUID, &iid)))
1505 ERR("%s is not a GUID\n", szGUID);
1506 return NULL;
1508 return _ILCreateGuid(PT_GUID, &iid);
1511 LPITEMIDLIST _ILCreateGuidFromStrW(LPCWSTR szGUID)
1513 IID iid;
1515 if (FAILED(SHCLSIDFromStringW(szGUID, &iid)))
1517 ERR("%s is not a GUID\n", debugstr_w(szGUID));
1518 return NULL;
1520 return _ILCreateGuid(PT_GUID, &iid);
1523 LPITEMIDLIST _ILCreateFromFindDataW( const WIN32_FIND_DATAW *wfd )
1525 char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1526 DWORD len, len1, wlen, alen;
1527 LPITEMIDLIST pidl;
1528 PIDLTYPE type;
1530 if (!wfd)
1531 return NULL;
1533 TRACE("(%s, %s)\n",debugstr_w(wfd->cAlternateFileName), debugstr_w(wfd->cFileName));
1535 /* prepare buffer with both names */
1536 len = WideCharToMultiByte(CP_ACP,0,wfd->cFileName,-1,buff,MAX_PATH,NULL,NULL);
1537 len1 = WideCharToMultiByte(CP_ACP,0,wfd->cAlternateFileName,-1, buff+len, sizeof(buff)-len, NULL, NULL);
1538 alen = len + len1;
1540 type = (wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
1542 wlen = lstrlenW(wfd->cFileName) + 1;
1543 pidl = _ILAlloc(type, FIELD_OFFSET(FileStruct, szNames[alen + (alen & 1)]) +
1544 FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD));
1545 if (pidl)
1547 LPPIDLDATA pData = _ILGetDataPointer(pidl);
1548 FileStruct *fs = &pData->u.file;
1549 FileStructW *fsw;
1550 WORD *pOffsetW;
1552 FileTimeToDosDateTime( &wfd->ftLastWriteTime, &fs->uFileDate, &fs->uFileTime);
1553 fs->dwFileSize = wfd->nFileSizeLow;
1554 fs->uFileAttribs = wfd->dwFileAttributes;
1555 memcpy(fs->szNames, buff, alen);
1557 fsw = (FileStructW*)(pData->u.file.szNames + alen + (alen & 0x1));
1558 fsw->cbLen = FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD);
1559 FileTimeToDosDateTime( &wfd->ftCreationTime, &fsw->uCreationDate, &fsw->uCreationTime);
1560 FileTimeToDosDateTime( &wfd->ftLastAccessTime, &fsw->uLastAccessDate, &fsw->uLastAccessTime);
1561 memcpy(fsw->wszName, wfd->cFileName, wlen * sizeof(WCHAR));
1563 pOffsetW = (WORD*)((LPBYTE)pidl + pidl->mkid.cb - sizeof(WORD));
1564 *pOffsetW = (LPBYTE)fsw - (LPBYTE)pidl;
1565 TRACE("-- Set Value: %s\n",debugstr_w(fsw->wszName));
1567 return pidl;
1571 HRESULT _ILCreateFromPathW(LPCWSTR szPath, LPITEMIDLIST* ppidl)
1573 HANDLE hFile;
1574 WIN32_FIND_DATAW stffile;
1576 if (!ppidl)
1577 return E_INVALIDARG;
1579 hFile = FindFirstFileW(szPath, &stffile);
1580 if (hFile == INVALID_HANDLE_VALUE)
1581 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1583 FindClose(hFile);
1585 *ppidl = _ILCreateFromFindDataW(&stffile);
1587 return *ppidl ? S_OK : E_OUTOFMEMORY;
1590 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
1592 LPITEMIDLIST pidlOut;
1594 TRACE("(%s)\n",debugstr_w(lpszNew));
1596 pidlOut = _ILAlloc(PT_DRIVE, sizeof(DriveStruct));
1597 if (pidlOut)
1599 LPSTR pszDest;
1601 pszDest = _ILGetTextPointer(pidlOut);
1602 if (pszDest)
1604 strcpy(pszDest, "x:\\");
1605 pszDest[0]=toupperW(lpszNew[0]);
1606 TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1609 return pidlOut;
1612 LPITEMIDLIST _ILCreateEntireNetwork(void)
1614 LPITEMIDLIST pidlOut;
1616 TRACE("\n");
1618 pidlOut = _ILAlloc(PT_NETWORK, FIELD_OFFSET(PIDLDATA, u.network.szNames[sizeof("Entire Network")]));
1619 if (pidlOut)
1621 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1623 pData->u.network.dummy = 0;
1624 strcpy(pData->u.network.szNames, "Entire Network");
1626 return pidlOut;
1629 /**************************************************************************
1630 * _ILGetDrive()
1632 * Gets the text for the drive eg. 'c:\'
1634 * RETURNS
1635 * strlen (lpszText)
1637 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1639 TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1641 if(_ILIsMyComputer(pidl))
1642 pidl = ILGetNext(pidl);
1644 if (pidl && _ILIsDrive(pidl))
1645 return _ILSimpleGetText(pidl, pOut, uSize);
1647 return 0;
1650 /**************************************************************************
1652 * ### 2. section testing pidls ###
1654 **************************************************************************
1655 * _ILIsUnicode()
1656 * _ILIsDesktop()
1657 * _ILIsMyComputer()
1658 * _ILIsSpecialFolder()
1659 * _ILIsDrive()
1660 * _ILIsFolder()
1661 * _ILIsValue()
1662 * _ILIsPidlSimple()
1664 BOOL _ILIsUnicode(LPCITEMIDLIST pidl)
1666 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1668 TRACE("(%p)\n",pidl);
1670 return (pidl && lpPData && PT_VALUEW == lpPData->type);
1673 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1675 TRACE("(%p)\n",pidl);
1677 return pidl && pidl->mkid.cb ? 0 : 1;
1680 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1682 REFIID iid = _ILGetGUIDPointer(pidl);
1684 TRACE("(%p)\n",pidl);
1686 if (iid)
1687 return IsEqualIID(iid, &CLSID_MyComputer);
1688 return FALSE;
1691 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1693 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1695 TRACE("(%p)\n",pidl);
1697 return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type || PT_YAGUID == lpPData->type)) ||
1698 (pidl && pidl->mkid.cb == 0x00)
1702 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1704 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1706 TRACE("(%p)\n",pidl);
1708 return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1709 PT_DRIVE1 == lpPData->type ||
1710 PT_DRIVE2 == lpPData->type ||
1711 PT_DRIVE3 == lpPData->type));
1714 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1716 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1718 TRACE("(%p)\n",pidl);
1720 return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1723 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1725 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1727 TRACE("(%p)\n",pidl);
1729 return (pidl && lpPData && PT_VALUE == lpPData->type);
1732 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1734 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1736 TRACE("(%p)\n",pidl);
1738 return (pidl && lpPData && (lpPData->type == 0));
1741 /**************************************************************************
1742 * _ILIsPidlSimple
1744 BOOL _ILIsPidlSimple(LPCITEMIDLIST pidl)
1746 BOOL ret = TRUE;
1748 if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1750 WORD len = pidl->mkid.cb;
1751 LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
1753 if (pidlnext->mkid.cb)
1754 ret = FALSE;
1757 TRACE("%s\n", ret ? "Yes" : "No");
1758 return ret;
1761 /**************************************************************************
1763 * ### 3. section getting values from pidls ###
1766 /**************************************************************************
1767 * _ILSimpleGetText
1769 * gets the text for the first item in the pidl (eg. simple pidl)
1771 * returns the length of the string
1773 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1775 DWORD dwReturn=0;
1776 LPSTR szSrc;
1777 LPWSTR szSrcW;
1778 GUID const * riid;
1779 char szTemp[MAX_PATH];
1781 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1783 if (!pidl)
1784 return 0;
1786 if (szOut)
1787 *szOut = 0;
1789 if (_ILIsDesktop(pidl))
1791 /* desktop */
1792 if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1794 if (szOut)
1795 lstrcpynA(szOut, szTemp, uOutSize);
1797 dwReturn = strlen (szTemp);
1800 else if (( szSrc = _ILGetTextPointer(pidl) ))
1802 /* filesystem */
1803 if (szOut)
1804 lstrcpynA(szOut, szSrc, uOutSize);
1806 dwReturn = strlen(szSrc);
1808 else if (( szSrcW = _ILGetTextPointerW(pidl) ))
1810 /* unicode filesystem */
1811 WideCharToMultiByte(CP_ACP,0,szSrcW, -1, szTemp, MAX_PATH, NULL, NULL);
1813 if (szOut)
1814 lstrcpynA(szOut, szTemp, uOutSize);
1816 dwReturn = strlen (szTemp);
1818 else if (( riid = _ILGetGUIDPointer(pidl) ))
1820 /* special folder */
1821 if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1823 if (szOut)
1824 lstrcpynA(szOut, szTemp, uOutSize);
1826 dwReturn = strlen (szTemp);
1829 else
1831 ERR("-- no text\n");
1834 TRACE("-- (%p=%s 0x%08x)\n",szOut,debugstr_a(szOut),dwReturn);
1835 return dwReturn;
1838 /**************************************************************************
1839 * _ILSimpleGetTextW
1841 * gets the text for the first item in the pidl (eg. simple pidl)
1843 * returns the length of the string
1845 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
1847 DWORD dwReturn;
1848 FileStructW *pFileStructW = _ILGetFileStructW(pidl);
1850 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1852 if (pFileStructW) {
1853 lstrcpynW(szOut, pFileStructW->wszName, uOutSize);
1854 dwReturn = lstrlenW(pFileStructW->wszName);
1855 } else {
1856 GUID const * riid;
1857 WCHAR szTemp[MAX_PATH];
1858 LPSTR szSrc;
1859 LPWSTR szSrcW;
1860 dwReturn=0;
1862 if (!pidl)
1863 return 0;
1865 if (szOut)
1866 *szOut = 0;
1868 if (_ILIsDesktop(pidl))
1870 /* desktop */
1871 if (HCR_GetClassNameW(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1873 if (szOut)
1874 lstrcpynW(szOut, szTemp, uOutSize);
1876 dwReturn = lstrlenW (szTemp);
1879 else if (( szSrcW = _ILGetTextPointerW(pidl) ))
1881 /* unicode filesystem */
1882 if (szOut)
1883 lstrcpynW(szOut, szSrcW, uOutSize);
1885 dwReturn = lstrlenW(szSrcW);
1887 else if (( szSrc = _ILGetTextPointer(pidl) ))
1889 /* filesystem */
1890 MultiByteToWideChar(CP_ACP, 0, szSrc, -1, szTemp, MAX_PATH);
1892 if (szOut)
1893 lstrcpynW(szOut, szTemp, uOutSize);
1895 dwReturn = lstrlenW (szTemp);
1897 else if (( riid = _ILGetGUIDPointer(pidl) ))
1899 /* special folder */
1900 if ( HCR_GetClassNameW(riid, szTemp, MAX_PATH) )
1902 if (szOut)
1903 lstrcpynW(szOut, szTemp, uOutSize);
1905 dwReturn = lstrlenW (szTemp);
1908 else
1910 ERR("-- no text\n");
1914 TRACE("-- (%p=%s 0x%08x)\n",szOut,debugstr_w(szOut),dwReturn);
1915 return dwReturn;
1918 /**************************************************************************
1920 * ### 4. getting pointers to parts of pidls ###
1922 **************************************************************************
1923 * _ILGetDataPointer()
1925 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
1927 if(pidl && pidl->mkid.cb != 0x00)
1928 return (LPPIDLDATA)pidl->mkid.abID;
1929 return NULL;
1932 /**************************************************************************
1933 * _ILGetTextPointerW()
1934 * gets a pointer to the unicode long filename string stored in the pidl
1936 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl)
1938 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
1940 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1942 if (!pdata)
1943 return NULL;
1945 switch (pdata->type)
1947 case PT_GUID:
1948 case PT_SHELLEXT:
1949 case PT_YAGUID:
1950 return NULL;
1952 case PT_DRIVE:
1953 case PT_DRIVE1:
1954 case PT_DRIVE2:
1955 case PT_DRIVE3:
1956 /*return (LPSTR)&(pdata->u.drive.szDriveName);*/
1957 return NULL;
1959 case PT_FOLDER:
1960 case PT_FOLDER1:
1961 case PT_VALUE:
1962 case PT_IESPECIAL1:
1963 case PT_IESPECIAL2:
1964 /*return (LPSTR)&(pdata->u.file.szNames);*/
1965 return NULL;
1967 case PT_WORKGRP:
1968 case PT_COMP:
1969 case PT_NETWORK:
1970 case PT_NETPROVIDER:
1971 case PT_SHARE:
1972 /*return (LPSTR)&(pdata->u.network.szNames);*/
1973 return NULL;
1975 case PT_VALUEW:
1976 return (LPWSTR)pdata->u.file.szNames;
1978 return NULL;
1982 /**************************************************************************
1983 * _ILGetTextPointer()
1984 * gets a pointer to the long filename string stored in the pidl
1986 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
1988 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
1990 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1992 if (!pdata)
1993 return NULL;
1995 switch (pdata->type)
1997 case PT_GUID:
1998 case PT_SHELLEXT:
1999 case PT_YAGUID:
2000 return NULL;
2002 case PT_DRIVE:
2003 case PT_DRIVE1:
2004 case PT_DRIVE2:
2005 case PT_DRIVE3:
2006 return pdata->u.drive.szDriveName;
2008 case PT_FOLDER:
2009 case PT_FOLDER1:
2010 case PT_VALUE:
2011 case PT_IESPECIAL1:
2012 case PT_IESPECIAL2:
2013 return pdata->u.file.szNames;
2015 case PT_WORKGRP:
2016 case PT_COMP:
2017 case PT_NETWORK:
2018 case PT_NETPROVIDER:
2019 case PT_SHARE:
2020 return pdata->u.network.szNames;
2022 return NULL;
2025 /**************************************************************************
2026 * _ILGetSTextPointer()
2027 * gets a pointer to the short filename string stored in the pidl
2029 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
2031 /* TRACE(pidl,"(pidl%p)\n", pidl); */
2033 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2035 if (!pdata)
2036 return NULL;
2038 switch (pdata->type)
2040 case PT_FOLDER:
2041 case PT_VALUE:
2042 case PT_IESPECIAL1:
2043 case PT_IESPECIAL2:
2044 return pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1;
2046 case PT_WORKGRP:
2047 return pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1;
2049 return NULL;
2052 /**************************************************************************
2053 * _ILGetGUIDPointer()
2055 * returns reference to guid stored in some pidls
2057 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
2059 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2061 TRACE("%p\n", pidl);
2063 if (!pdata)
2064 return NULL;
2066 TRACE("pdata->type 0x%04x\n", pdata->type);
2067 switch (pdata->type)
2069 case PT_SHELLEXT:
2070 case PT_GUID:
2071 case PT_YAGUID:
2072 return &(pdata->u.guid.guid);
2074 default:
2075 TRACE("Unknown pidl type 0x%04x\n", pdata->type);
2076 break;
2078 return NULL;
2081 /******************************************************************************
2082 * _ILGetFileStructW [Internal]
2084 * Get pointer the a SHITEMID's FileStructW field if present
2086 * PARAMS
2087 * pidl [I] The SHITEMID
2089 * RETURNS
2090 * Success: Pointer to pidl's FileStructW field.
2091 * Failure: NULL
2093 FileStructW* _ILGetFileStructW(LPCITEMIDLIST pidl) {
2094 FileStructW *pFileStructW;
2095 WORD cbOffset;
2097 if (!(_ILIsValue(pidl) || _ILIsFolder(pidl)))
2098 return NULL;
2100 cbOffset = *(const WORD *)((const BYTE *)pidl + pidl->mkid.cb - sizeof(WORD));
2101 pFileStructW = (FileStructW*)((LPBYTE)pidl + cbOffset);
2103 /* Currently I don't see a fool prove way to figure out if a pidl is for sure of WinXP
2104 * style with a FileStructW member. If we switch all our shellfolder-implementations to
2105 * the new format, this won't be a problem. For now, we do as many sanity checks as possible. */
2106 if (cbOffset & 0x1 || /* FileStructW member is word aligned in the pidl */
2107 /* FileStructW is positioned after FileStruct */
2108 cbOffset < sizeof(pidl->mkid.cb) + sizeof(PIDLTYPE) + sizeof(FileStruct) ||
2109 /* There has to be enough space at cbOffset in the pidl to hold FileStructW and cbOffset */
2110 cbOffset > pidl->mkid.cb - sizeof(cbOffset) - sizeof(FileStructW) ||
2111 pidl->mkid.cb != cbOffset + pFileStructW->cbLen)
2113 WARN("Invalid pidl format (cbOffset = %d)!\n", cbOffset);
2114 return NULL;
2117 return pFileStructW;
2120 /*************************************************************************
2121 * _ILGetFileDateTime
2123 * Given the ItemIdList, get the FileTime
2125 * PARAMS
2126 * pidl [I] The ItemIDList
2127 * pFt [I] the resulted FILETIME of the file
2129 * RETURNS
2130 * True if Successful
2132 * NOTES
2135 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
2137 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2139 if (!pdata)
2140 return FALSE;
2142 switch (pdata->type)
2144 case PT_FOLDER:
2145 case PT_VALUE:
2146 DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
2147 break;
2148 default:
2149 return FALSE;
2151 return TRUE;
2154 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2156 FILETIME ft,lft;
2157 SYSTEMTIME time;
2158 BOOL ret;
2160 if (_ILGetFileDateTime( pidl, &ft ))
2162 FileTimeToLocalFileTime(&ft, &lft);
2163 FileTimeToSystemTime (&lft, &time);
2165 ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize);
2166 if (ret)
2168 /* Append space + time without seconds */
2169 pOut[ret-1] = ' ';
2170 GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &pOut[ret], uOutSize - ret);
2173 else
2175 pOut[0] = '\0';
2176 ret = FALSE;
2178 return ret;
2181 /*************************************************************************
2182 * _ILGetFileSize
2184 * Given the ItemIdList, get the FileSize
2186 * PARAMS
2187 * pidl [I] The ItemIDList
2188 * pOut [I] The buffer to save the result
2189 * uOutsize [I] The size of the buffer
2191 * RETURNS
2192 * The FileSize
2194 * NOTES
2195 * pOut can be null when no string is needed
2198 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2200 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2201 DWORD dwSize;
2203 if (!pdata)
2204 return 0;
2206 switch (pdata->type)
2208 case PT_VALUE:
2209 dwSize = pdata->u.file.dwFileSize;
2210 if (pOut)
2211 StrFormatKBSizeA(dwSize, pOut, uOutSize);
2212 return dwSize;
2214 if (pOut)
2215 *pOut = 0x00;
2216 return 0;
2219 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2221 char szTemp[MAX_PATH];
2222 const char * pPoint;
2223 LPCITEMIDLIST pidlTemp=pidl;
2225 TRACE("pidl=%p\n",pidl);
2227 if (!pidl)
2228 return FALSE;
2230 pidlTemp = ILFindLastID(pidl);
2232 if (!_ILIsValue(pidlTemp))
2233 return FALSE;
2234 if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
2235 return FALSE;
2237 pPoint = PathFindExtensionA(szTemp);
2239 if (!*pPoint)
2240 return FALSE;
2242 pPoint++;
2243 lstrcpynA(pOut, pPoint, uOutSize);
2244 TRACE("%s\n",pOut);
2246 return TRUE;
2249 /*************************************************************************
2250 * _ILGetFileType
2252 * Given the ItemIdList, get the file type description
2254 * PARAMS
2255 * pidl [I] The ItemIDList (simple)
2256 * pOut [I] The buffer to save the result
2257 * uOutsize [I] The size of the buffer
2259 * RETURNS
2260 * nothing
2262 * NOTES
2263 * This function copies as much as possible into the buffer.
2265 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2267 if(_ILIsValue(pidl))
2269 char sTemp[64];
2271 if(uOutSize > 0)
2272 pOut[0] = 0;
2273 if (_ILGetExtension (pidl, sTemp, 64))
2275 if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2276 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
2278 lstrcpynA (pOut, sTemp, uOutSize - 6);
2279 strcat (pOut, "-file");
2283 else
2284 lstrcpynA(pOut, "Folder", uOutSize);
2287 /*************************************************************************
2288 * _ILGetFileAttributes
2290 * Given the ItemIdList, get the Attrib string format
2292 * PARAMS
2293 * pidl [I] The ItemIDList
2294 * pOut [I] The buffer to save the result
2295 * uOutsize [I] The size of the Buffer
2297 * RETURNS
2298 * Attributes
2300 * FIXME
2301 * return value 0 in case of error is a valid return value
2304 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2306 LPPIDLDATA pData = _ILGetDataPointer(pidl);
2307 WORD wAttrib = 0;
2308 int i;
2310 if (!pData)
2311 return 0;
2313 switch(pData->type)
2315 case PT_FOLDER:
2316 case PT_VALUE:
2317 wAttrib = pData->u.file.uFileAttribs;
2318 break;
2321 if(uOutSize >= 6)
2323 i=0;
2324 if(wAttrib & FILE_ATTRIBUTE_READONLY)
2325 pOut[i++] = 'R';
2326 if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2327 pOut[i++] = 'H';
2328 if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2329 pOut[i++] = 'S';
2330 if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2331 pOut[i++] = 'A';
2332 if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2333 pOut[i++] = 'C';
2334 pOut[i] = 0x00;
2336 return wAttrib;
2339 /*************************************************************************
2340 * ILFreeaPidl
2342 * free a aPidl struct
2344 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2346 UINT i;
2348 if (apidl)
2350 for (i = 0; i < cidl; i++)
2351 SHFree(apidl[i]);
2352 SHFree(apidl);
2356 /*************************************************************************
2357 * ILCopyaPidl
2359 * copies an aPidl struct
2361 LPITEMIDLIST* _ILCopyaPidl(const LPCITEMIDLIST * apidlsrc, UINT cidl)
2363 UINT i;
2364 LPITEMIDLIST *apidldest;
2366 apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
2367 if (!apidlsrc)
2368 return NULL;
2370 for (i = 0; i < cidl; i++)
2371 apidldest[i] = ILClone(apidlsrc[i]);
2373 return apidldest;
2376 /*************************************************************************
2377 * _ILCopyCidaToaPidl
2379 * creates aPidl from CIDA
2381 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, const CIDA * cida)
2383 UINT i;
2384 LPITEMIDLIST *dst;
2386 dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2387 if (!dst)
2388 return NULL;
2390 if (pidl)
2391 *pidl = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[0]]));
2393 for (i = 0; i < cida->cidl; i++)
2394 dst[i] = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[i + 1]]));
2396 return dst;