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
43 #include "undocshell.h"
44 #include "shell32_main.h"
50 #include "wine/debug.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(pidl
);
53 WINE_DECLARE_DEBUG_CHANNEL(shell
);
55 /* from comctl32.dll */
56 extern LPVOID WINAPI
Alloc(INT
);
57 extern BOOL WINAPI
Free(LPVOID
);
59 /*************************************************************************
60 * ILGetDisplayNameEx [SHELL32.186]
62 * Retrieves the display name of an ItemIDList
65 * psf [I] Shell Folder to start with, if NULL the desktop is used
66 * pidl [I] ItemIDList relativ to the psf to get the display name for
67 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
68 * type [I] Type of display name to retrieve
69 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
70 * 1 = SHGDN_NORMAL relative to the root folder
71 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
74 * True if the display name could be retrieved successfully, False otherwise
76 BOOL WINAPI
ILGetDisplayNameExA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPSTR path
, DWORD type
)
79 WCHAR wPath
[MAX_PATH
];
81 TRACE("%p %p %p %ld\n", psf
, pidl
, path
, type
);
86 ret
= ILGetDisplayNameExW(psf
, pidl
, wPath
, type
);
87 WideCharToMultiByte(CP_ACP
, 0, wPath
, -1, path
, MAX_PATH
, NULL
, NULL
);
88 TRACE("%p %p %s\n", psf
, pidl
, debugstr_a(path
));
93 BOOL WINAPI
ILGetDisplayNameExW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPWSTR path
, DWORD type
)
95 LPSHELLFOLDER psfParent
, lsf
= psf
;
96 HRESULT ret
= NO_ERROR
;
97 LPCITEMIDLIST pidllast
;
101 TRACE("%p %p %p %ld\n", psf
, pidl
, path
, type
);
108 ret
= SHGetDesktopFolder(&lsf
);
113 if (type
>= 0 && type
<= 2)
117 case ILGDN_FORPARSING
:
118 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
124 flag
= SHGDN_INFOLDER
;
127 FIXME("Unknown type parameter = %lx", type
);
128 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
131 if (!*(LPWORD
)pidl
|| type
== ILGDN_FORPARSING
)
133 ret
= IShellFolder_GetDisplayNameOf(lsf
, pidl
, flag
, &strret
);
136 ret
= StrRetToStrNW(path
, MAX_PATH
, &strret
, pidl
);
141 ret
= SHBindToParent(pidl
, &IID_IShellFolder
, (LPVOID
*)&psfParent
, &pidllast
);
144 ret
= IShellFolder_GetDisplayNameOf(psfParent
, pidllast
, flag
, &strret
);
147 ret
= StrRetToStrNW(path
, MAX_PATH
, &strret
, pidllast
);
149 IShellFolder_Release(psfParent
);
154 TRACE("%p %p %s\n", psf
, pidl
, debugstr_w(path
));
157 IShellFolder_Release(lsf
);
158 return SUCCEEDED(ret
);
161 BOOL WINAPI
ILGetDisplayNameEx(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPVOID path
, DWORD type
)
163 TRACE_(shell
)("%p %p %p %ld\n", psf
, pidl
, path
, type
);
164 if (SHELL_OsIsUnicode())
165 return ILGetDisplayNameExW(psf
, pidl
, path
, type
);
166 return ILGetDisplayNameExA(psf
, pidl
, path
, type
);
169 /*************************************************************************
170 * ILGetDisplayName [SHELL32.15]
172 BOOL WINAPI
ILGetDisplayName(LPCITEMIDLIST pidl
, LPVOID path
)
174 TRACE_(shell
)("%p %p\n", pidl
, path
);
175 if (SHELL_OsIsUnicode())
176 return ILGetDisplayNameExW(NULL
, pidl
, path
, ILGDN_FORPARSING
);
177 return ILGetDisplayNameExA(NULL
, pidl
, path
, ILGDN_FORPARSING
);
180 /*************************************************************************
181 * ILFindLastID [SHELL32.16]
184 * observed: pidl=Desktop return=pidl
186 LPITEMIDLIST WINAPI
ILFindLastID(LPCITEMIDLIST pidl
)
187 { LPCITEMIDLIST pidlLast
= pidl
;
189 TRACE("(pidl=%p)\n",pidl
);
191 while (pidl
->mkid
.cb
)
194 pidl
= ILGetNext(pidl
);
196 return (LPITEMIDLIST
)pidlLast
;
198 /*************************************************************************
199 * ILRemoveLastID [SHELL32.17]
202 * when pidl=Desktop return=FALSE
204 BOOL WINAPI
ILRemoveLastID(LPCITEMIDLIST pidl
)
206 TRACE_(shell
)("pidl=%p\n",pidl
);
208 if (!pidl
|| !pidl
->mkid
.cb
)
210 ILFindLastID(pidl
)->mkid
.cb
= 0;
214 /*************************************************************************
215 * ILClone [SHELL32.18]
218 * duplicate an idlist
220 LPITEMIDLIST WINAPI
ILClone (LPCITEMIDLIST pidl
)
222 LPITEMIDLIST newpidl
;
227 len
= ILGetSize(pidl
);
228 newpidl
= (LPITEMIDLIST
)SHAlloc(len
);
230 memcpy(newpidl
,pidl
,len
);
232 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
237 /*************************************************************************
238 * ILCloneFirst [SHELL32.19]
241 * duplicates the first idlist of a complex pidl
243 LPITEMIDLIST WINAPI
ILCloneFirst(LPCITEMIDLIST pidl
)
245 LPITEMIDLIST pidlNew
= NULL
;
247 TRACE("pidl=%p \n",pidl
);
253 pidlNew
= (LPITEMIDLIST
) SHAlloc (len
+2);
256 memcpy(pidlNew
,pidl
,len
+2); /* 2 -> mind a desktop pidl */
259 ILGetNext(pidlNew
)->mkid
.cb
= 0x00;
262 TRACE("-- newpidl=%p\n",pidlNew
);
267 /*************************************************************************
268 * ILLoadFromStream (SHELL32.26)
271 * the first two bytes are the len, the pidl is following then
273 HRESULT WINAPI
ILLoadFromStream (IStream
* pStream
, LPITEMIDLIST
* ppPidl
)
276 HRESULT ret
= E_FAIL
;
279 TRACE_(shell
)("%p %p\n", pStream
, ppPidl
);
286 IStream_AddRef (pStream
);
288 if (SUCCEEDED(IStream_Read(pStream
, (LPVOID
)&wLen
, 2, &dwBytesRead
)))
290 TRACE("PIDL length is %d\n", wLen
);
292 *ppPidl
= SHAlloc (wLen
);
293 if (SUCCEEDED(IStream_Read(pStream
, *ppPidl
, wLen
, &dwBytesRead
))) {
294 TRACE("Stream read OK\n");
297 WARN("reading pidl failed\n");
307 /* we are not yet fully compatible */
308 if (*ppPidl
&& !pcheck(*ppPidl
))
310 WARN("Check failed\n");
316 IStream_Release (pStream
);
321 /*************************************************************************
322 * ILSaveToStream (SHELL32.27)
325 * the first two bytes are the len, the pidl is following then
327 HRESULT WINAPI
ILSaveToStream (IStream
* pStream
, LPCITEMIDLIST pPidl
)
331 HRESULT ret
= E_FAIL
;
333 TRACE_(shell
)("%p %p\n", pStream
, pPidl
);
335 IStream_AddRef (pStream
);
338 while (pidl
->mkid
.cb
)
340 wLen
+= sizeof(WORD
) + pidl
->mkid
.cb
;
341 pidl
= ILGetNext(pidl
);
344 if (SUCCEEDED(IStream_Write(pStream
, (LPVOID
)&wLen
, 2, NULL
)))
346 if (SUCCEEDED(IStream_Write(pStream
, pPidl
, wLen
, NULL
)))
350 IStream_Release (pStream
);
355 /*************************************************************************
356 * SHILCreateFromPath [SHELL32.28]
358 * Create an ItemIDList from a path
363 * attributes [I/O] requested attributes on call and actual attributes when
364 * the function returns
367 * NO_ERROR if successful, or an OLE errer code otherwise
370 * Wrapper for IShellFolder_ParseDisplayName().
372 HRESULT WINAPI
SHILCreateFromPathA(LPCSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
375 WCHAR lpszDisplayName
[MAX_PATH
];
377 HRESULT ret
= E_FAIL
;
379 TRACE_(shell
)("%s %p 0x%08lx\n", path
, ppidl
, attributes
? *attributes
: 0);
381 if (!MultiByteToWideChar(CP_ACP
, 0, path
, -1, lpszDisplayName
, MAX_PATH
))
382 lpszDisplayName
[MAX_PATH
-1] = 0;
384 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
386 ret
= IShellFolder_ParseDisplayName(sf
, 0, NULL
, lpszDisplayName
, &pchEaten
, ppidl
, attributes
);
387 IShellFolder_Release(sf
);
392 HRESULT WINAPI
SHILCreateFromPathW(LPCWSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
396 HRESULT ret
= E_FAIL
;
398 TRACE_(shell
)("%s %p 0x%08lx\n", debugstr_w(path
), ppidl
, attributes
? *attributes
: 0);
400 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
402 ret
= IShellFolder_ParseDisplayName(sf
, 0, NULL
, (LPWSTR
)path
, &pchEaten
, ppidl
, attributes
);
403 IShellFolder_Release(sf
);
408 HRESULT WINAPI
SHILCreateFromPathAW (LPCVOID path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
410 if ( SHELL_OsIsUnicode())
411 return SHILCreateFromPathW (path
, ppidl
, attributes
);
412 return SHILCreateFromPathA (path
, ppidl
, attributes
);
415 /*************************************************************************
416 * SHCloneSpecialIDList [SHELL32.89]
418 * Create an ItemIDList to one of the special folders.
422 * nFolder [in] CSIDL_xxxxx
423 * fCreate [in] Create folder if it does not exist
426 * Success: The newly created pidl
427 * Failure: NULL, if inputs are invalid.
430 * exported by ordinal.
431 * Caller is responsible for deallocating the returned ItemIDList with the
432 * shells IMalloc interface, aka ILFree.
434 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND hwndOwner
, DWORD nFolder
, BOOL fCreate
)
435 { LPITEMIDLIST ppidl
;
436 TRACE_(shell
)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner
, nFolder
, fCreate
? "T" : "F");
439 nFolder
|= CSIDL_FLAG_CREATE
;
441 SHGetSpecialFolderLocation(hwndOwner
, nFolder
, &ppidl
);
445 /*************************************************************************
446 * ILGlobalClone [SHELL32.20]
448 * Clones an ItemIDList using Alloc.
451 * pidl [I] ItemIDList to clone
454 * Newly allocated ItemIDList.
457 * exported by ordinal.
459 LPITEMIDLIST WINAPI
ILGlobalClone(LPCITEMIDLIST pidl
)
461 LPITEMIDLIST newpidl
;
466 len
= ILGetSize(pidl
);
467 newpidl
= (LPITEMIDLIST
)Alloc(len
);
469 memcpy(newpidl
,pidl
,len
);
471 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
477 /*************************************************************************
478 * ILIsEqual [SHELL32.21]
481 BOOL WINAPI
ILIsEqual(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
483 char szData1
[MAX_PATH
];
484 char szData2
[MAX_PATH
];
486 LPCITEMIDLIST pidltemp1
= pidl1
;
487 LPCITEMIDLIST pidltemp2
= pidl2
;
489 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
491 /* explorer reads from registry directly (StreamMRU),
492 so we can only check here */
493 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
))) return FALSE
;
498 if ( (!pidl1
) || (!pidl2
) ) return FALSE
;
500 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
502 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
503 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
505 if (strcasecmp ( szData1
, szData2
)!=0 )
508 pidltemp1
= ILGetNext(pidltemp1
);
509 pidltemp2
= ILGetNext(pidltemp2
);
512 if (!pidltemp1
->mkid
.cb
&& !pidltemp2
->mkid
.cb
)
519 /*************************************************************************
520 * ILIsParent [SHELL32.23]
522 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
527 * bImmediate [I] only return true if the parent is the direct parent
531 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
535 * parent = a/b, child = a/b/c -> true, c is in folder a/b
536 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
537 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
539 BOOL WINAPI
ILIsParent(LPCITEMIDLIST pidlParent
, LPCITEMIDLIST pidlChild
, BOOL bImmediate
)
541 char szData1
[MAX_PATH
];
542 char szData2
[MAX_PATH
];
544 LPCITEMIDLIST pParent
= pidlParent
;
545 LPCITEMIDLIST pChild
= pidlChild
;
547 TRACE("%p %p %x\n", pidlParent
, pidlChild
, bImmediate
);
549 if (!pParent
|| !pChild
) return FALSE
;
551 while (pParent
->mkid
.cb
&& pChild
->mkid
.cb
)
553 _ILSimpleGetText(pParent
, szData1
, MAX_PATH
);
554 _ILSimpleGetText(pChild
, szData2
, MAX_PATH
);
556 if (strcasecmp ( szData1
, szData2
)!=0 )
559 pParent
= ILGetNext(pParent
);
560 pChild
= ILGetNext(pChild
);
563 if ( pParent
->mkid
.cb
|| ! pChild
->mkid
.cb
) /* child shorter or has equal length to parent */
566 if ( ILGetNext(pChild
)->mkid
.cb
&& bImmediate
) /* not immediate descent */
572 /*************************************************************************
573 * ILFindChild [SHELL32.24]
575 * Compares elements from pidl1 and pidl2.
582 * pidl1 is desktop pidl2
583 * pidl1 shorter pidl2 pointer to first different element of pidl2
584 * if there was at least one equal element
585 * pidl2 shorter pidl1 0
586 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
589 * exported by ordinal.
591 LPITEMIDLIST WINAPI
ILFindChild(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
593 char szData1
[MAX_PATH
];
594 char szData2
[MAX_PATH
];
596 LPCITEMIDLIST pidltemp1
= pidl1
;
597 LPCITEMIDLIST pidltemp2
= pidl2
;
598 LPCITEMIDLIST ret
=NULL
;
600 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
602 /* explorer reads from registry directly (StreamMRU),
603 so we can only check here */
604 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
)))
610 if ( _ILIsDesktop(pidl1
) )
616 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
618 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
619 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
621 if (strcasecmp(szData1
,szData2
))
624 pidltemp1
= ILGetNext(pidltemp1
);
625 pidltemp2
= ILGetNext(pidltemp2
);
629 if (pidltemp1
->mkid
.cb
)
631 ret
= NULL
; /* elements of pidl1 left*/
634 TRACE_(shell
)("--- %p\n", ret
);
635 return (LPITEMIDLIST
)ret
; /* pidl 1 is shorter */
638 /*************************************************************************
639 * ILCombine [SHELL32.25]
641 * Concatenates two complex ItemIDLists.
644 * pidl1 [I] first complex ItemIDLists
645 * pidl2 [I] complex ItemIDLists to append
648 * if both pidl's == NULL NULL
649 * if pidl1 == NULL cloned pidl2
650 * if pidl2 == NULL cloned pidl1
651 * otherwise new pidl with pidl2 appended to pidl1
654 * exported by ordinal.
655 * Does not destroy the passed in ItemIDLists!
657 LPITEMIDLIST WINAPI
ILCombine(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
660 LPITEMIDLIST pidlNew
;
662 TRACE("pidl=%p pidl=%p\n",pidl1
,pidl2
);
664 if(!pidl1
&& !pidl2
) return NULL
;
671 pidlNew
= ILClone(pidl2
);
677 pidlNew
= ILClone(pidl1
);
681 len1
= ILGetSize(pidl1
)-2;
682 len2
= ILGetSize(pidl2
);
683 pidlNew
= SHAlloc(len1
+len2
);
687 memcpy(pidlNew
,pidl1
,len1
);
688 memcpy(((BYTE
*)pidlNew
)+len1
,pidl2
,len2
);
691 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
695 /*************************************************************************
696 * SHGetRealIDL [SHELL32.98]
700 HRESULT WINAPI
SHGetRealIDL(LPSHELLFOLDER lpsf
, LPCITEMIDLIST pidlSimple
, LPITEMIDLIST
*pidlReal
)
702 IDataObject
* pDataObj
;
703 HRESULT hr
= IShellFolder_GetUIObjectOf(lpsf
, 0, 1, &pidlSimple
, &IID_IDataObject
, 0, (LPVOID
*)&pDataObj
);
709 fmt
.cfFormat
= RegisterClipboardFormatA(CFSTR_SHELLIDLIST
);
711 fmt
.dwAspect
= DVASPECT_CONTENT
;
713 fmt
.tymed
= TYMED_HGLOBAL
;
715 hr
= IDataObject_GetData(pDataObj
, &fmt
, &medium
);
717 IDataObject_Release(pDataObj
);
720 /*assert(pida->cidl==1);*/
721 LPIDA pida
= (LPIDA
)GlobalLock(medium
.u
.hGlobal
);
723 LPCITEMIDLIST pidl_folder
= (LPCITEMIDLIST
) ((LPBYTE
)pida
+pida
->aoffset
[0]);
724 LPCITEMIDLIST pidl_child
= (LPCITEMIDLIST
) ((LPBYTE
)pida
+pida
->aoffset
[1]);
726 *pidlReal
= ILCombine(pidl_folder
, pidl_child
);
731 GlobalUnlock(medium
.u
.hGlobal
);
732 GlobalFree(medium
.u
.hGlobal
);
739 /*************************************************************************
740 * SHLogILFromFSIL [SHELL32.95]
743 * pild = CSIDL_DESKTOP ret = 0
744 * pild = CSIDL_DRIVES ret = 0
746 LPITEMIDLIST WINAPI
SHLogILFromFSIL(LPITEMIDLIST pidl
)
748 FIXME("(pidl=%p)\n",pidl
);
755 /*************************************************************************
756 * ILGetSize [SHELL32.152]
758 * Gets the byte size of an ItemIDList including zero terminator
761 * pidl [I] ItemIDList
764 * size of pidl in bytes
767 * exported by ordinal
769 DWORD WINAPI
ILGetSize(LPCITEMIDLIST pidl
)
771 LPCSHITEMID si
= &(pidl
->mkid
);
777 si
= (LPSHITEMID
)(((LPBYTE
)si
)+si
->cb
);
781 TRACE("pidl=%p size=%lu\n",pidl
, len
);
785 /*************************************************************************
786 * ILGetNext [SHELL32.153]
788 * Gets the next ItemID of an ItemIDList
791 * pidl [I] ItemIDList
796 * simple pidl -> pointer to 0x0000 element
799 * exported by ordinal.
801 LPITEMIDLIST WINAPI
ILGetNext(LPCITEMIDLIST pidl
)
812 pidl
= (LPITEMIDLIST
) (((LPBYTE
)pidl
)+len
);
813 TRACE("-- %p\n", pidl
);
814 return (LPITEMIDLIST
)pidl
;
820 /*************************************************************************
821 * ILAppend [SHELL32.154]
823 * Adds the single ItemID item to the ItemIDList indicated by pidl.
824 * If bEnd is FALSE, inserts the item in the front of the list,
825 * otherwise it adds the item to the end. (???)
828 * pidl [I] ItemIDList to extend
829 * item [I] ItemID to prepend/append
830 * bEnd [I] Indicates if the item should be appended
833 * Destroys the passed in idlist! (???)
835 LPITEMIDLIST WINAPI
ILAppend(LPITEMIDLIST pidl
, LPCITEMIDLIST item
, BOOL bEnd
)
839 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl
,item
,bEnd
);
844 if (_ILIsDesktop(pidl
))
846 idlRet
= ILClone(item
);
854 idlRet
= ILCombine(pidl
, item
);
858 idlRet
= ILCombine(item
, pidl
);
865 /*************************************************************************
866 * ILFree [SHELL32.155]
868 * Frees memory (if not NULL) allocated by SHMalloc allocator
874 * exported by ordinal
876 DWORD WINAPI
ILFree(LPITEMIDLIST pidl
)
878 TRACE("(pidl=0x%08lx)\n",(DWORD
)pidl
);
880 if(!pidl
) return FALSE
;
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 UNICODE_STRING wPath
;
1047 TRACE("%s\n", debugstr_a(lpszPath
));
1049 RtlCreateUnicodeStringFromAsciiz(&wPath
, lpszPath
);
1051 _ILParsePathW(wPath
.Buffer
, NULL
, TRUE
, &pidl
, NULL
);
1052 RtlFreeUnicodeString(&wPath
);
1054 TRACE("%s %p\n", debugstr_a(lpszPath
), pidl
);
1058 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathW(LPCWSTR lpszPath
)
1060 LPITEMIDLIST pidl
= NULL
;
1062 TRACE("%s\n", debugstr_w(lpszPath
));
1064 _ILParsePathW(lpszPath
, NULL
, TRUE
, &pidl
, NULL
);
1065 TRACE("%s %p\n", debugstr_w(lpszPath
), pidl
);
1069 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathAW(LPCVOID lpszPath
)
1071 if ( SHELL_OsIsUnicode())
1072 return SHSimpleIDListFromPathW (lpszPath
);
1073 return SHSimpleIDListFromPathA (lpszPath
);
1076 /*************************************************************************
1077 * SHGetSpecialFolderLocation [SHELL32.@]
1079 * gets the folder locations from the registry and creates a pidl
1080 * creates missing reg keys and directories
1084 * nFolder [I] CSIDL_xxxxx
1085 * ppidl [O] PIDL of a special folder
1088 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
1089 * directory. If the directory is missing it returns a x80070002.
1091 HRESULT WINAPI
SHGetSpecialFolderLocation(
1094 LPITEMIDLIST
* ppidl
)
1096 CHAR szPath
[MAX_PATH
];
1097 HRESULT hr
= E_INVALIDARG
;
1099 TRACE_(shell
)("(%p,0x%x,%p)\n", hwndOwner
,nFolder
,ppidl
);
1107 *ppidl
= _ILCreateDesktop();
1111 *ppidl
= _ILCreateMyComputer();
1115 *ppidl
= _ILCreateNetwork ();
1118 case CSIDL_CONTROLS
:
1119 *ppidl
= _ILCreateControl ();
1122 case CSIDL_PRINTERS
:
1123 *ppidl
= _ILCreatePrinter ();
1126 case CSIDL_BITBUCKET
:
1127 *ppidl
= _ILCreateBitBucket ();
1131 if (SHGetSpecialFolderPathA(hwndOwner
, szPath
, nFolder
, TRUE
))
1134 TRACE_(shell
)("Value=%s\n",szPath
);
1135 hr
= SHILCreateFromPathA(szPath
, ppidl
, &attributes
);
1138 if(*ppidl
) hr
= NOERROR
;
1141 TRACE_(shell
)("-- (new pidl %p)\n",*ppidl
);
1145 /*************************************************************************
1146 * SHGetFolderLocation [SHELL32.@]
1149 * the pidl can be a simple one. since we cant get the path out of the pidl
1150 * we have to take all data from the pidl
1152 HRESULT WINAPI
SHGetFolderLocation(
1157 LPITEMIDLIST
*ppidl
)
1159 FIXME("%p 0x%08x %p 0x%08lx %p\n",
1160 hwnd
, csidl
, hToken
, dwFlags
, ppidl
);
1161 return SHGetSpecialFolderLocation(hwnd
, csidl
, ppidl
);
1164 /*************************************************************************
1165 * SHGetDataFromIDListA [SHELL32.247]
1168 * the pidl can be a simple one. since we cant get the path out of the pidl
1169 * we have to take all data from the pidl
1171 HRESULT WINAPI
SHGetDataFromIDListA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
1173 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1176 if (!psf
|| !dest
) return E_INVALIDARG
;
1180 case SHGDFIL_FINDDATA
:
1182 LPSTR filename
, shortname
;
1183 WIN32_FIND_DATAA
* pfd
= dest
;
1185 if (_ILIsDrive(pidl
))
1186 return E_INVALIDARG
;
1188 if (len
< (int)sizeof(WIN32_FIND_DATAA
)) return E_INVALIDARG
;
1190 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
1191 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1192 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1193 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1195 filename
= _ILGetTextPointer(pidl
);
1196 shortname
= _ILGetSTextPointer(pidl
);
1199 lstrcpynA(pfd
->cFileName
, filename
, MAX_PATH
);
1201 pfd
->cFileName
[0] = '\0';
1204 lstrcpynA(pfd
->cAlternateFileName
, shortname
, MAX_PATH
);
1206 pfd
->cAlternateFileName
[0] = '\0';
1210 case SHGDFIL_NETRESOURCE
:
1211 case SHGDFIL_DESCRIPTIONID
:
1212 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1216 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1219 return E_INVALIDARG
;
1222 /*************************************************************************
1223 * SHGetDataFromIDListW [SHELL32.248]
1226 HRESULT WINAPI
SHGetDataFromIDListW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
1228 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1232 if (! psf
|| !dest
) return E_INVALIDARG
;
1236 case SHGDFIL_FINDDATA
:
1238 LPSTR filename
, shortname
;
1239 WIN32_FIND_DATAW
* pfd
= dest
;
1241 if (_ILIsDrive(pidl
))
1242 return E_INVALIDARG
;
1244 if (len
< (int)sizeof(WIN32_FIND_DATAW
)) return E_INVALIDARG
;
1246 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
1247 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1248 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1249 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1251 filename
= _ILGetTextPointer(pidl
);
1252 shortname
= _ILGetSTextPointer(pidl
);
1255 pfd
->cFileName
[0] = '\0';
1256 else if (!MultiByteToWideChar(CP_ACP
, 0, filename
, -1, pfd
->cFileName
, MAX_PATH
))
1257 pfd
->cFileName
[MAX_PATH
-1] = 0;
1260 pfd
->cAlternateFileName
[0] = '\0';
1261 else if (!MultiByteToWideChar(CP_ACP
, 0, shortname
, -1, pfd
->cAlternateFileName
, 14))
1262 pfd
->cAlternateFileName
[13] = 0;
1265 case SHGDFIL_NETRESOURCE
:
1266 case SHGDFIL_DESCRIPTIONID
:
1267 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1271 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1274 return E_INVALIDARG
;
1277 /*************************************************************************
1278 * SHELL_GetPathFromIDListA
1280 HRESULT
SHELL_GetPathFromIDListA(LPCITEMIDLIST pidl
, LPSTR pszPath
, UINT uOutSize
)
1282 LPSTR pstr
= pszPath
;
1283 LPSTR end
= pszPath
+ uOutSize
;
1286 /* One case is a PIDL rooted at desktop level */
1287 if (_ILIsValue(pidl
) || _ILIsFolder(pidl
)) {
1288 hr
= SHGetSpecialFolderPathA(0, pstr
, CSIDL_DESKTOP
, FALSE
);
1291 pstr
= PathAddBackslashA(pstr
);
1293 /* The only other valid case is a item ID list beginning at "My Computer" */
1294 else if (_ILIsMyComputer(pidl
))
1295 pidl
= ILGetNext(pidl
);
1297 if (SUCCEEDED(hr
)) {
1300 while(pidl
&& pidl
->mkid
.cb
&& pstr
<end
) {
1301 if (_ILIsSpecialFolder(pidl
))
1302 {hr
= E_INVALIDARG
; break;}
1304 txt
= _ILGetTextPointer(pidl
);
1306 {hr
= E_INVALIDARG
; break;}
1308 lstrcpynA(pstr
, txt
, end
-pstr
);
1310 pidl
= ILGetNext(pidl
);
1312 {hr
= E_INVALIDARG
; break;}
1314 if (!pidl
->mkid
.cb
) {
1315 /* We are at the end and successfully converted the complete PIDL. */
1319 pstr
= PathAddBackslashA(pstr
);
1321 {hr
= E_INVALIDARG
; break;}
1326 TRACE_(shell
)("-- %s, 0x%08lx\n", pszPath
, hr
);
1330 /*************************************************************************
1331 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1335 * pszPath [OUT] path
1338 * path from a passed PIDL.
1341 * NULL returns FALSE
1342 * desktop pidl gives path to desktop directory back
1343 * special pidls returning FALSE
1345 BOOL WINAPI
SHGetPathFromIDListA(LPCITEMIDLIST pidl
, LPSTR pszPath
)
1349 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1355 hr
= SHELL_GetPathFromIDListA(pidl
, pszPath
, MAX_PATH
);
1357 return SUCCEEDED(hr
);
1360 /*************************************************************************
1361 * SHELL_GetPathFromIDListW
1363 HRESULT
SHELL_GetPathFromIDListW(LPCITEMIDLIST pidl
, LPWSTR pszPath
, UINT uOutSize
)
1365 LPWSTR pstr
= pszPath
;
1366 LPWSTR end
= pszPath
+ uOutSize
;
1369 /* One case is a PIDL rooted at desktop level */
1370 if (_ILIsValue(pidl
) || _ILIsFolder(pidl
)) {
1371 hr
= SHGetSpecialFolderPathW(0, pstr
, CSIDL_DESKTOP
, FALSE
);
1374 pstr
= PathAddBackslashW(pstr
);
1376 /* The only other valid case is a item ID list beginning at "My Computer" */
1377 else if (_ILIsMyComputer(pidl
))
1378 pidl
= ILGetNext(pidl
);
1380 if (SUCCEEDED(hr
)) {
1383 while(pidl
&& pidl
->mkid
.cb
&& pstr
<end
) {
1384 if (_ILIsSpecialFolder(pidl
))
1385 {hr
= E_INVALIDARG
; break;}
1387 txt
= _ILGetTextPointer(pidl
);
1389 {hr
= E_INVALIDARG
; break;}
1391 if (!MultiByteToWideChar(CP_ACP
, 0, txt
, -1, pstr
, uOutSize
))
1392 {hr
= E_OUTOFMEMORY
; break;}
1394 pidl
= ILGetNext(pidl
);
1396 {hr
= E_INVALIDARG
; break;}
1398 if (!pidl
->mkid
.cb
) {
1399 /* We are at the end and successfully converted the complete PIDL. */
1403 pstr
= PathAddBackslashW(pstr
);
1405 {hr
= E_INVALIDARG
; break;}
1410 TRACE_(shell
)("-- %s, 0x%08lx\n", debugstr_w(pszPath
), hr
);
1414 /*************************************************************************
1415 * SHGetPathFromIDListW [SHELL32.@]
1417 BOOL WINAPI
SHGetPathFromIDListW(LPCITEMIDLIST pidl
, LPWSTR pszPath
)
1421 TRACE_(shell
)("(pidl=%p,%p)\n", pidl
, debugstr_w(pszPath
));
1427 hr
= SHELL_GetPathFromIDListW(pidl
, pszPath
, MAX_PATH
);
1429 TRACE_(shell
)("-- %s, 0x%08lx\n",debugstr_w(pszPath
), hr
);
1430 return SUCCEEDED(hr
);
1433 /*************************************************************************
1434 * SHGetPathFromIDList [SHELL32.@][NT 4.0: SHELL32.219]
1436 BOOL WINAPI
SHGetPathFromIDListAW(LPCITEMIDLIST pidl
,LPVOID pszPath
)
1438 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1440 if (SHELL_OsIsUnicode())
1441 return SHGetPathFromIDListW(pidl
,pszPath
);
1442 return SHGetPathFromIDListA(pidl
,pszPath
);
1445 /*************************************************************************
1446 * SHBindToParent [shell version 5.0]
1448 HRESULT WINAPI
SHBindToParent(LPCITEMIDLIST pidl
, REFIID riid
, LPVOID
*ppv
, LPCITEMIDLIST
*ppidlLast
)
1451 LPITEMIDLIST pidlChild
, pidlParent
;
1454 TRACE_(shell
)("pidl=%p\n", pidl
);
1458 if (ppidlLast
) *ppidlLast
= NULL
;
1460 if (_ILIsPidlSimple(pidl
))
1462 /* we are on desktop level */
1464 *ppidlLast
= ILClone(pidl
);
1465 hr
= SHGetDesktopFolder((IShellFolder
**)ppv
);
1469 pidlChild
= ILClone(ILFindLastID(pidl
));
1470 pidlParent
= ILClone(pidl
);
1471 ILRemoveLastID(pidlParent
);
1473 hr
= SHGetDesktopFolder(&psf
);
1476 hr
= IShellFolder_BindToObject(psf
, pidlParent
, NULL
, riid
, ppv
);
1478 if (SUCCEEDED(hr
) && ppidlLast
)
1479 *ppidlLast
= pidlChild
;
1483 SHFree (pidlParent
);
1484 if (psf
) IShellFolder_Release(psf
);
1488 TRACE_(shell
)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv
, (ppidlLast
)?*ppidlLast
:NULL
, hr
);
1492 /**************************************************************************
1494 * internal functions
1496 * ### 1. section creating pidls ###
1498 *************************************************************************
1499 * _ILCreateDesktop()
1500 * _ILCreateIExplore()
1501 * _ILCreateMyComputer()
1506 LPITEMIDLIST
_ILCreateDesktop()
1508 return _ILCreate(PT_DESKTOP
, NULL
, 0);
1511 LPITEMIDLIST
_ILCreateMyComputer()
1513 return _ILCreate(PT_MYCOMP
, &CLSID_MyComputer
, sizeof(GUID
));
1516 LPITEMIDLIST
_ILCreateIExplore()
1518 return _ILCreate(PT_MYCOMP
, &CLSID_Internet
, sizeof(GUID
));
1521 LPITEMIDLIST
_ILCreateControl()
1523 return _ILCreate(PT_SPECIAL
, &CLSID_ControlPanel
, sizeof(GUID
));
1526 LPITEMIDLIST
_ILCreatePrinter()
1528 return _ILCreate(PT_SPECIAL
, &CLSID_Printers
, sizeof(GUID
));
1531 LPITEMIDLIST
_ILCreateNetwork()
1533 return _ILCreate(PT_MYCOMP
, &CLSID_NetworkPlaces
, sizeof(GUID
));
1536 LPITEMIDLIST
_ILCreateBitBucket()
1538 return _ILCreate(PT_MYCOMP
, &CLSID_RecycleBin
, sizeof(GUID
));
1541 LPITEMIDLIST
_ILCreateDrive( LPCSTR lpszNew
)
1543 lstrcpynA (sTemp
,lpszNew
,4);
1546 TRACE("(%s)\n",sTemp
);
1547 return _ILCreate(PT_DRIVE
,(LPVOID
)&sTemp
[0],4);
1550 LPITEMIDLIST
_ILCreateFolder( WIN32_FIND_DATAA
* stffile
)
1552 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1553 char * pbuff
= buff
;
1557 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1559 /* prepare buffer with both names */
1560 len
= strlen (stffile
->cFileName
) + 1;
1561 memcpy (pbuff
, stffile
->cFileName
, len
);
1564 if (stffile
->cAlternateFileName
)
1566 len1
= strlen (stffile
->cAlternateFileName
)+1;
1567 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1575 pidl
= _ILCreate(PT_FOLDER
, (LPVOID
)buff
, len
+ len1
);
1577 /* set attributes */
1581 pData
= _ILGetDataPointer(pidl
);
1582 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1583 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1584 pData
->u
.folder
.uFileAttribs
= stffile
->dwFileAttributes
;
1590 LPITEMIDLIST
_ILCreateValue(WIN32_FIND_DATAA
* stffile
)
1592 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1593 char * pbuff
= buff
;
1597 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1599 /* prepare buffer with both names */
1600 len
= strlen (stffile
->cFileName
) + 1;
1601 memcpy (pbuff
, stffile
->cFileName
, len
);
1604 if (stffile
->cAlternateFileName
)
1606 len1
= strlen (stffile
->cAlternateFileName
)+1;
1607 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1615 pidl
= _ILCreate(PT_VALUE
, (LPVOID
)buff
, len
+ len1
);
1617 /* set attributes */
1621 pData
= _ILGetDataPointer(pidl
);
1622 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1623 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1624 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1630 LPITEMIDLIST
_ILCreateFromPathA(LPCSTR szPath
)
1633 WIN32_FIND_DATAA stffile
;
1634 LPITEMIDLIST pidl
= NULL
;
1636 hFile
= FindFirstFileA(szPath
, &stffile
);
1637 if (hFile
!= INVALID_HANDLE_VALUE
)
1639 if (stffile
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1640 pidl
= _ILCreateFolder(&stffile
);
1642 pidl
= _ILCreateValue(&stffile
);
1648 LPITEMIDLIST
_ILCreateSpecial(LPCSTR szGUID
)
1652 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID
, &iid
)))
1654 ERR("%s is not a GUID\n", szGUID
);
1657 return _ILCreate(PT_MYCOMP
, &iid
, sizeof(IID
));
1660 /**************************************************************************
1662 * Creates a new PIDL
1663 * type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1665 * uInSize = size of data (raw)
1668 LPITEMIDLIST
_ILCreate(PIDLTYPE type
, LPCVOID pIn
, UINT uInSize
)
1670 LPITEMIDLIST pidlOut
= NULL
, pidlTemp
= NULL
;
1675 TRACE("(0x%02x %p %i)\n",type
,pIn
,uInSize
);
1684 uSize
= 2 + 2 + sizeof(GUID
);
1691 uSize
= 2 + 12 + uInSize
;
1694 FIXME("can't create type: 0x%08x\n",type
);
1698 if(!(pidlOut
= SHAlloc(uSize
+ 2))) return NULL
;
1699 ZeroMemory(pidlOut
, uSize
+ 2);
1700 pidlOut
->mkid
.cb
= uSize
;
1705 TRACE("- create Desktop\n");
1710 pData
= _ILGetDataPointer(pidlOut
);
1712 memcpy(&(pData
->u
.mycomp
.guid
), pIn
, uInSize
);
1713 TRACE("-- create GUID-pidl %s\n", debugstr_guid(&(pData
->u
.mycomp
.guid
)));
1717 pData
= _ILGetDataPointer(pidlOut
);
1719 pszDest
= _ILGetTextPointer(pidlOut
);
1720 memcpy(pszDest
, pIn
, uInSize
);
1721 TRACE("-- create Drive: %s\n",debugstr_a(pszDest
));
1726 pData
= _ILGetDataPointer(pidlOut
);
1728 pszDest
= _ILGetTextPointer(pidlOut
);
1729 memcpy(pszDest
, pIn
, uInSize
);
1730 TRACE("-- create Value: %s\n",debugstr_a(pszDest
));
1734 pidlTemp
= ILGetNext(pidlOut
);
1736 pidlTemp
->mkid
.cb
= 0x00;
1738 TRACE("-- (pidl=%p, size=%u)\n", pidlOut
, uSize
);
1742 /**************************************************************************
1745 * Gets the text for the drive eg. 'c:\'
1750 DWORD
_ILGetDrive(LPCITEMIDLIST pidl
,LPSTR pOut
, UINT uSize
)
1751 { TRACE("(%p,%p,%u)\n",pidl
,pOut
,uSize
);
1753 if(_ILIsMyComputer(pidl
))
1754 pidl
= ILGetNext(pidl
);
1756 if (pidl
&& _ILIsDrive(pidl
))
1757 return _ILSimpleGetText(pidl
, pOut
, uSize
);
1762 /**************************************************************************
1764 * ### 2. section testing pidls ###
1766 **************************************************************************
1769 * _ILIsSpecialFolder()
1775 BOOL
_ILIsDesktop(LPCITEMIDLIST pidl
)
1776 { TRACE("(%p)\n",pidl
);
1777 return pidl
&& pidl
->mkid
.cb
? 0 : 1;
1780 BOOL
_ILIsMyComputer(LPCITEMIDLIST pidl
)
1782 REFIID iid
= _ILGetGUIDPointer(pidl
);
1784 TRACE("(%p)\n",pidl
);
1787 return IsEqualIID(iid
, &CLSID_MyComputer
);
1791 BOOL
_ILIsSpecialFolder (LPCITEMIDLIST pidl
)
1793 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1794 TRACE("(%p)\n",pidl
);
1795 return (pidl
&& ( (lpPData
&& (PT_MYCOMP
== lpPData
->type
|| PT_SPECIAL
== lpPData
->type
)) ||
1796 (pidl
&& pidl
->mkid
.cb
== 0x00)
1800 BOOL
_ILIsDrive(LPCITEMIDLIST pidl
)
1801 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1802 TRACE("(%p)\n",pidl
);
1803 return (pidl
&& lpPData
&& (PT_DRIVE
== lpPData
->type
||
1804 PT_DRIVE1
== lpPData
->type
||
1805 PT_DRIVE2
== lpPData
->type
||
1806 PT_DRIVE3
== lpPData
->type
));
1809 BOOL
_ILIsFolder(LPCITEMIDLIST pidl
)
1810 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1811 TRACE("(%p)\n",pidl
);
1812 return (pidl
&& lpPData
&& (PT_FOLDER
== lpPData
->type
|| PT_FOLDER1
== lpPData
->type
));
1815 BOOL
_ILIsValue(LPCITEMIDLIST pidl
)
1816 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1817 TRACE("(%p)\n",pidl
);
1818 return (pidl
&& lpPData
&& PT_VALUE
== lpPData
->type
);
1821 /**************************************************************************
1824 BOOL
_ILIsPidlSimple ( LPCITEMIDLIST pidl
)
1828 if(! _ILIsDesktop(pidl
)) /* pidl=NULL or mkid.cb=0 */
1830 WORD len
= pidl
->mkid
.cb
;
1831 LPCITEMIDLIST pidlnext
= (LPCITEMIDLIST
) (((LPBYTE
)pidl
) + len
);
1832 if (pidlnext
->mkid
.cb
)
1836 TRACE("%s\n", ret
? "Yes" : "No");
1840 /**************************************************************************
1842 * ### 3. section getting values from pidls ###
1845 /**************************************************************************
1848 * gets the text for the first item in the pidl (eg. simple pidl)
1850 * returns the length of the string
1852 DWORD
_ILSimpleGetText (LPCITEMIDLIST pidl
, LPSTR szOut
, UINT uOutSize
)
1857 char szTemp
[MAX_PATH
];
1859 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1861 if (!pidl
) return 0;
1866 if (_ILIsDesktop(pidl
))
1869 if (HCR_GetClassNameA(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
1872 lstrcpynA(szOut
, szTemp
, uOutSize
);
1874 dwReturn
= strlen (szTemp
);
1877 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
1881 lstrcpynA(szOut
, szSrc
, uOutSize
);
1883 dwReturn
= strlen(szSrc
);
1885 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
1887 /* special folder */
1888 if ( HCR_GetClassNameA(riid
, szTemp
, MAX_PATH
) )
1891 lstrcpynA(szOut
, szTemp
, uOutSize
);
1893 dwReturn
= strlen (szTemp
);
1898 ERR("-- no text\n");
1901 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,debugstr_a(szOut
),dwReturn
);
1905 /**************************************************************************
1908 * gets the text for the first item in the pidl (eg. simple pidl)
1910 * returns the length of the string
1912 DWORD
_ILSimpleGetTextW (LPCITEMIDLIST pidl
, LPWSTR szOut
, UINT uOutSize
)
1915 char szTemp
[MAX_PATH
];
1917 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1919 dwReturn
= _ILSimpleGetText(pidl
, szTemp
, uOutSize
);
1921 if (!MultiByteToWideChar(CP_ACP
, 0, szTemp
, -1, szOut
, MAX_PATH
))
1924 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,debugstr_w(szOut
),dwReturn
);
1928 /**************************************************************************
1930 * ### 4. getting pointers to parts of pidls ###
1932 **************************************************************************
1933 * _ILGetDataPointer()
1935 LPPIDLDATA
_ILGetDataPointer(LPCITEMIDLIST pidl
)
1937 if(pidl
&& pidl
->mkid
.cb
!= 0x00)
1938 return (LPPIDLDATA
) &(pidl
->mkid
.abID
);
1942 /**************************************************************************
1943 * _ILGetTextPointer()
1944 * gets a pointer to the long filename string stored in the pidl
1946 LPSTR
_ILGetTextPointer(LPCITEMIDLIST pidl
)
1947 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1949 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
1953 switch (pdata
->type
)
1963 return (LPSTR
)&(pdata
->u
.drive
.szDriveName
);
1971 return (LPSTR
)&(pdata
->u
.file
.szNames
);
1976 case PT_NETPROVIDER
:
1978 return (LPSTR
)&(pdata
->u
.network
.szNames
);
1984 /**************************************************************************
1985 * _ILGetSTextPointer()
1986 * gets a pointer to the short filename string stored in the pidl
1988 LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
)
1989 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1991 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1995 switch (pdata
->type
)
2002 return (LPSTR
)(pdata
->u
.file
.szNames
+ strlen (pdata
->u
.file
.szNames
) + 1);
2005 return (LPSTR
)(pdata
->u
.network
.szNames
+ strlen (pdata
->u
.network
.szNames
) + 1);
2011 /**************************************************************************
2012 * _ILGetGUIDPointer()
2014 * returns reference to guid stored in some pidls
2016 REFIID
_ILGetGUIDPointer(LPCITEMIDLIST pidl
)
2018 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
2020 TRACE("%p\n", pidl
);
2024 TRACE("pdata->type 0x%04x\n", pdata
->type
);
2025 switch (pdata
->type
)
2029 return (REFIID
) &(pdata
->u
.mycomp
.guid
);
2032 TRACE("Unknown pidl type 0x%04x\n", pdata
->type
);
2039 /*************************************************************************
2040 * _ILGetFileDateTime
2042 * Given the ItemIdList, get the FileTime
2045 * pidl [I] The ItemIDList
2046 * pFt [I] the resulted FILETIME of the file
2049 * True if Successful
2054 BOOL
_ILGetFileDateTime(LPCITEMIDLIST pidl
, FILETIME
*pFt
)
2056 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2058 if(! pdata
) return FALSE
;
2060 switch (pdata
->type
)
2063 DosDateTimeToFileTime(pdata
->u
.folder
.uFileDate
, pdata
->u
.folder
.uFileTime
, pFt
);
2066 DosDateTimeToFileTime(pdata
->u
.file
.uFileDate
, pdata
->u
.file
.uFileTime
, pFt
);
2074 BOOL
_ILGetFileDate (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2080 if (_ILGetFileDateTime( pidl
, &ft
)) {
2081 FileTimeToLocalFileTime(&ft
, &lft
);
2082 FileTimeToSystemTime (&lft
, &time
);
2083 ret
= GetDateFormatA(LOCALE_USER_DEFAULT
,DATE_SHORTDATE
,&time
, NULL
, pOut
, uOutSize
);
2092 /*************************************************************************
2095 * Given the ItemIdList, get the FileSize
2098 * pidl [I] The ItemIDList
2099 * pOut [I] The buffer to save the result
2100 * uOutsize [I] The size of the buffer
2106 * pOut can be null when no string is needed
2109 DWORD
_ILGetFileSize (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2111 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2114 if(! pdata
) return 0;
2116 switch (pdata
->type
)
2119 dwSize
= pdata
->u
.file
.dwFileSize
;
2120 if (pOut
) StrFormatByteSizeA(dwSize
, pOut
, uOutSize
);
2123 if (pOut
) *pOut
= 0x00;
2127 BOOL
_ILGetExtension (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2129 char szTemp
[MAX_PATH
];
2130 const char * pPoint
;
2131 LPCITEMIDLIST pidlTemp
=pidl
;
2133 TRACE("pidl=%p\n",pidl
);
2135 if (!pidl
) return FALSE
;
2137 pidlTemp
= ILFindLastID(pidl
);
2139 if (!_ILIsValue(pidlTemp
)) return FALSE
;
2140 if (!_ILSimpleGetText(pidlTemp
, szTemp
, MAX_PATH
)) return FALSE
;
2142 pPoint
= PathFindExtensionA(szTemp
);
2144 if (! *pPoint
) return FALSE
;
2147 lstrcpynA(pOut
, pPoint
, uOutSize
);
2153 /*************************************************************************
2156 * Given the ItemIdList, get the file type description
2159 * pidl [I] The ItemIDList (simple)
2160 * pOut [I] The buffer to save the result
2161 * uOutsize [I] The size of the buffer
2167 * This function copies as much as possible into the buffer.
2169 void _ILGetFileType(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2171 if(_ILIsValue(pidl
))
2178 if (_ILGetExtension (pidl
, sTemp
, 64))
2180 if (!( HCR_MapTypeToValueA(sTemp
, sTemp
, 64, TRUE
)
2181 && HCR_MapTypeToValueA(sTemp
, pOut
, uOutSize
, FALSE
)))
2183 lstrcpynA (pOut
, sTemp
, uOutSize
- 6);
2184 strcat (pOut
, "-file");
2190 lstrcpynA(pOut
, "Folder", uOutSize
);
2194 /*************************************************************************
2195 * _ILGetFileAttributes
2197 * Given the ItemIdList, get the Attrib string format
2200 * pidl [I] The ItemIDList
2201 * pOut [I] The buffer to save the result
2202 * uOutsize [I] The size of the Buffer
2208 * return value 0 in case of error is a valid return value
2211 DWORD
_ILGetFileAttributes(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2213 LPPIDLDATA pData
= _ILGetDataPointer(pidl
);
2217 if(! pData
) return 0;
2222 wAttrib
= pData
->u
.folder
.uFileAttribs
;
2225 wAttrib
= pData
->u
.file
.uFileAttribs
;
2232 if(wAttrib
& FILE_ATTRIBUTE_READONLY
)
2236 if(wAttrib
& FILE_ATTRIBUTE_HIDDEN
)
2240 if(wAttrib
& FILE_ATTRIBUTE_SYSTEM
)
2244 if(wAttrib
& FILE_ATTRIBUTE_ARCHIVE
)
2248 if(wAttrib
& FILE_ATTRIBUTE_COMPRESSED
)
2257 /*************************************************************************
2260 * free a aPidl struct
2262 void _ILFreeaPidl(LPITEMIDLIST
* apidl
, UINT cidl
)
2268 for (i
= 0; i
< cidl
; i
++) SHFree(apidl
[i
]);
2273 /*************************************************************************
2276 * copies an aPidl struct
2278 LPITEMIDLIST
* _ILCopyaPidl(LPCITEMIDLIST
* apidlsrc
, UINT cidl
)
2281 LPITEMIDLIST
* apidldest
= (LPITEMIDLIST
*)SHAlloc(cidl
* sizeof(LPITEMIDLIST
));
2282 if(!apidlsrc
) return NULL
;
2284 for (i
= 0; i
< cidl
; i
++)
2285 apidldest
[i
] = ILClone(apidlsrc
[i
]);
2290 /*************************************************************************
2291 * _ILCopyCidaToaPidl
2293 * creates aPidl from CIDA
2295 LPITEMIDLIST
* _ILCopyCidaToaPidl(LPITEMIDLIST
* pidl
, LPIDA cida
)
2298 LPITEMIDLIST
* dst
= (LPITEMIDLIST
*)SHAlloc(cida
->cidl
* sizeof(LPITEMIDLIST
));
2300 if(!dst
) return NULL
;
2303 *pidl
= ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[0]]));
2305 for (i
= 0; i
< cida
->cidl
; i
++)
2306 dst
[i
] = ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[i
+ 1]]));