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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * a pidl == NULL means desktop and is legal
26 #include "wine/port.h"
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
42 #include "undocshell.h"
43 #include "shell32_main.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 /*************************************************************************
59 * ILGetDisplayNameEx [SHELL32.186]
61 * Retrieves the display name of an ItemIDList
64 * psf [I] Shell Folder to start with, if NULL the desktop is used
65 * pidl [I] ItemIDList relativ to the psf to get the display name for
66 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
67 * type [I] Type of display name to retrieve
68 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
69 * 1 = SHGDN_NORMAL relative to the root folder
70 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
73 * True if the display name could be retrieved successfully, False otherwise
75 BOOL WINAPI ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
78 WCHAR wPath[MAX_PATH];
80 TRACE("%p %p %p %ld\n", psf, pidl, path, type);
85 ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
86 WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
87 TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
92 BOOL WINAPI ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
94 LPSHELLFOLDER psfParent, lsf = psf;
95 HRESULT ret = NO_ERROR;
96 LPCITEMIDLIST pidllast;
100 TRACE("%p %p %p %ld\n", psf, pidl, path, type);
107 ret = SHGetDesktopFolder(&lsf);
112 if (type >= 0 && type <= 2)
116 case ILGDN_FORPARSING:
117 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
123 flag = SHGDN_INFOLDER;
126 FIXME("Unknown type parameter = %lx\n", type);
127 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
130 if (!*(LPWORD)pidl || type == ILGDN_FORPARSING)
132 ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
135 ret = StrRetToStrNW(path, MAX_PATH, &strret, pidl);
140 ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
143 ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
146 ret = StrRetToStrNW(path, MAX_PATH, &strret, pidllast);
148 IShellFolder_Release(psfParent);
153 TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
156 IShellFolder_Release(lsf);
157 return SUCCEEDED(ret);
160 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
162 TRACE_(shell)("%p %p %p %ld\n", psf, pidl, path, type);
163 if (SHELL_OsIsUnicode())
164 return ILGetDisplayNameExW(psf, pidl, path, type);
165 return ILGetDisplayNameExA(psf, pidl, path, type);
168 /*************************************************************************
169 * ILGetDisplayName [SHELL32.15]
171 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
173 TRACE_(shell)("%p %p\n", pidl, path);
174 if (SHELL_OsIsUnicode())
175 return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
176 return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
179 /*************************************************************************
180 * ILFindLastID [SHELL32.16]
183 * observed: pidl=Desktop return=pidl
185 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
187 LPCITEMIDLIST pidlLast = pidl;
189 TRACE("(pidl=%p)\n",pidl);
194 while (pidl->mkid.cb)
197 pidl = ILGetNext(pidl);
199 return (LPITEMIDLIST)pidlLast;
201 /*************************************************************************
202 * ILRemoveLastID [SHELL32.17]
205 * when pidl=Desktop return=FALSE
207 BOOL WINAPI ILRemoveLastID(LPCITEMIDLIST pidl)
209 TRACE_(shell)("pidl=%p\n",pidl);
211 if (!pidl || !pidl->mkid.cb)
213 ILFindLastID(pidl)->mkid.cb = 0;
217 /*************************************************************************
218 * ILClone [SHELL32.18]
221 * duplicate an idlist
223 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
225 LPITEMIDLIST newpidl;
230 len = ILGetSize(pidl);
231 newpidl = (LPITEMIDLIST)SHAlloc(len);
233 memcpy(newpidl,pidl,len);
235 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
240 /*************************************************************************
241 * ILCloneFirst [SHELL32.19]
244 * duplicates the first idlist of a complex pidl
246 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
248 LPITEMIDLIST pidlNew = NULL;
250 TRACE("pidl=%p \n",pidl);
256 pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
259 memcpy(pidlNew,pidl,len+2); /* 2 -> mind a desktop pidl */
262 ILGetNext(pidlNew)->mkid.cb = 0x00;
265 TRACE("-- newpidl=%p\n",pidlNew);
270 /*************************************************************************
271 * ILLoadFromStream (SHELL32.26)
274 * the first two bytes are the len, the pidl is following then
276 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
279 HRESULT ret = E_FAIL;
282 TRACE_(shell)("%p %p\n", pStream , ppPidl);
289 IStream_AddRef (pStream);
291 if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
293 TRACE("PIDL length is %d\n", wLen);
295 *ppPidl = SHAlloc (wLen);
296 if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead))) {
297 TRACE("Stream read OK\n");
300 WARN("reading pidl failed\n");
310 /* we are not yet fully compatible */
311 if (*ppPidl && !pcheck(*ppPidl))
313 WARN("Check failed\n");
319 IStream_Release (pStream);
324 /*************************************************************************
325 * ILSaveToStream (SHELL32.27)
328 * the first two bytes are the len, the pidl is following then
330 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
334 HRESULT ret = E_FAIL;
336 TRACE_(shell)("%p %p\n", pStream, pPidl);
338 IStream_AddRef (pStream);
341 while (pidl->mkid.cb)
343 wLen += sizeof(WORD) + pidl->mkid.cb;
344 pidl = ILGetNext(pidl);
347 if (SUCCEEDED(IStream_Write(pStream, (LPVOID)&wLen, 2, NULL)))
349 if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
353 IStream_Release (pStream);
358 /*************************************************************************
359 * SHILCreateFromPath [SHELL32.28]
361 * Create an ItemIDList from a path
366 * attributes [I/O] requested attributes on call and actual attributes when
367 * the function returns
370 * NO_ERROR if successful, or an OLE errer code otherwise
373 * Wrapper for IShellFolder_ParseDisplayName().
375 HRESULT WINAPI SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
378 WCHAR lpszDisplayName[MAX_PATH];
380 HRESULT ret = E_FAIL;
382 TRACE_(shell)("%s %p 0x%08lx\n", path, ppidl, attributes ? *attributes : 0);
384 if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
385 lpszDisplayName[MAX_PATH-1] = 0;
387 if (SUCCEEDED (SHGetDesktopFolder(&sf)))
389 ret = IShellFolder_ParseDisplayName(sf, 0, NULL, lpszDisplayName, &pchEaten, ppidl, attributes);
390 IShellFolder_Release(sf);
395 HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
399 HRESULT ret = E_FAIL;
401 TRACE_(shell)("%s %p 0x%08lx\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
403 if (SUCCEEDED (SHGetDesktopFolder(&sf)))
405 ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
406 IShellFolder_Release(sf);
411 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
413 if ( SHELL_OsIsUnicode())
414 return SHILCreateFromPathW (path, ppidl, attributes);
415 return SHILCreateFromPathA (path, ppidl, attributes);
418 /*************************************************************************
419 * SHCloneSpecialIDList [SHELL32.89]
421 * Create an ItemIDList to one of the special folders.
425 * nFolder [in] CSIDL_xxxxx
426 * fCreate [in] Create folder if it does not exist
429 * Success: The newly created pidl
430 * Failure: NULL, if inputs are invalid.
433 * exported by ordinal.
434 * Caller is responsible for deallocating the returned ItemIDList with the
435 * shells IMalloc interface, aka ILFree.
437 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
438 { LPITEMIDLIST ppidl;
439 TRACE_(shell)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
442 nFolder |= CSIDL_FLAG_CREATE;
444 SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
448 /*************************************************************************
449 * ILGlobalClone [SHELL32.20]
451 * Clones an ItemIDList using Alloc.
454 * pidl [I] ItemIDList to clone
457 * Newly allocated ItemIDList.
460 * exported by ordinal.
462 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
464 LPITEMIDLIST newpidl;
469 len = ILGetSize(pidl);
470 newpidl = (LPITEMIDLIST)Alloc(len);
472 memcpy(newpidl,pidl,len);
474 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
480 /*************************************************************************
481 * ILIsEqual [SHELL32.21]
484 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
486 char szData1[MAX_PATH];
487 char szData2[MAX_PATH];
489 LPCITEMIDLIST pidltemp1 = pidl1;
490 LPCITEMIDLIST pidltemp2 = pidl2;
492 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
494 /* explorer reads from registry directly (StreamMRU),
495 so we can only check here */
496 if ((!pcheck (pidl1)) || (!pcheck (pidl2))) return FALSE;
501 if ( (!pidl1) || (!pidl2) ) return FALSE;
503 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
505 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
506 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
508 if (strcasecmp ( szData1, szData2 )!=0 )
511 pidltemp1 = ILGetNext(pidltemp1);
512 pidltemp2 = ILGetNext(pidltemp2);
515 if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
522 /*************************************************************************
523 * ILIsParent [SHELL32.23]
525 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
530 * bImmediate [I] only return true if the parent is the direct parent
534 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
538 * parent = a/b, child = a/b/c -> true, c is in folder a/b
539 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
540 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
542 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
544 char szData1[MAX_PATH];
545 char szData2[MAX_PATH];
547 LPCITEMIDLIST pParent = pidlParent;
548 LPCITEMIDLIST pChild = pidlChild;
550 TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
552 if (!pParent || !pChild) return FALSE;
554 while (pParent->mkid.cb && pChild->mkid.cb)
556 _ILSimpleGetText(pParent, szData1, MAX_PATH);
557 _ILSimpleGetText(pChild, szData2, MAX_PATH);
559 if (strcasecmp ( szData1, szData2 )!=0 )
562 pParent = ILGetNext(pParent);
563 pChild = ILGetNext(pChild);
566 if ( pParent->mkid.cb || ! pChild->mkid.cb) /* child shorter or has equal length to parent */
569 if ( ILGetNext(pChild)->mkid.cb && bImmediate) /* not immediate descent */
575 /*************************************************************************
576 * ILFindChild [SHELL32.24]
578 * Compares elements from pidl1 and pidl2.
585 * pidl1 is desktop pidl2
586 * pidl1 shorter pidl2 pointer to first different element of pidl2
587 * if there was at least one equal element
588 * pidl2 shorter pidl1 0
589 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
592 * exported by ordinal.
594 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
596 char szData1[MAX_PATH];
597 char szData2[MAX_PATH];
599 LPCITEMIDLIST pidltemp1 = pidl1;
600 LPCITEMIDLIST pidltemp2 = pidl2;
601 LPCITEMIDLIST ret=NULL;
603 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
605 /* explorer reads from registry directly (StreamMRU),
606 so we can only check here */
607 if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
613 if ( _ILIsDesktop(pidl1) )
619 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
621 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
622 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
624 if (strcasecmp(szData1,szData2))
627 pidltemp1 = ILGetNext(pidltemp1);
628 pidltemp2 = ILGetNext(pidltemp2);
632 if (pidltemp1->mkid.cb)
634 ret = NULL; /* elements of pidl1 left*/
637 TRACE_(shell)("--- %p\n", ret);
638 return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
641 /*************************************************************************
642 * ILCombine [SHELL32.25]
644 * Concatenates two complex ItemIDLists.
647 * pidl1 [I] first complex ItemIDLists
648 * pidl2 [I] complex ItemIDLists to append
651 * if both pidl's == NULL NULL
652 * if pidl1 == NULL cloned pidl2
653 * if pidl2 == NULL cloned pidl1
654 * otherwise new pidl with pidl2 appended to pidl1
657 * exported by ordinal.
658 * Does not destroy the passed in ItemIDLists!
660 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
663 LPITEMIDLIST pidlNew;
665 TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
667 if(!pidl1 && !pidl2) return NULL;
674 pidlNew = ILClone(pidl2);
680 pidlNew = ILClone(pidl1);
684 len1 = ILGetSize(pidl1)-2;
685 len2 = ILGetSize(pidl2);
686 pidlNew = SHAlloc(len1+len2);
690 memcpy(pidlNew,pidl1,len1);
691 memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
694 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
698 /*************************************************************************
699 * SHGetRealIDL [SHELL32.98]
703 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
705 IDataObject* pDataObj;
706 HRESULT hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple, &IID_IDataObject, 0, (LPVOID*)&pDataObj);
712 fmt.cfFormat = RegisterClipboardFormatA(CFSTR_SHELLIDLIST);
714 fmt.dwAspect = DVASPECT_CONTENT;
716 fmt.tymed = TYMED_HGLOBAL;
718 hr = IDataObject_GetData(pDataObj, &fmt, &medium);
720 IDataObject_Release(pDataObj);
723 /*assert(pida->cidl==1);*/
724 LPIDA pida = (LPIDA)GlobalLock(medium.u.hGlobal);
726 LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
727 LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
729 *pidlReal = ILCombine(pidl_folder, pidl_child);
734 GlobalUnlock(medium.u.hGlobal);
735 GlobalFree(medium.u.hGlobal);
742 /*************************************************************************
743 * SHLogILFromFSIL [SHELL32.95]
746 * pild = CSIDL_DESKTOP ret = 0
747 * pild = CSIDL_DRIVES ret = 0
749 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
751 FIXME("(pidl=%p)\n",pidl);
758 /*************************************************************************
759 * ILGetSize [SHELL32.152]
761 * Gets the byte size of an ItemIDList including zero terminator
764 * pidl [I] ItemIDList
767 * size of pidl in bytes
770 * exported by ordinal
772 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
774 LPCSHITEMID si = &(pidl->mkid);
780 si = (LPSHITEMID)(((LPBYTE)si)+si->cb);
784 TRACE("pidl=%p size=%u\n",pidl, len);
788 /*************************************************************************
789 * ILGetNext [SHELL32.153]
791 * Gets the next ItemID of an ItemIDList
794 * pidl [I] ItemIDList
799 * simple pidl -> pointer to 0x0000 element
802 * exported by ordinal.
804 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
815 pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
816 TRACE("-- %p\n", pidl);
817 return (LPITEMIDLIST)pidl;
823 /*************************************************************************
824 * ILAppend [SHELL32.154]
826 * Adds the single ItemID item to the ItemIDList indicated by pidl.
827 * If bEnd is FALSE, inserts the item in the front of the list,
828 * otherwise it adds the item to the end. (???)
831 * pidl [I] ItemIDList to extend
832 * item [I] ItemID to prepend/append
833 * bEnd [I] Indicates if the item should be appended
836 * Destroys the passed in idlist! (???)
838 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl, LPCITEMIDLIST item, BOOL bEnd)
842 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
847 if (_ILIsDesktop(pidl))
849 idlRet = ILClone(item);
857 idlRet = ILCombine(pidl, item);
861 idlRet = ILCombine(item, pidl);
868 /*************************************************************************
869 * ILFree [SHELL32.155]
871 * Frees memory (if not NULL) allocated by SHMalloc allocator
877 * exported by ordinal
879 void WINAPI ILFree(LPITEMIDLIST pidl)
881 TRACE("(pidl=%p)\n",pidl);
882 if(pidl) SHFree(pidl);
885 /*************************************************************************
886 * ILGlobalFree [SHELL32.156]
888 * Frees memory (if not NULL) allocated by Alloc allocator
894 * exported by ordinal.
896 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
904 /*************************************************************************
905 * ILCreateFromPathA [SHELL32.189]
907 * Creates a complex ItemIDList from a path and returns it.
913 * the newly created complex ItemIDList or NULL if failed
916 * exported by ordinal.
919 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
921 LPITEMIDLIST pidlnew = NULL;
923 TRACE_(shell)("%s\n", debugstr_a(path));
925 if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
930 /*************************************************************************
931 * ILCreateFromPathW [SHELL32.190]
933 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
935 LPITEMIDLIST pidlnew = NULL;
937 TRACE_(shell)("%s\n", debugstr_w(path));
939 if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
944 /*************************************************************************
945 * ILCreateFromPath [SHELL32.157]
947 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
949 if ( SHELL_OsIsUnicode())
950 return ILCreateFromPathW (path);
951 return ILCreateFromPathA (path);
954 /*************************************************************************
955 * _ILParsePathW [internal]
957 * Creates an ItemIDList from a path and returns it.
960 * path [I] path to parse and convert into an ItemIDList
961 * lpFindFile [I] pointer to buffer to initialize the FileSystem
962 * Bind Data object with
963 * bBindCtx [I] indicates to create a BindContext and assign a
964 * FileSystem Bind Data object
965 * ppidl [O] the newly create ItemIDList
966 * prgfInOut [I/O] requested attributes on input and actual
967 * attributes on return
970 * NO_ERROR on success or an OLE error code
973 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
974 * creates a BindContext object and assigns a FileSystem Bind Data object
975 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
976 * IShellFolder uses that FileSystem Bind Data object of the BindContext
977 * to pass data about the current path element to the next object. This
978 * is used to avoid having to verify the current path element on disk, so
979 * that creating an ItemIDList from a non-existent path still can work.
981 static HRESULT WINAPI _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
982 BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
984 LPSHELLFOLDER pSF = NULL;
988 TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path), lpFindFile, bBindCtx,
989 ppidl, ppidl ? *ppidl : NULL,
990 prgfInOut, prgfInOut ? *prgfInOut : 0);
992 ret = SHGetDesktopFolder(&pSF);
998 if (lpFindFile || bBindCtx)
999 ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1003 ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1008 IBindCtx_Release(pBC);
1012 IShellFolder_Release(pSF);
1014 if (!SUCCEEDED(ret) && ppidl)
1017 TRACE("%s %p 0x%lx\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1022 /*************************************************************************
1023 * SHSimpleIDListFromPath [SHELL32.162]
1025 * Creates a simple ItemIDList from a path and returns it. This function
1026 * does not fail on non-existent paths.
1029 * path [I] path to parse and convert into an ItemIDList
1032 * the newly created simple ItemIDList
1035 * Simple in the name does not mean a relative ItemIDList but rather a
1036 * fully qualified list, where only the file name is filled in and the
1037 * directory flag for those ItemID elements this is known about, eg.
1038 * it is not the last element in the ItemIDList or the actual directory
1040 * exported by ordinal.
1042 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA(LPCSTR lpszPath)
1044 LPITEMIDLIST pidl = NULL;
1045 LPWSTR wPath = NULL;
1048 TRACE("%s\n", debugstr_a(lpszPath));
1052 len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1053 wPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1054 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1057 _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1059 if (wPath) HeapFree(GetProcessHeap(), 0, wPath);
1060 TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1064 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1066 LPITEMIDLIST pidl = NULL;
1068 TRACE("%s\n", debugstr_w(lpszPath));
1070 _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1071 TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1075 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1077 if ( SHELL_OsIsUnicode())
1078 return SHSimpleIDListFromPathW (lpszPath);
1079 return SHSimpleIDListFromPathA (lpszPath);
1082 /*************************************************************************
1083 * SHGetSpecialFolderLocation [SHELL32.@]
1085 * gets the folder locations from the registry and creates a pidl
1086 * creates missing reg keys and directories
1090 * nFolder [I] CSIDL_xxxxx
1091 * ppidl [O] PIDL of a special folder
1094 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
1095 * directory. If the directory is missing it returns a x80070002.
1097 HRESULT WINAPI SHGetSpecialFolderLocation(
1100 LPITEMIDLIST * ppidl)
1102 CHAR szPath[MAX_PATH];
1103 HRESULT hr = E_INVALIDARG;
1105 TRACE_(shell)("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
1113 *ppidl = _ILCreateDesktop();
1117 *ppidl = _ILCreateMyComputer();
1121 *ppidl = _ILCreateNetwork ();
1124 case CSIDL_CONTROLS:
1125 *ppidl = _ILCreateControl ();
1128 case CSIDL_PRINTERS:
1129 *ppidl = _ILCreatePrinter ();
1132 case CSIDL_BITBUCKET:
1133 *ppidl = _ILCreateBitBucket ();
1137 if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
1140 TRACE_(shell)("Value=%s\n",szPath);
1141 hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
1144 if(*ppidl) hr = NOERROR;
1147 TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
1151 /*************************************************************************
1152 * SHGetFolderLocation [SHELL32.@]
1155 * the pidl can be a simple one. since we can't get the path out of the pidl
1156 * we have to take all data from the pidl
1158 HRESULT WINAPI SHGetFolderLocation(
1163 LPITEMIDLIST *ppidl)
1165 FIXME("%p 0x%08x %p 0x%08lx %p\n",
1166 hwnd, csidl, hToken, dwFlags, ppidl);
1167 return SHGetSpecialFolderLocation(hwnd, csidl, ppidl);
1170 /*************************************************************************
1171 * SHGetDataFromIDListA [SHELL32.247]
1174 * the pidl can be a simple one. since we can't get the path out of the pidl
1175 * we have to take all data from the pidl
1177 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
1179 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1182 if (!psf || !dest ) return E_INVALIDARG;
1186 case SHGDFIL_FINDDATA:
1188 LPSTR filename, shortname;
1189 WIN32_FIND_DATAA * pfd = dest;
1191 if (_ILIsDrive(pidl))
1192 return E_INVALIDARG;
1194 if (len < (int)sizeof(WIN32_FIND_DATAA)) return E_INVALIDARG;
1196 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1197 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1198 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1199 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1201 filename = _ILGetTextPointer(pidl);
1202 shortname = _ILGetSTextPointer(pidl);
1205 lstrcpynA(pfd->cFileName, filename, MAX_PATH);
1207 pfd->cFileName[0] = '\0';
1210 lstrcpynA(pfd->cAlternateFileName, shortname, MAX_PATH);
1212 pfd->cAlternateFileName[0] = '\0';
1216 case SHGDFIL_NETRESOURCE:
1217 case SHGDFIL_DESCRIPTIONID:
1218 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1222 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1225 return E_INVALIDARG;
1228 /*************************************************************************
1229 * SHGetDataFromIDListW [SHELL32.248]
1232 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, int nFormat, LPVOID dest, int len)
1234 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1238 if (! psf || !dest ) return E_INVALIDARG;
1242 case SHGDFIL_FINDDATA:
1244 LPSTR filename, shortname;
1245 WIN32_FIND_DATAW * pfd = dest;
1247 if (_ILIsDrive(pidl))
1248 return E_INVALIDARG;
1250 if (len < (int)sizeof(WIN32_FIND_DATAW)) return E_INVALIDARG;
1252 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1253 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1254 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1255 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1257 filename = _ILGetTextPointer(pidl);
1258 shortname = _ILGetSTextPointer(pidl);
1261 pfd->cFileName[0] = '\0';
1262 else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1263 pfd->cFileName[MAX_PATH-1] = 0;
1266 pfd->cAlternateFileName[0] = '\0';
1267 else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1268 pfd->cAlternateFileName[13] = 0;
1271 case SHGDFIL_NETRESOURCE:
1272 case SHGDFIL_DESCRIPTIONID:
1273 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1277 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1280 return E_INVALIDARG;
1283 /*************************************************************************
1284 * SHELL_GetPathFromIDListA
1286 HRESULT SHELL_GetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath, UINT uOutSize)
1292 /* One case is a PIDL rooted at desktop level */
1293 if (_ILIsValue(pidl) || _ILIsFolder(pidl)) {
1294 hr = SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOP, FALSE);
1297 PathAddBackslashA(pszPath);
1299 /* The only other valid case is a item ID list beginning at "My Computer" */
1300 else if (_ILIsMyComputer(pidl))
1301 pidl = ILGetNext(pidl);
1303 if (SUCCEEDED(hr)) {
1306 while(pidl && pidl->mkid.cb) {
1307 if (_ILIsSpecialFolder(pidl))
1308 {hr = E_INVALIDARG; break;}
1310 txt = _ILGetTextPointer(pidl);
1312 {hr = E_INVALIDARG; break;}
1314 if (lstrlenA(txt) > pidl->mkid.cb)
1315 ERR("pidl %p is borked\n",pidl);
1317 /* make sure there's enough space for the next segment */
1318 if ( (lstrlenA(txt) + lstrlenA(pszPath)) > uOutSize)
1319 {hr = E_INVALIDARG; break;}
1320 lstrcatA( pszPath, txt );
1322 pidl = ILGetNext(pidl);
1324 {hr = E_INVALIDARG; break;}
1326 if (!pidl->mkid.cb) {
1327 /* We are at the end and successfully converted the complete PIDL. */
1331 if( (lstrlenA(pszPath) + 1) > uOutSize)
1332 {hr = E_INVALIDARG; break;}
1333 if (!PathAddBackslashA(pszPath))
1334 {hr = E_INVALIDARG; break;}
1339 TRACE_(shell)("-- %s, 0x%08lx\n", pszPath, hr);
1343 /*************************************************************************
1344 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1348 * pszPath [OUT] path
1351 * path from a passed PIDL.
1354 * NULL returns FALSE
1355 * desktop pidl gives path to desktop directory back
1356 * special pidls returning FALSE
1358 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1362 TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
1368 hr = SHELL_GetPathFromIDListA(pidl, pszPath, MAX_PATH);
1370 return SUCCEEDED(hr);
1373 /*************************************************************************
1374 * SHELL_GetPathFromIDListW
1376 HRESULT SHELL_GetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath, UINT uOutSize)
1383 /* One case is a PIDL rooted at desktop level */
1384 if (_ILIsValue(pidl) || _ILIsFolder(pidl)) {
1385 hr = SHGetSpecialFolderPathW(0, pszPath, CSIDL_DESKTOP, FALSE);
1388 PathAddBackslashW(pszPath);
1390 /* The only other valid case is a item ID list beginning at "My Computer" */
1391 else if (_ILIsMyComputer(pidl))
1392 pidl = ILGetNext(pidl);
1394 if (SUCCEEDED(hr)) {
1397 while(pidl && pidl->mkid.cb) {
1398 if (_ILIsSpecialFolder(pidl))
1399 {hr = E_INVALIDARG; break;}
1401 txt = _ILGetTextPointer(pidl);
1403 {hr = E_INVALIDARG; break;}
1405 if (lstrlenA(txt) > pidl->mkid.cb)
1406 ERR("pidl %p is borked\n",pidl);
1407 len = MultiByteToWideChar(CP_ACP, 0, txt, -1, NULL, 0);
1408 if ( (lstrlenW(pszPath) + len) > uOutSize )
1409 {hr = E_INVALIDARG; break;}
1411 MultiByteToWideChar(CP_ACP, 0, txt, -1,
1412 &pszPath[lstrlenW(pszPath)], len);
1414 pidl = ILGetNext(pidl);
1416 {hr = E_INVALIDARG; break;}
1418 if (!pidl->mkid.cb) {
1419 /* We are at the end and successfully converted the complete PIDL. */
1423 if ( (lstrlenW(pszPath) + 1) > uOutSize )
1424 {hr = E_INVALIDARG; break;}
1425 if (!PathAddBackslashW(pszPath))
1426 {hr = E_INVALIDARG; break;}
1431 TRACE_(shell)("-- %s, 0x%08lx\n", debugstr_w(pszPath), hr);
1435 /*************************************************************************
1436 * SHGetPathFromIDListW [SHELL32.@]
1438 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1442 TRACE_(shell)("(pidl=%p,%p)\n", pidl, debugstr_w(pszPath));
1448 hr = SHELL_GetPathFromIDListW(pidl, pszPath, MAX_PATH);
1450 TRACE_(shell)("-- %s, 0x%08lx\n",debugstr_w(pszPath), hr);
1451 return SUCCEEDED(hr);
1454 /*************************************************************************
1455 * SHGetPathFromIDList [SHELL32.@][NT 4.0: SHELL32.219]
1457 BOOL WINAPI SHGetPathFromIDListAW(LPCITEMIDLIST pidl,LPVOID pszPath)
1459 TRACE_(shell)("(pidl=%p,%p)\n",pidl,pszPath);
1461 if (SHELL_OsIsUnicode())
1462 return SHGetPathFromIDListW(pidl,pszPath);
1463 return SHGetPathFromIDListA(pidl,pszPath);
1466 /*************************************************************************
1467 * SHBindToParent [shell version 5.0]
1469 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1472 LPITEMIDLIST pidlChild, pidlParent;
1475 TRACE_(shell)("pidl=%p\n", pidl);
1479 if (ppidlLast) *ppidlLast = NULL;
1481 if (_ILIsPidlSimple(pidl))
1483 /* we are on desktop level */
1485 *ppidlLast = ILClone(pidl);
1486 hr = SHGetDesktopFolder((IShellFolder**)ppv);
1490 pidlChild = ILClone(ILFindLastID(pidl));
1491 pidlParent = ILClone(pidl);
1492 ILRemoveLastID(pidlParent);
1494 hr = SHGetDesktopFolder(&psf);
1497 hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
1499 if (SUCCEEDED(hr) && ppidlLast)
1500 *ppidlLast = pidlChild;
1504 SHFree (pidlParent);
1505 if (psf) IShellFolder_Release(psf);
1509 TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1513 /**************************************************************************
1515 * internal functions
1517 * ### 1. section creating pidls ###
1519 *************************************************************************
1520 * _ILCreateDesktop()
1521 * _ILCreateIExplore()
1522 * _ILCreateMyComputer()
1527 LPITEMIDLIST _ILCreateDesktop()
1529 return _ILCreateWithTypeAndSize(PT_DESKTOP, 0);
1532 LPITEMIDLIST _ILCreateMyComputer()
1534 return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1537 LPITEMIDLIST _ILCreateIExplore()
1539 return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1542 LPITEMIDLIST _ILCreateControl()
1544 /* FIXME: needs to be child of MyComputer */
1545 return _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1548 LPITEMIDLIST _ILCreatePrinter()
1550 /* FIXME: needs to be child of MyComputer */
1551 return _ILCreateGuid(PT_SHELLEXT, &CLSID_Printers);
1554 LPITEMIDLIST _ILCreateNetwork()
1556 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1559 LPITEMIDLIST _ILCreateBitBucket()
1561 return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1564 /**************************************************************************
1566 * Creates a new PIDL with type type (which can be one of PT_SHELLEXT or
1567 * PT_GUID) with the given GUID data.
1569 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1571 LPITEMIDLIST pidlOut;
1573 if (type == PT_SHELLEXT || type == PT_GUID)
1575 pidlOut = _ILCreateWithTypeAndSize(type, 2 + 2 + sizeof(GUID));
1578 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1580 memcpy(&(pData->u.guid.guid), guid, sizeof(GUID));
1581 TRACE("-- create GUID-pidl %s\n",
1582 debugstr_guid(&(pData->u.guid.guid)));
1587 WARN("%d: invalid type for GUID\n", type);
1593 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1597 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID, &iid)))
1599 ERR("%s is not a GUID\n", szGUID);
1602 return _ILCreateGuid(PT_GUID, &iid);
1605 LPITEMIDLIST _ILCreateWithTypeAndSize(PIDLTYPE type, UINT size)
1607 LPITEMIDLIST pidlOut = NULL, pidlTemp = NULL;
1610 if(!(pidlOut = SHAlloc(size + 2))) return NULL;
1611 ZeroMemory(pidlOut, size + 2);
1612 pidlOut->mkid.cb = size;
1614 if ((pData = _ILGetDataPointer(pidlOut)))
1617 if ((pidlTemp = ILGetNext(pidlOut)))
1618 pidlTemp->mkid.cb = 0x00;
1620 TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1624 /**************************************************************************
1625 * _ILCreateFromFindDataA()
1626 * Creates a new PIDL from stffile
1628 LPITEMIDLIST _ILCreateFromFindDataA(WIN32_FIND_DATAA * stffile )
1630 char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1631 char * pbuff = buff;
1639 TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1641 /* prepare buffer with both names */
1642 len = strlen (stffile->cFileName) + 1;
1643 memcpy (pbuff, stffile->cFileName, len);
1646 len1 = strlen (stffile->cAlternateFileName)+1;
1647 memcpy (pbuff, stffile->cAlternateFileName, len1);
1649 type = (stffile->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER :
1651 /* FIXME: magic #s! */
1652 if ((pidl = _ILCreateWithTypeAndSize(type, 2 + 12 + len + len1)))
1657 /* set attributes */
1658 if ((pData = _ILGetDataPointer(pidl)))
1661 FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
1662 pData->u.folder.dwFileSize = stffile->nFileSizeLow;
1663 pData->u.folder.uFileAttribs = stffile->dwFileAttributes;
1665 if ((pszDest = _ILGetTextPointer(pidl)))
1667 memcpy(pszDest, buff, len + len1);
1668 TRACE("-- create Value: %s\n",debugstr_a(pszDest));
1674 LPITEMIDLIST _ILCreateFromPathA(LPCSTR szPath)
1677 WIN32_FIND_DATAA stffile;
1678 LPITEMIDLIST pidl = NULL;
1680 hFile = FindFirstFileA(szPath, &stffile);
1681 if (hFile != INVALID_HANDLE_VALUE)
1683 pidl = _ILCreateFromFindDataA(&stffile);
1689 LPITEMIDLIST _ILCreateDrive( LPCSTR lpszNew)
1692 LPITEMIDLIST pidlOut;
1694 sTemp[0]=lpszNew[0];
1698 TRACE("(%s)\n",sTemp);
1700 /* FIXME: magic #s! */
1701 if ((pidlOut = _ILCreateWithTypeAndSize(PT_DRIVE, 25)))
1705 if ((pszDest = _ILGetTextPointer(pidlOut)))
1707 memcpy(pszDest, sTemp, sizeof(sTemp));
1708 TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1714 LPITEMIDLIST _ILCreateCPanel(LPCSTR name, LPCSTR displayName, LPCSTR comment, int iconIdx)
1716 PIDLCPanelStruct *p;
1719 int size0 = (char*)&tmp.u.cpanel.szName-(char*)&tmp.u.cpanel;
1724 tmp.u.cpanel.dummy = 0;
1725 tmp.u.cpanel.iconIdx = iconIdx;
1730 tmp.u.cpanel.offsDispName = l+1;
1731 l = strlen(displayName);
1734 tmp.u.cpanel.offsComment = tmp.u.cpanel.offsDispName+1+l;
1735 l = strlen(comment);
1738 pidl = SHAlloc(size+4);
1742 pidl->mkid.cb = size+2;
1743 memcpy(pidl->mkid.abID, &tmp, 2+size0);
1745 p = &((PIDLDATA*)pidl->mkid.abID)->u.cpanel;
1746 strcpy(p->szName, name);
1747 strcpy(p->szName+tmp.u.cpanel.offsDispName, displayName);
1748 strcpy(p->szName+tmp.u.cpanel.offsComment, comment);
1750 *(WORD*)((char*)pidl+(size+2)) = 0;
1757 /**************************************************************************
1760 * Gets the text for the drive eg. 'c:\'
1765 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1766 { TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1768 if(_ILIsMyComputer(pidl))
1769 pidl = ILGetNext(pidl);
1771 if (pidl && _ILIsDrive(pidl))
1772 return _ILSimpleGetText(pidl, pOut, uSize);
1777 /**************************************************************************
1779 * ### 2. section testing pidls ###
1781 **************************************************************************
1784 * _ILIsSpecialFolder()
1790 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1791 { TRACE("(%p)\n",pidl);
1792 return pidl && pidl->mkid.cb ? 0 : 1;
1795 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1797 REFIID iid = _ILGetGUIDPointer(pidl);
1799 TRACE("(%p)\n",pidl);
1802 return IsEqualIID(iid, &CLSID_MyComputer);
1806 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1808 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1809 TRACE("(%p)\n",pidl);
1810 return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type)) ||
1811 (pidl && pidl->mkid.cb == 0x00)
1815 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1816 { LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1817 TRACE("(%p)\n",pidl);
1818 return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1819 PT_DRIVE1 == lpPData->type ||
1820 PT_DRIVE2 == lpPData->type ||
1821 PT_DRIVE3 == lpPData->type));
1824 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1825 { LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1826 TRACE("(%p)\n",pidl);
1827 return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1830 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1831 { LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1832 TRACE("(%p)\n",pidl);
1833 return (pidl && lpPData && PT_VALUE == lpPData->type);
1836 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1837 { LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1838 TRACE("(%p)\n",pidl);
1839 return (pidl && lpPData && (lpPData->type == 0));
1842 /**************************************************************************
1845 BOOL _ILIsPidlSimple ( LPCITEMIDLIST pidl)
1849 if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1851 WORD len = pidl->mkid.cb;
1852 LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
1853 if (pidlnext->mkid.cb)
1857 TRACE("%s\n", ret ? "Yes" : "No");
1861 /**************************************************************************
1863 * ### 3. section getting values from pidls ###
1866 /**************************************************************************
1869 * gets the text for the first item in the pidl (eg. simple pidl)
1871 * returns the length of the string
1873 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1878 char szTemp[MAX_PATH];
1880 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1882 if (!pidl) return 0;
1887 if (_ILIsDesktop(pidl))
1890 if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1893 lstrcpynA(szOut, szTemp, uOutSize);
1895 dwReturn = strlen (szTemp);
1898 else if (( szSrc = _ILGetTextPointer(pidl) ))
1902 lstrcpynA(szOut, szSrc, uOutSize);
1904 dwReturn = strlen(szSrc);
1906 else if (( riid = _ILGetGUIDPointer(pidl) ))
1908 /* special folder */
1909 if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1912 lstrcpynA(szOut, szTemp, uOutSize);
1914 dwReturn = strlen (szTemp);
1919 ERR("-- no text\n");
1922 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_a(szOut),dwReturn);
1926 /**************************************************************************
1929 * gets the text for the first item in the pidl (eg. simple pidl)
1931 * returns the length of the string
1933 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
1936 char szTemp[MAX_PATH];
1938 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1940 dwReturn = _ILSimpleGetText(pidl, szTemp, uOutSize);
1942 if (!MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szOut, MAX_PATH))
1945 TRACE("-- (%p=%s 0x%08lx)\n",szOut,debugstr_w(szOut),dwReturn);
1949 /**************************************************************************
1951 * ### 4. getting pointers to parts of pidls ###
1953 **************************************************************************
1954 * _ILGetDataPointer()
1956 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
1958 if(pidl && pidl->mkid.cb != 0x00)
1959 return (LPPIDLDATA) &(pidl->mkid.abID);
1963 /**************************************************************************
1964 * _ILGetTextPointer()
1965 * gets a pointer to the long filename string stored in the pidl
1967 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
1968 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1970 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1974 switch (pdata->type)
1984 return (LPSTR)&(pdata->u.drive.szDriveName);
1992 return (LPSTR)&(pdata->u.file.szNames);
1997 case PT_NETPROVIDER:
1999 return (LPSTR)&(pdata->u.network.szNames);
2005 /**************************************************************************
2006 * _ILGetSTextPointer()
2007 * gets a pointer to the short filename string stored in the pidl
2009 LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
2010 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
2012 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2016 switch (pdata->type)
2023 return (LPSTR)(pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1);
2026 return (LPSTR)(pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1);
2032 /**************************************************************************
2033 * _ILGetGUIDPointer()
2035 * returns reference to guid stored in some pidls
2037 REFIID _ILGetGUIDPointer(LPCITEMIDLIST pidl)
2039 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2041 TRACE("%p\n", pidl);
2045 TRACE("pdata->type 0x%04x\n", pdata->type);
2046 switch (pdata->type)
2050 return (REFIID) &(pdata->u.guid.guid);
2053 TRACE("Unknown pidl type 0x%04x\n", pdata->type);
2060 /**************************************************************************
2061 * _ILGetCPanelPointer()
2062 * gets a pointer to the control panel struct stored in the pidl
2064 PIDLCPanelStruct* _ILGetCPanelPointer(LPCITEMIDLIST pidl)
2066 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2068 if (pdata && pdata->type==0)
2069 return (PIDLCPanelStruct*)&(pdata->u.cpanel);
2074 /*************************************************************************
2075 * _ILGetFileDateTime
2077 * Given the ItemIdList, get the FileTime
2080 * pidl [I] The ItemIDList
2081 * pFt [I] the resulted FILETIME of the file
2084 * True if Successful
2089 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
2091 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2093 if(! pdata) return FALSE;
2095 switch (pdata->type)
2098 DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, pFt);
2101 DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
2109 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2115 if (_ILGetFileDateTime( pidl, &ft )) {
2116 FileTimeToLocalFileTime(&ft, &lft);
2117 FileTimeToSystemTime (&lft, &time);
2118 ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize);
2127 /*************************************************************************
2130 * Given the ItemIdList, get the FileSize
2133 * pidl [I] The ItemIDList
2134 * pOut [I] The buffer to save the result
2135 * uOutsize [I] The size of the buffer
2141 * pOut can be null when no string is needed
2144 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2146 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2149 if(! pdata) return 0;
2151 switch (pdata->type)
2154 dwSize = pdata->u.file.dwFileSize;
2155 if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
2158 if (pOut) *pOut = 0x00;
2162 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2164 char szTemp[MAX_PATH];
2165 const char * pPoint;
2166 LPCITEMIDLIST pidlTemp=pidl;
2168 TRACE("pidl=%p\n",pidl);
2170 if (!pidl) return FALSE;
2172 pidlTemp = ILFindLastID(pidl);
2174 if (!_ILIsValue(pidlTemp)) return FALSE;
2175 if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
2177 pPoint = PathFindExtensionA(szTemp);
2179 if (! *pPoint) return FALSE;
2182 lstrcpynA(pOut, pPoint, uOutSize);
2188 /*************************************************************************
2191 * Given the ItemIdList, get the file type description
2194 * pidl [I] The ItemIDList (simple)
2195 * pOut [I] The buffer to save the result
2196 * uOutsize [I] The size of the buffer
2202 * This function copies as much as possible into the buffer.
2204 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2206 if(_ILIsValue(pidl))
2213 if (_ILGetExtension (pidl, sTemp, 64))
2215 if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2216 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
2218 lstrcpynA (pOut, sTemp, uOutSize - 6);
2219 strcat (pOut, "-file");
2225 lstrcpynA(pOut, "Folder", uOutSize);
2229 /*************************************************************************
2230 * _ILGetFileAttributes
2232 * Given the ItemIdList, get the Attrib string format
2235 * pidl [I] The ItemIDList
2236 * pOut [I] The buffer to save the result
2237 * uOutsize [I] The size of the Buffer
2243 * return value 0 in case of error is a valid return value
2246 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2248 LPPIDLDATA pData = _ILGetDataPointer(pidl);
2252 if(! pData) return 0;
2257 wAttrib = pData->u.folder.uFileAttribs;
2260 wAttrib = pData->u.file.uFileAttribs;
2267 if(wAttrib & FILE_ATTRIBUTE_READONLY)
2271 if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2275 if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2279 if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2283 if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2292 /*************************************************************************
2295 * free a aPidl struct
2297 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2303 for (i = 0; i < cidl; i++) SHFree(apidl[i]);
2308 /*************************************************************************
2311 * copies an aPidl struct
2313 LPITEMIDLIST* _ILCopyaPidl(LPCITEMIDLIST * apidlsrc, UINT cidl)
2316 LPITEMIDLIST * apidldest = (LPITEMIDLIST*)SHAlloc(cidl * sizeof(LPITEMIDLIST));
2317 if(!apidlsrc) return NULL;
2319 for (i = 0; i < cidl; i++)
2320 apidldest[i] = ILClone(apidlsrc[i]);
2325 /*************************************************************************
2326 * _ILCopyCidaToaPidl
2328 * creates aPidl from CIDA
2330 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, LPIDA cida)
2333 LPITEMIDLIST * dst = (LPITEMIDLIST*)SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2335 if(!dst) return NULL;
2338 *pidl = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[0]]));
2340 for (i = 0; i < cida->cidl; i++)
2341 dst[i] = ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[i + 1]]));