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"
40 #include "undocshell.h"
41 #include "shell32_main.h"
47 #include "wine/debug.h"
49 WINE_DEFAULT_DEBUG_CHANNEL(pidl
);
50 WINE_DECLARE_DEBUG_CHANNEL(shell
);
52 /* from comctl32.dll */
53 extern LPVOID WINAPI
Alloc(INT
);
54 extern BOOL WINAPI
Free(LPVOID
);
56 /*************************************************************************
57 * ILGetDisplayNameEx [SHELL32.186]
59 * Retrieves the display name of an ItemIDList
62 * psf [I] Shell Folder to start with, if NULL the desktop is used
63 * pidl [I] ItemIDList relativ to the psf to get the display name for
64 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
65 * type [I] Type of display name to retrieve
66 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
67 * 1 = SHGDN_NORMAL relative to the root folder
68 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
71 * True if the display name could be retrieved successfully, False otherwise
73 BOOL WINAPI
ILGetDisplayNameExA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPSTR path
, DWORD type
)
76 WCHAR wPath
[MAX_PATH
];
78 TRACE("%p %p %p %ld\n", psf
, pidl
, path
, type
);
83 ret
= ILGetDisplayNameExW(psf
, pidl
, wPath
, type
);
84 WideCharToMultiByte(CP_ACP
, 0, wPath
, -1, path
, MAX_PATH
, NULL
, NULL
);
85 TRACE("%p %p %s\n", psf
, pidl
, debugstr_a(path
));
90 BOOL WINAPI
ILGetDisplayNameExW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPWSTR path
, DWORD type
)
92 LPSHELLFOLDER psfParent
, lsf
= psf
;
93 HRESULT ret
= NO_ERROR
;
94 LPCITEMIDLIST pidllast
;
98 TRACE("%p %p %p %ld\n", psf
, pidl
, path
, type
);
105 ret
= SHGetDesktopFolder(&lsf
);
110 if (type
>= 0 && type
<= 2)
114 case ILGDN_FORPARSING
:
115 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
121 flag
= SHGDN_INFOLDER
;
124 FIXME("Unknown type parameter = %lx", type
);
125 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
128 if (!*(LPWORD
)pidl
|| type
== ILGDN_FORPARSING
)
130 ret
= IShellFolder_GetDisplayNameOf(lsf
, pidl
, flag
, &strret
);
133 ret
= StrRetToStrNW(path
, MAX_PATH
, &strret
, pidl
);
138 ret
= SHBindToParent(pidl
, &IID_IShellFolder
, (LPVOID
*)&psfParent
, &pidllast
);
141 ret
= IShellFolder_GetDisplayNameOf(psfParent
, pidllast
, flag
, &strret
);
144 ret
= StrRetToStrNW(path
, MAX_PATH
, &strret
, pidllast
);
146 IShellFolder_Release(psfParent
);
151 TRACE("%p %p %s\n", psf
, pidl
, debugstr_w(path
));
154 IShellFolder_Release(lsf
);
155 return SUCCEEDED(ret
);
158 BOOL WINAPI
ILGetDisplayNameEx(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPVOID path
, DWORD type
)
160 TRACE_(shell
)("%p %p %p %ld\n", psf
, pidl
, path
, type
);
161 if (SHELL_OsIsUnicode())
162 return ILGetDisplayNameExW(psf
, pidl
, path
, type
);
163 return ILGetDisplayNameExA(psf
, pidl
, path
, type
);
166 /*************************************************************************
167 * ILGetDisplayName [SHELL32.15]
169 BOOL WINAPI
ILGetDisplayName(LPCITEMIDLIST pidl
, LPVOID path
)
171 TRACE_(shell
)("%p %p\n", pidl
, path
);
172 if (SHELL_OsIsUnicode())
173 return ILGetDisplayNameExW(NULL
, pidl
, path
, ILGDN_FORPARSING
);
174 return ILGetDisplayNameExA(NULL
, pidl
, path
, ILGDN_FORPARSING
);
177 /*************************************************************************
178 * ILFindLastID [SHELL32.16]
181 * observed: pidl=Desktop return=pidl
183 LPITEMIDLIST WINAPI
ILFindLastID(LPCITEMIDLIST pidl
)
184 { LPCITEMIDLIST pidlLast
= pidl
;
186 TRACE("(pidl=%p)\n",pidl
);
188 while (pidl
->mkid
.cb
)
191 pidl
= ILGetNext(pidl
);
193 return (LPITEMIDLIST
)pidlLast
;
195 /*************************************************************************
196 * ILRemoveLastID [SHELL32.17]
199 * when pidl=Desktop return=FALSE
201 BOOL WINAPI
ILRemoveLastID(LPCITEMIDLIST pidl
)
203 TRACE_(shell
)("pidl=%p\n",pidl
);
205 if (!pidl
|| !pidl
->mkid
.cb
)
207 ILFindLastID(pidl
)->mkid
.cb
= 0;
211 /*************************************************************************
212 * ILClone [SHELL32.18]
215 * duplicate an idlist
217 LPITEMIDLIST WINAPI
ILClone (LPCITEMIDLIST pidl
)
219 LPITEMIDLIST newpidl
;
224 len
= ILGetSize(pidl
);
225 newpidl
= (LPITEMIDLIST
)SHAlloc(len
);
227 memcpy(newpidl
,pidl
,len
);
229 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
234 /*************************************************************************
235 * ILCloneFirst [SHELL32.19]
238 * duplicates the first idlist of a complex pidl
240 LPITEMIDLIST WINAPI
ILCloneFirst(LPCITEMIDLIST pidl
)
242 LPITEMIDLIST pidlNew
= NULL
;
244 TRACE("pidl=%p \n",pidl
);
250 pidlNew
= (LPITEMIDLIST
) SHAlloc (len
+2);
253 memcpy(pidlNew
,pidl
,len
+2); /* 2 -> mind a desktop pidl */
256 ILGetNext(pidlNew
)->mkid
.cb
= 0x00;
259 TRACE("-- newpidl=%p\n",pidlNew
);
264 /*************************************************************************
265 * ILLoadFromStream (SHELL32.26)
268 * the first two bytes are the len, the pidl is following then
270 HRESULT WINAPI
ILLoadFromStream (IStream
* pStream
, LPITEMIDLIST
* ppPidl
)
273 HRESULT ret
= E_FAIL
;
276 TRACE_(shell
)("%p %p\n", pStream
, ppPidl
);
283 IStream_AddRef (pStream
);
285 if (SUCCEEDED(IStream_Read(pStream
, (LPVOID
)&wLen
, 2, &dwBytesRead
)))
287 TRACE("PIDL length is %d\n", wLen
);
289 *ppPidl
= SHAlloc (wLen
);
290 if (SUCCEEDED(IStream_Read(pStream
, *ppPidl
, wLen
, &dwBytesRead
))) {
291 TRACE("Stream read OK\n");
294 WARN("reading pidl failed\n");
304 /* we are not yet fully compatible */
305 if (*ppPidl
&& !pcheck(*ppPidl
))
307 WARN("Check failed\n");
313 IStream_Release (pStream
);
318 /*************************************************************************
319 * ILSaveToStream (SHELL32.27)
322 * the first two bytes are the len, the pidl is following then
324 HRESULT WINAPI
ILSaveToStream (IStream
* pStream
, LPCITEMIDLIST pPidl
)
328 HRESULT ret
= E_FAIL
;
330 TRACE_(shell
)("%p %p\n", pStream
, pPidl
);
332 IStream_AddRef (pStream
);
335 while (pidl
->mkid
.cb
)
337 wLen
+= sizeof(WORD
) + pidl
->mkid
.cb
;
338 pidl
= ILGetNext(pidl
);
341 if (SUCCEEDED(IStream_Write(pStream
, (LPVOID
)&wLen
, 2, NULL
)))
343 if (SUCCEEDED(IStream_Write(pStream
, pPidl
, wLen
, NULL
)))
347 IStream_Release (pStream
);
352 /*************************************************************************
353 * SHILCreateFromPath [SHELL32.28]
355 * Create an ItemIDList from a path
360 * attributes [I/O] requested attributes on call and actual attributes when
361 * the function returns
364 * NO_ERROR if successful, or an OLE errer code otherwise
367 * Wrapper for IShellFolder_ParseDisplayName().
369 HRESULT WINAPI
SHILCreateFromPathA(LPCSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
372 WCHAR lpszDisplayName
[MAX_PATH
];
374 HRESULT ret
= E_FAIL
;
376 TRACE_(shell
)("%s %p 0x%08lx\n", path
, ppidl
, attributes
? *attributes
: 0);
378 if (!MultiByteToWideChar(CP_ACP
, 0, path
, -1, lpszDisplayName
, MAX_PATH
))
379 lpszDisplayName
[MAX_PATH
-1] = 0;
381 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
383 ret
= IShellFolder_ParseDisplayName(sf
, 0, NULL
, lpszDisplayName
, &pchEaten
, ppidl
, attributes
);
384 IShellFolder_Release(sf
);
389 HRESULT WINAPI
SHILCreateFromPathW(LPCWSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
393 HRESULT ret
= E_FAIL
;
395 TRACE_(shell
)("%s %p 0x%08lx\n", debugstr_w(path
), ppidl
, attributes
? *attributes
: 0);
397 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
399 ret
= IShellFolder_ParseDisplayName(sf
, 0, NULL
, (LPWSTR
)path
, &pchEaten
, ppidl
, attributes
);
400 IShellFolder_Release(sf
);
405 HRESULT WINAPI
SHILCreateFromPathAW (LPCVOID path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
407 if ( SHELL_OsIsUnicode())
408 return SHILCreateFromPathW (path
, ppidl
, attributes
);
409 return SHILCreateFromPathA (path
, ppidl
, attributes
);
412 /*************************************************************************
413 * SHCloneSpecialIDList [SHELL32.89]
415 * Create an ItemIDList to one of the special folders.
419 * nFolder [in] CSIDL_xxxxx
420 * fCreate [in] Create folder if it does not exist
423 * Success: The newly created pidl
424 * Failure: NULL, if inputs are invalid.
427 * exported by ordinal.
428 * Caller is responsible for deallocating the returned ItemIDList with the
429 * shells IMalloc interface, aka ILFree.
431 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND hwndOwner
, DWORD nFolder
, BOOL fCreate
)
432 { LPITEMIDLIST ppidl
;
433 TRACE_(shell
)("(hwnd=%p,csidl=0x%lx,%s).\n", hwndOwner
, nFolder
, fCreate
? "T" : "F");
436 nFolder
|= CSIDL_FLAG_CREATE
;
438 SHGetSpecialFolderLocation(hwndOwner
, nFolder
, &ppidl
);
442 /*************************************************************************
443 * ILGlobalClone [SHELL32.20]
445 * Clones an ItemIDList using Alloc.
448 * pidl [I] ItemIDList to clone
451 * Newly allocated ItemIDList.
454 * exported by ordinal.
456 LPITEMIDLIST WINAPI
ILGlobalClone(LPCITEMIDLIST pidl
)
458 LPITEMIDLIST newpidl
;
463 len
= ILGetSize(pidl
);
464 newpidl
= (LPITEMIDLIST
)Alloc(len
);
466 memcpy(newpidl
,pidl
,len
);
468 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
474 /*************************************************************************
475 * ILIsEqual [SHELL32.21]
478 BOOL WINAPI
ILIsEqual(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
480 char szData1
[MAX_PATH
];
481 char szData2
[MAX_PATH
];
483 LPCITEMIDLIST pidltemp1
= pidl1
;
484 LPCITEMIDLIST pidltemp2
= pidl2
;
486 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
488 /* explorer reads from registry directly (StreamMRU),
489 so we can only check here */
490 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
))) return FALSE
;
495 if ( (!pidl1
) || (!pidl2
) ) return FALSE
;
497 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
499 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
500 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
502 if (strcasecmp ( szData1
, szData2
)!=0 )
505 pidltemp1
= ILGetNext(pidltemp1
);
506 pidltemp2
= ILGetNext(pidltemp2
);
509 if (!pidltemp1
->mkid
.cb
&& !pidltemp2
->mkid
.cb
)
516 /*************************************************************************
517 * ILIsParent [SHELL32.23]
519 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
524 * bImmediate [I] only return true if the parent is the direct parent
528 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
532 * parent = a/b, child = a/b/c -> true, c is in folder a/b
533 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
534 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
536 BOOL WINAPI
ILIsParent(LPCITEMIDLIST pidlParent
, LPCITEMIDLIST pidlChild
, BOOL bImmediate
)
538 char szData1
[MAX_PATH
];
539 char szData2
[MAX_PATH
];
541 LPCITEMIDLIST pParent
= pidlParent
;
542 LPCITEMIDLIST pChild
= pidlChild
;
544 TRACE("%p %p %x\n", pidlParent
, pidlChild
, bImmediate
);
546 if (!pParent
|| !pChild
) return FALSE
;
548 while (pParent
->mkid
.cb
&& pChild
->mkid
.cb
)
550 _ILSimpleGetText(pParent
, szData1
, MAX_PATH
);
551 _ILSimpleGetText(pChild
, szData2
, MAX_PATH
);
553 if (strcasecmp ( szData1
, szData2
)!=0 )
556 pParent
= ILGetNext(pParent
);
557 pChild
= ILGetNext(pChild
);
560 if ( pParent
->mkid
.cb
|| ! pChild
->mkid
.cb
) /* child shorter or has equal length to parent */
563 if ( ILGetNext(pChild
)->mkid
.cb
&& bImmediate
) /* not immediate descent */
569 /*************************************************************************
570 * ILFindChild [SHELL32.24]
572 * Compares elements from pidl1 and pidl2.
579 * pidl1 is desktop pidl2
580 * pidl1 shorter pidl2 pointer to first different element of pidl2
581 * if there was at least one equal element
582 * pidl2 shorter pidl1 0
583 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
586 * exported by ordinal.
588 LPITEMIDLIST WINAPI
ILFindChild(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
590 char szData1
[MAX_PATH
];
591 char szData2
[MAX_PATH
];
593 LPCITEMIDLIST pidltemp1
= pidl1
;
594 LPCITEMIDLIST pidltemp2
= pidl2
;
595 LPCITEMIDLIST ret
=NULL
;
597 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
599 /* explorer reads from registry directly (StreamMRU),
600 so we can only check here */
601 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
)))
607 if ( _ILIsDesktop(pidl1
) )
613 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
615 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
616 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
618 if (strcasecmp(szData1
,szData2
))
621 pidltemp1
= ILGetNext(pidltemp1
);
622 pidltemp2
= ILGetNext(pidltemp2
);
626 if (pidltemp1
->mkid
.cb
)
628 ret
= NULL
; /* elements of pidl1 left*/
631 TRACE_(shell
)("--- %p\n", ret
);
632 return (LPITEMIDLIST
)ret
; /* pidl 1 is shorter */
635 /*************************************************************************
636 * ILCombine [SHELL32.25]
638 * Concatenates two complex ItemIDLists.
641 * pidl1 [I] first complex ItemIDLists
642 * pidl2 [I] complex ItemIDLists to append
645 * if both pidl's == NULL NULL
646 * if pidl1 == NULL cloned pidl2
647 * if pidl2 == NULL cloned pidl1
648 * otherwise new pidl with pidl2 appended to pidl1
651 * exported by ordinal.
652 * Does not destroy the passed in ItemIDLists!
654 LPITEMIDLIST WINAPI
ILCombine(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
657 LPITEMIDLIST pidlNew
;
659 TRACE("pidl=%p pidl=%p\n",pidl1
,pidl2
);
661 if(!pidl1
&& !pidl2
) return NULL
;
668 pidlNew
= ILClone(pidl2
);
674 pidlNew
= ILClone(pidl1
);
678 len1
= ILGetSize(pidl1
)-2;
679 len2
= ILGetSize(pidl2
);
680 pidlNew
= SHAlloc(len1
+len2
);
684 memcpy(pidlNew
,pidl1
,len1
);
685 memcpy(((BYTE
*)pidlNew
)+len1
,pidl2
,len2
);
688 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
691 /*************************************************************************
692 * SHGetRealIDL [SHELL32.98]
696 HRESULT WINAPI
SHGetRealIDL(LPSHELLFOLDER lpsf
, LPCITEMIDLIST pidlSimple
, LPITEMIDLIST
*pidlReal
)
698 FIXME("sf=%p pidlSimple=%p pidlReal=%p\n", lpsf
, pidlSimple
, pidlReal
);
704 /*************************************************************************
705 * SHLogILFromFSIL [SHELL32.95]
708 * pild = CSIDL_DESKTOP ret = 0
709 * pild = CSIDL_DRIVES ret = 0
711 LPITEMIDLIST WINAPI
SHLogILFromFSIL(LPITEMIDLIST pidl
)
713 FIXME("(pidl=%p)\n",pidl
);
720 /*************************************************************************
721 * ILGetSize [SHELL32.152]
723 * Gets the byte size of an ItemIDList including zero terminator
726 * pidl [I] ItemIDList
729 * size of pidl in bytes
732 * exported by ordinal
734 DWORD WINAPI
ILGetSize(LPCITEMIDLIST pidl
)
736 LPCSHITEMID si
= &(pidl
->mkid
);
742 si
= (LPSHITEMID
)(((LPBYTE
)si
)+si
->cb
);
746 TRACE("pidl=%p size=%lu\n",pidl
, len
);
750 /*************************************************************************
751 * ILGetNext [SHELL32.153]
753 * Gets the next ItemID of an ItemIDList
756 * pidl [I] ItemIDList
761 * simple pidl -> pointer to 0x0000 element
764 * exported by ordinal.
766 LPITEMIDLIST WINAPI
ILGetNext(LPCITEMIDLIST pidl
)
777 pidl
= (LPITEMIDLIST
) (((LPBYTE
)pidl
)+len
);
778 TRACE("-- %p\n", pidl
);
779 return (LPITEMIDLIST
)pidl
;
785 /*************************************************************************
786 * ILAppend [SHELL32.154]
788 * Adds the single ItemID item to the ItemIDList indicated by pidl.
789 * If bEnd is FALSE, inserts the item in the front of the list,
790 * otherwise it adds the item to the end. (???)
793 * pidl [I] ItemIDList to extend
794 * item [I] ItemID to prepend/append
795 * bEnd [I] Indicates if the item should be appended
798 * Destroys the passed in idlist! (???)
800 LPITEMIDLIST WINAPI
ILAppend(LPITEMIDLIST pidl
, LPCITEMIDLIST item
, BOOL bEnd
)
804 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl
,item
,bEnd
);
809 if (_ILIsDesktop(pidl
))
811 idlRet
= ILClone(item
);
819 idlRet
= ILCombine(pidl
, item
);
823 idlRet
= ILCombine(item
, pidl
);
830 /*************************************************************************
831 * ILFree [SHELL32.155]
833 * Frees memory (if not NULL) allocated by SHMalloc allocator
839 * exported by ordinal
841 DWORD WINAPI
ILFree(LPITEMIDLIST pidl
)
843 TRACE("(pidl=0x%08lx)\n",(DWORD
)pidl
);
845 if(!pidl
) return FALSE
;
850 /*************************************************************************
851 * ILGlobalFree [SHELL32.156]
853 * Frees memory (if not NULL) allocated by Alloc allocator
859 * exported by ordinal.
861 void WINAPI
ILGlobalFree( LPITEMIDLIST pidl
)
869 /*************************************************************************
870 * ILCreateFromPathA [SHELL32.189]
872 * Creates a complex ItemIDList from a path and returns it.
878 * the newly created complex ItemIDList or NULL if failed
881 * exported by ordinal.
884 LPITEMIDLIST WINAPI
ILCreateFromPathA (LPCSTR path
)
886 LPITEMIDLIST pidlnew
= NULL
;
888 TRACE_(shell
)("%s\n", debugstr_a(path
));
890 if (SUCCEEDED(SHILCreateFromPathA(path
, &pidlnew
, NULL
)))
895 /*************************************************************************
896 * ILCreateFromPathW [SHELL32.190]
898 LPITEMIDLIST WINAPI
ILCreateFromPathW (LPCWSTR path
)
900 LPITEMIDLIST pidlnew
= NULL
;
902 TRACE_(shell
)("%s\n", debugstr_w(path
));
904 if (SUCCEEDED(SHILCreateFromPathW(path
, &pidlnew
, NULL
)))
909 /*************************************************************************
910 * ILCreateFromPath [SHELL32.157]
912 LPITEMIDLIST WINAPI
ILCreateFromPathAW (LPCVOID path
)
914 if ( SHELL_OsIsUnicode())
915 return ILCreateFromPathW (path
);
916 return ILCreateFromPathA (path
);
919 /*************************************************************************
920 * _ILParsePathW [internal]
922 * Creates an ItemIDList from a path and returns it.
925 * path [I] path to parse and convert into an ItemIDList
926 * lpFindFile [I] pointer to buffer to initialize the FileSystem
927 * Bind Data object with
928 * bBindCtx [I] indicates to create a BindContext and assign a
929 * FileSystem Bind Data object
930 * ppidl [O] the newly create ItemIDList
931 * prgfInOut [I/O] requested attributes on input and actual
932 * attributes on return
935 * NO_ERROR on success or an OLE error code
938 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
939 * creates a BindContext object and assigns a FileSystem Bind Data object
940 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
941 * IShellFolder uses that FileSystem Bind Data object of the BindContext
942 * to pass data about the current path element to the next object. This
943 * is used to avoid having to verify the current path element on disk, so
944 * that creating an ItemIDList from a non-existent path still can work.
946 static HRESULT WINAPI
_ILParsePathW(LPCWSTR path
, LPWIN32_FIND_DATAW lpFindFile
,
947 BOOL bBindCtx
, LPITEMIDLIST
*ppidl
, LPDWORD prgfInOut
)
949 LPSHELLFOLDER pSF
= NULL
;
953 TRACE("%s %p %d (%p)->%p (%p)->0x%lx\n", debugstr_w(path
), lpFindFile
, bBindCtx
,
954 ppidl
, ppidl
? *ppidl
: NULL
,
955 prgfInOut
, prgfInOut
? *prgfInOut
: 0);
957 ret
= SHGetDesktopFolder(&pSF
);
963 if (lpFindFile
|| bBindCtx
)
964 ret
= IFileSystemBindData_Constructor(lpFindFile
, &pBC
);
968 ret
= IShellFolder_ParseDisplayName(pSF
, 0, pBC
, (LPOLESTR
)path
, NULL
, ppidl
, prgfInOut
);
973 IBindCtx_Release(pBC
);
977 IShellFolder_Release(pSF
);
979 if (!SUCCEEDED(ret
) && ppidl
)
982 TRACE("%s %p 0x%lx\n", debugstr_w(path
), ppidl
? *ppidl
: NULL
, prgfInOut
? *prgfInOut
: 0);
987 /*************************************************************************
988 * SHSimpleIDListFromPath [SHELL32.162]
990 * Creates a simple ItemIDList from a path and returns it. This function
991 * does not fail on non-existent paths.
994 * path [I] path to parse and convert into an ItemIDList
997 * the newly created simple ItemIDList
1000 * Simple in the name does not mean a relative ItemIDList but rather a
1001 * fully qualified list, where only the file name is filled in and the
1002 * directory flag for those ItemID elements this is known about, eg.
1003 * it is not the last element in the ItemIDList or the actual directory
1005 * exported by ordinal.
1007 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathA(LPCSTR lpszPath
)
1009 LPITEMIDLIST pidl
= NULL
;
1010 UNICODE_STRING wPath
;
1012 TRACE("%s\n", debugstr_a(lpszPath
));
1014 RtlCreateUnicodeStringFromAsciiz(&wPath
, lpszPath
);
1016 _ILParsePathW(wPath
.Buffer
, NULL
, TRUE
, &pidl
, NULL
);
1017 RtlFreeUnicodeString(&wPath
);
1019 TRACE("%s %p\n", debugstr_a(lpszPath
), pidl
);
1023 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathW(LPCWSTR lpszPath
)
1025 LPITEMIDLIST pidl
= NULL
;
1027 TRACE("%s\n", debugstr_w(lpszPath
));
1029 _ILParsePathW(lpszPath
, NULL
, TRUE
, &pidl
, NULL
);
1030 TRACE("%s %p\n", debugstr_w(lpszPath
), pidl
);
1034 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathAW(LPCVOID lpszPath
)
1036 if ( SHELL_OsIsUnicode())
1037 return SHSimpleIDListFromPathW (lpszPath
);
1038 return SHSimpleIDListFromPathA (lpszPath
);
1041 /*************************************************************************
1042 * SHGetSpecialFolderLocation [SHELL32.@]
1044 * gets the folder locations from the registry and creates a pidl
1045 * creates missing reg keys and directories
1049 * nFolder [I] CSIDL_xxxxx
1050 * ppidl [O] PIDL of a special folder
1053 * In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
1054 * directory. If the directory is missing it returns a x80070002.
1056 HRESULT WINAPI
SHGetSpecialFolderLocation(
1059 LPITEMIDLIST
* ppidl
)
1061 CHAR szPath
[MAX_PATH
];
1062 HRESULT hr
= E_INVALIDARG
;
1064 TRACE_(shell
)("(%p,0x%x,%p)\n", hwndOwner
,nFolder
,ppidl
);
1072 *ppidl
= _ILCreateDesktop();
1076 *ppidl
= _ILCreateMyComputer();
1080 *ppidl
= _ILCreateNetwork ();
1083 case CSIDL_CONTROLS
:
1084 *ppidl
= _ILCreateControl ();
1087 case CSIDL_PRINTERS
:
1088 *ppidl
= _ILCreatePrinter ();
1091 case CSIDL_BITBUCKET
:
1092 *ppidl
= _ILCreateBitBucket ();
1096 if (SHGetSpecialFolderPathA(hwndOwner
, szPath
, nFolder
, TRUE
))
1099 TRACE_(shell
)("Value=%s\n",szPath
);
1100 hr
= SHILCreateFromPathA(szPath
, ppidl
, &attributes
);
1103 if(*ppidl
) hr
= NOERROR
;
1106 TRACE_(shell
)("-- (new pidl %p)\n",*ppidl
);
1110 /*************************************************************************
1111 * SHGetFolderLocation [SHELL32.@]
1114 * the pidl can be a simple one. since we cant get the path out of the pidl
1115 * we have to take all data from the pidl
1117 HRESULT WINAPI
SHGetFolderLocation(
1122 LPITEMIDLIST
*ppidl
)
1124 FIXME("%p 0x%08x %p 0x%08lx %p\n",
1125 hwnd
, csidl
, hToken
, dwFlags
, ppidl
);
1126 return SHGetSpecialFolderLocation(hwnd
, csidl
, ppidl
);
1129 /*************************************************************************
1130 * SHGetDataFromIDListA [SHELL32.247]
1133 * the pidl can be a simple one. since we cant get the path out of the pidl
1134 * we have to take all data from the pidl
1136 HRESULT WINAPI
SHGetDataFromIDListA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
1138 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1141 if (!psf
|| !dest
) return E_INVALIDARG
;
1145 case SHGDFIL_FINDDATA
:
1147 WIN32_FIND_DATAA
* pfd
= dest
;
1149 if (len
< (int)sizeof(WIN32_FIND_DATAA
)) return E_INVALIDARG
;
1151 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
1152 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1153 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1154 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1155 lstrcpynA(pfd
->cFileName
,_ILGetTextPointer(pidl
), MAX_PATH
);
1156 lstrcpynA(pfd
->cAlternateFileName
,_ILGetSTextPointer(pidl
), 14);
1160 case SHGDFIL_NETRESOURCE
:
1161 case SHGDFIL_DESCRIPTIONID
:
1162 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1166 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1169 return E_INVALIDARG
;
1171 /*************************************************************************
1172 * SHGetDataFromIDListW [SHELL32.248]
1175 HRESULT WINAPI
SHGetDataFromIDListW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
1177 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1181 if (! psf
|| !dest
) return E_INVALIDARG
;
1185 case SHGDFIL_FINDDATA
:
1187 WIN32_FIND_DATAW
* pfd
= dest
;
1189 if (len
< (int)sizeof(WIN32_FIND_DATAW
)) return E_INVALIDARG
;
1191 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
1192 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1193 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1194 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1195 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetTextPointer(pidl
), -1,
1196 pfd
->cFileName
, MAX_PATH
))
1197 pfd
->cFileName
[MAX_PATH
-1] = 0;
1198 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetSTextPointer(pidl
), -1,
1199 pfd
->cAlternateFileName
, 14 ))
1200 pfd
->cFileName
[13] = 0;
1203 case SHGDFIL_NETRESOURCE
:
1204 case SHGDFIL_DESCRIPTIONID
:
1205 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1209 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1212 return E_INVALIDARG
;
1215 /*************************************************************************
1216 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1220 * pszPath [OUT] path
1223 * path from a passed PIDL.
1226 * NULL returns FALSE
1227 * desktop pidl gives path to desktop directory back
1228 * special pidls returning FALSE
1230 BOOL WINAPI
SHGetPathFromIDListA(LPCITEMIDLIST pidl
, LPSTR pszPath
)
1234 LPSHELLFOLDER shellfolder
;
1236 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1242 hr
= SHGetDesktopFolder(&shellfolder
);
1243 if (SUCCEEDED (hr
)) {
1244 hr
= IShellFolder_GetDisplayNameOf(shellfolder
, pidl
, SHGDN_FORPARSING
, &str
);
1246 StrRetToStrNA (pszPath
, MAX_PATH
, &str
, pidl
);
1248 IShellFolder_Release(shellfolder
);
1251 /* don't allow to return displaynames of the form "::{guid}" */
1252 if (pszPath
[0]==':' && pszPath
[1]==':') {
1257 TRACE_(shell
)("-- %s, 0x%08lx\n",pszPath
, hr
);
1258 return SUCCEEDED(hr
);
1260 /*************************************************************************
1261 * SHGetPathFromIDListW [SHELL32.@]
1263 BOOL WINAPI
SHGetPathFromIDListW(LPCITEMIDLIST pidl
, LPWSTR pszPath
)
1267 LPSHELLFOLDER shellfolder
;
1269 TRACE_(shell
)("(pidl=%p,%p)\n", pidl
, debugstr_w(pszPath
));
1272 if (!pidl
) return FALSE
;
1274 hr
= SHGetDesktopFolder(&shellfolder
);
1275 if (SUCCEEDED(hr
)) {
1276 hr
= IShellFolder_GetDisplayNameOf(shellfolder
, pidl
, SHGDN_FORPARSING
, &str
);
1277 if (SUCCEEDED(hr
)) {
1278 StrRetToStrNW(pszPath
, MAX_PATH
, &str
, pidl
);
1280 IShellFolder_Release(shellfolder
);
1283 /* don't allow to return displaynames of the form "::{guid}" */
1284 if (pszPath
[0]==':' && pszPath
[1]==':') {
1289 TRACE_(shell
)("-- %s, 0x%08lx\n",debugstr_w(pszPath
), hr
);
1290 return SUCCEEDED(hr
);
1293 /*************************************************************************
1294 * SHGetPathFromIDList [SHELL32.@][NT 4.0: SHELL32.219]
1296 BOOL WINAPI
SHGetPathFromIDListAW(LPCITEMIDLIST pidl
,LPVOID pszPath
)
1298 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1300 if (SHELL_OsIsUnicode())
1301 return SHGetPathFromIDListW(pidl
,pszPath
);
1302 return SHGetPathFromIDListA(pidl
,pszPath
);
1305 /*************************************************************************
1306 * SHBindToParent [shell version 5.0]
1308 HRESULT WINAPI
SHBindToParent(LPCITEMIDLIST pidl
, REFIID riid
, LPVOID
*ppv
, LPCITEMIDLIST
*ppidlLast
)
1311 LPITEMIDLIST pidlChild
, pidlParent
;
1314 TRACE_(shell
)("pidl=%p\n", pidl
);
1318 if (ppidlLast
) *ppidlLast
= NULL
;
1320 if (_ILIsPidlSimple(pidl
))
1322 /* we are on desktop level */
1324 *ppidlLast
= ILClone(pidl
);
1325 hr
= SHGetDesktopFolder((IShellFolder
**)ppv
);
1329 pidlChild
= ILClone(ILFindLastID(pidl
));
1330 pidlParent
= ILClone(pidl
);
1331 ILRemoveLastID(pidlParent
);
1333 hr
= SHGetDesktopFolder(&psf
);
1336 hr
= IShellFolder_BindToObject(psf
, pidlParent
, NULL
, riid
, ppv
);
1338 if (SUCCEEDED(hr
) && ppidlLast
)
1339 *ppidlLast
= pidlChild
;
1343 SHFree (pidlParent
);
1344 if (psf
) IShellFolder_Release(psf
);
1348 TRACE_(shell
)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv
, (ppidlLast
)?*ppidlLast
:NULL
, hr
);
1352 /**************************************************************************
1354 * internal functions
1356 * ### 1. section creating pidls ###
1358 *************************************************************************
1359 * _ILCreateDesktop()
1360 * _ILCreateIExplore()
1361 * _ILCreateMyComputer()
1366 LPITEMIDLIST
_ILCreateDesktop()
1368 return _ILCreate(PT_DESKTOP
, NULL
, 0);
1371 LPITEMIDLIST
_ILCreateMyComputer()
1373 return _ILCreate(PT_MYCOMP
, &CLSID_MyComputer
, sizeof(GUID
));
1376 LPITEMIDLIST
_ILCreateIExplore()
1378 return _ILCreate(PT_MYCOMP
, &CLSID_Internet
, sizeof(GUID
));
1381 LPITEMIDLIST
_ILCreateControl()
1383 return _ILCreate(PT_SPECIAL
, &CLSID_ControlPanel
, sizeof(GUID
));
1386 LPITEMIDLIST
_ILCreatePrinter()
1388 return _ILCreate(PT_SPECIAL
, &CLSID_Printers
, sizeof(GUID
));
1391 LPITEMIDLIST
_ILCreateNetwork()
1393 return _ILCreate(PT_MYCOMP
, &CLSID_NetworkPlaces
, sizeof(GUID
));
1396 LPITEMIDLIST
_ILCreateBitBucket()
1398 return _ILCreate(PT_MYCOMP
, &CLSID_RecycleBin
, sizeof(GUID
));
1401 LPITEMIDLIST
_ILCreateDrive( LPCSTR lpszNew
)
1403 lstrcpynA (sTemp
,lpszNew
,4);
1406 TRACE("(%s)\n",sTemp
);
1407 return _ILCreate(PT_DRIVE
,(LPVOID
)&sTemp
[0],4);
1410 LPITEMIDLIST
_ILCreateFolder( WIN32_FIND_DATAA
* stffile
)
1412 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1413 char * pbuff
= buff
;
1417 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1419 /* prepare buffer with both names */
1420 len
= strlen (stffile
->cFileName
) + 1;
1421 memcpy (pbuff
, stffile
->cFileName
, len
);
1424 if (stffile
->cAlternateFileName
)
1426 len1
= strlen (stffile
->cAlternateFileName
)+1;
1427 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1435 pidl
= _ILCreate(PT_FOLDER
, (LPVOID
)buff
, len
+ len1
);
1437 /* set attributes */
1441 pData
= _ILGetDataPointer(pidl
);
1442 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1443 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1444 pData
->u
.folder
.uFileAttribs
= stffile
->dwFileAttributes
;
1450 LPITEMIDLIST
_ILCreateValue(WIN32_FIND_DATAA
* stffile
)
1452 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1453 char * pbuff
= buff
;
1457 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1459 /* prepare buffer with both names */
1460 len
= strlen (stffile
->cFileName
) + 1;
1461 memcpy (pbuff
, stffile
->cFileName
, len
);
1464 if (stffile
->cAlternateFileName
)
1466 len1
= strlen (stffile
->cAlternateFileName
)+1;
1467 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1475 pidl
= _ILCreate(PT_VALUE
, (LPVOID
)buff
, len
+ len1
);
1477 /* set attributes */
1481 pData
= _ILGetDataPointer(pidl
);
1482 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1483 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1484 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1490 LPITEMIDLIST
_ILCreateFromPathA(LPCSTR szPath
)
1493 WIN32_FIND_DATAA stffile
;
1494 LPITEMIDLIST pidl
= NULL
;
1496 hFile
= FindFirstFileA(szPath
, &stffile
);
1497 if (hFile
!= INVALID_HANDLE_VALUE
)
1499 if (stffile
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1500 pidl
= _ILCreateFolder(&stffile
);
1502 pidl
= _ILCreateValue(&stffile
);
1508 LPITEMIDLIST
_ILCreateSpecial(LPCSTR szGUID
)
1512 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID
, &iid
)))
1514 ERR("%s is not a GUID\n", szGUID
);
1517 return _ILCreate(PT_MYCOMP
, &iid
, sizeof(IID
));
1520 /**************************************************************************
1522 * Creates a new PIDL
1523 * type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1525 * uInSize = size of data (raw)
1528 LPITEMIDLIST
_ILCreate(PIDLTYPE type
, LPCVOID pIn
, UINT uInSize
)
1530 LPITEMIDLIST pidlOut
= NULL
, pidlTemp
= NULL
;
1535 TRACE("(0x%02x %p %i)\n",type
,pIn
,uInSize
);
1544 uSize
= 2 + 2 + sizeof(GUID
);
1551 uSize
= 2 + 12 + uInSize
;
1554 FIXME("can't create type: 0x%08x\n",type
);
1558 if(!(pidlOut
= SHAlloc(uSize
+ 2))) return NULL
;
1559 ZeroMemory(pidlOut
, uSize
+ 2);
1560 pidlOut
->mkid
.cb
= uSize
;
1565 TRACE("- create Desktop\n");
1570 pData
= _ILGetDataPointer(pidlOut
);
1572 memcpy(&(pData
->u
.mycomp
.guid
), pIn
, uInSize
);
1573 TRACE("-- create GUID-pidl %s\n", debugstr_guid(&(pData
->u
.mycomp
.guid
)));
1577 pData
= _ILGetDataPointer(pidlOut
);
1579 pszDest
= _ILGetTextPointer(pidlOut
);
1580 memcpy(pszDest
, pIn
, uInSize
);
1581 TRACE("-- create Drive: %s\n",debugstr_a(pszDest
));
1586 pData
= _ILGetDataPointer(pidlOut
);
1588 pszDest
= _ILGetTextPointer(pidlOut
);
1589 memcpy(pszDest
, pIn
, uInSize
);
1590 TRACE("-- create Value: %s\n",debugstr_a(pszDest
));
1594 pidlTemp
= ILGetNext(pidlOut
);
1596 pidlTemp
->mkid
.cb
= 0x00;
1598 TRACE("-- (pidl=%p, size=%u)\n", pidlOut
, uSize
);
1602 /**************************************************************************
1605 * Gets the text for the drive eg. 'c:\'
1610 DWORD
_ILGetDrive(LPCITEMIDLIST pidl
,LPSTR pOut
, UINT uSize
)
1611 { TRACE("(%p,%p,%u)\n",pidl
,pOut
,uSize
);
1613 if(_ILIsMyComputer(pidl
))
1614 pidl
= ILGetNext(pidl
);
1616 if (pidl
&& _ILIsDrive(pidl
))
1617 return _ILSimpleGetText(pidl
, pOut
, uSize
);
1622 /**************************************************************************
1624 * ### 2. section testing pidls ###
1626 **************************************************************************
1629 * _ILIsSpecialFolder()
1635 BOOL
_ILIsDesktop(LPCITEMIDLIST pidl
)
1636 { TRACE("(%p)\n",pidl
);
1637 return pidl
&& pidl
->mkid
.cb
? 0 : 1;
1640 BOOL
_ILIsMyComputer(LPCITEMIDLIST pidl
)
1642 REFIID iid
= _ILGetGUIDPointer(pidl
);
1644 TRACE("(%p)\n",pidl
);
1647 return IsEqualIID(iid
, &CLSID_MyComputer
);
1651 BOOL
_ILIsSpecialFolder (LPCITEMIDLIST pidl
)
1653 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1654 TRACE("(%p)\n",pidl
);
1655 return (pidl
&& ( (lpPData
&& (PT_MYCOMP
== lpPData
->type
|| PT_SPECIAL
== lpPData
->type
)) ||
1656 (pidl
&& pidl
->mkid
.cb
== 0x00)
1660 BOOL
_ILIsDrive(LPCITEMIDLIST pidl
)
1661 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1662 TRACE("(%p)\n",pidl
);
1663 return (pidl
&& lpPData
&& (PT_DRIVE
== lpPData
->type
||
1664 PT_DRIVE1
== lpPData
->type
||
1665 PT_DRIVE2
== lpPData
->type
||
1666 PT_DRIVE3
== lpPData
->type
));
1669 BOOL
_ILIsFolder(LPCITEMIDLIST pidl
)
1670 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1671 TRACE("(%p)\n",pidl
);
1672 return (pidl
&& lpPData
&& (PT_FOLDER
== lpPData
->type
|| PT_FOLDER1
== lpPData
->type
));
1675 BOOL
_ILIsValue(LPCITEMIDLIST pidl
)
1676 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1677 TRACE("(%p)\n",pidl
);
1678 return (pidl
&& lpPData
&& PT_VALUE
== lpPData
->type
);
1681 /**************************************************************************
1684 BOOL
_ILIsPidlSimple ( LPCITEMIDLIST pidl
)
1688 if(! _ILIsDesktop(pidl
)) /* pidl=NULL or mkid.cb=0 */
1690 WORD len
= pidl
->mkid
.cb
;
1691 LPCITEMIDLIST pidlnext
= (LPCITEMIDLIST
) (((LPBYTE
)pidl
) + len
);
1692 if (pidlnext
->mkid
.cb
)
1696 TRACE("%s\n", ret
? "Yes" : "No");
1700 /**************************************************************************
1702 * ### 3. section getting values from pidls ###
1705 /**************************************************************************
1708 * gets the text for the first item in the pidl (eg. simple pidl)
1710 * returns the length of the string
1712 DWORD
_ILSimpleGetText (LPCITEMIDLIST pidl
, LPSTR szOut
, UINT uOutSize
)
1717 char szTemp
[MAX_PATH
];
1719 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1721 if (!pidl
) return 0;
1726 if (_ILIsDesktop(pidl
))
1729 if (HCR_GetClassNameA(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
1732 lstrcpynA(szOut
, szTemp
, uOutSize
);
1734 dwReturn
= strlen (szTemp
);
1737 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
1741 lstrcpynA(szOut
, szSrc
, uOutSize
);
1743 dwReturn
= strlen(szSrc
);
1745 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
1747 /* special folder */
1748 if ( HCR_GetClassNameA(riid
, szTemp
, MAX_PATH
) )
1751 lstrcpynA(szOut
, szTemp
, uOutSize
);
1753 dwReturn
= strlen (szTemp
);
1758 ERR("-- no text\n");
1761 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,debugstr_a(szOut
),dwReturn
);
1765 /**************************************************************************
1768 * gets the text for the first item in the pidl (eg. simple pidl)
1770 * returns the length of the string
1772 DWORD
_ILSimpleGetTextW (LPCITEMIDLIST pidl
, LPWSTR szOut
, UINT uOutSize
)
1775 char szTemp
[MAX_PATH
];
1777 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1779 dwReturn
= _ILSimpleGetText(pidl
, szTemp
, uOutSize
);
1781 if (!MultiByteToWideChar(CP_ACP
, 0, szTemp
, -1, szOut
, MAX_PATH
))
1784 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,debugstr_w(szOut
),dwReturn
);
1788 /**************************************************************************
1790 * ### 4. getting pointers to parts of pidls ###
1792 **************************************************************************
1793 * _ILGetDataPointer()
1795 LPPIDLDATA
_ILGetDataPointer(LPCITEMIDLIST pidl
)
1797 if(pidl
&& pidl
->mkid
.cb
!= 0x00)
1798 return (LPPIDLDATA
) &(pidl
->mkid
.abID
);
1802 /**************************************************************************
1803 * _ILGetTextPointer()
1804 * gets a pointer to the long filename string stored in the pidl
1806 LPSTR
_ILGetTextPointer(LPCITEMIDLIST pidl
)
1807 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1809 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
1813 switch (pdata
->type
)
1823 return (LPSTR
)&(pdata
->u
.drive
.szDriveName
);
1831 return (LPSTR
)&(pdata
->u
.file
.szNames
);
1836 case PT_NETPROVIDER
:
1838 return (LPSTR
)&(pdata
->u
.network
.szNames
);
1844 /**************************************************************************
1845 * _ILGetSTextPointer()
1846 * gets a pointer to the short filename string stored in the pidl
1848 LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
)
1849 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1851 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1855 switch (pdata
->type
)
1862 return (LPSTR
)(pdata
->u
.file
.szNames
+ strlen (pdata
->u
.file
.szNames
) + 1);
1865 return (LPSTR
)(pdata
->u
.network
.szNames
+ strlen (pdata
->u
.network
.szNames
) + 1);
1871 /**************************************************************************
1872 * _ILGetGUIDPointer()
1874 * returns reference to guid stored in some pidls
1876 REFIID
_ILGetGUIDPointer(LPCITEMIDLIST pidl
)
1878 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1880 TRACE("%p\n", pidl
);
1884 TRACE("pdata->type 0x%04x\n", pdata
->type
);
1885 switch (pdata
->type
)
1889 return (REFIID
) &(pdata
->u
.mycomp
.guid
);
1892 TRACE("Unknown pidl type 0x%04x\n", pdata
->type
);
1899 /*************************************************************************
1900 * _ILGetFileDateTime
1902 * Given the ItemIdList, get the FileTime
1905 * pidl [I] The ItemIDList
1906 * pFt [I] the resulted FILETIME of the file
1909 * True if Successful
1914 BOOL
_ILGetFileDateTime(LPCITEMIDLIST pidl
, FILETIME
*pFt
)
1916 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
1918 if(! pdata
) return FALSE
;
1920 switch (pdata
->type
)
1923 DosDateTimeToFileTime(pdata
->u
.folder
.uFileDate
, pdata
->u
.folder
.uFileTime
, pFt
);
1926 DosDateTimeToFileTime(pdata
->u
.file
.uFileDate
, pdata
->u
.file
.uFileTime
, pFt
);
1934 BOOL
_ILGetFileDate (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1940 if (_ILGetFileDateTime( pidl
, &ft
)) {
1941 FileTimeToLocalFileTime(&ft
, &lft
);
1942 FileTimeToSystemTime (&lft
, &time
);
1943 ret
= GetDateFormatA(LOCALE_USER_DEFAULT
,DATE_SHORTDATE
,&time
, NULL
, pOut
, uOutSize
);
1952 /*************************************************************************
1955 * Given the ItemIdList, get the FileSize
1958 * pidl [I] The ItemIDList
1959 * pOut [I] The buffer to save the result
1960 * uOutsize [I] The size of the buffer
1966 * pOut can be null when no string is needed
1969 DWORD
_ILGetFileSize (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1971 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
1974 if(! pdata
) return 0;
1976 switch (pdata
->type
)
1979 dwSize
= pdata
->u
.file
.dwFileSize
;
1980 if (pOut
) StrFormatByteSizeA(dwSize
, pOut
, uOutSize
);
1983 if (pOut
) *pOut
= 0x00;
1987 BOOL
_ILGetExtension (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1989 char szTemp
[MAX_PATH
];
1990 const char * pPoint
;
1991 LPCITEMIDLIST pidlTemp
=pidl
;
1993 TRACE("pidl=%p\n",pidl
);
1995 if (!pidl
) return FALSE
;
1997 pidlTemp
= ILFindLastID(pidl
);
1999 if (!_ILIsValue(pidlTemp
)) return FALSE
;
2000 if (!_ILSimpleGetText(pidlTemp
, szTemp
, MAX_PATH
)) return FALSE
;
2002 pPoint
= PathFindExtensionA(szTemp
);
2004 if (! *pPoint
) return FALSE
;
2007 lstrcpynA(pOut
, pPoint
, uOutSize
);
2013 /*************************************************************************
2016 * Given the ItemIdList, get the file type description
2019 * pidl [I] The ItemIDList (simple)
2020 * pOut [I] The buffer to save the result
2021 * uOutsize [I] The size of the buffer
2027 * This function copies as much as possible into the buffer.
2029 void _ILGetFileType(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2031 if(_ILIsValue(pidl
))
2038 if (_ILGetExtension (pidl
, sTemp
, 64))
2040 if (!( HCR_MapTypeToValueA(sTemp
, sTemp
, 64, TRUE
)
2041 && HCR_MapTypeToValueA(sTemp
, pOut
, uOutSize
, FALSE
)))
2043 lstrcpynA (pOut
, sTemp
, uOutSize
- 6);
2044 strcat (pOut
, "-file");
2050 lstrcpynA(pOut
, "Folder", uOutSize
);
2054 /*************************************************************************
2055 * _ILGetFileAttributes
2057 * Given the ItemIdList, get the Attrib string format
2060 * pidl [I] The ItemIDList
2061 * pOut [I] The buffer to save the result
2062 * uOutsize [I] The size of the Buffer
2068 * return value 0 in case of error is a valid return value
2071 DWORD
_ILGetFileAttributes(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2073 LPPIDLDATA pData
= _ILGetDataPointer(pidl
);
2077 if(! pData
) return 0;
2082 wAttrib
= pData
->u
.folder
.uFileAttribs
;
2085 wAttrib
= pData
->u
.file
.uFileAttribs
;
2092 if(wAttrib
& FILE_ATTRIBUTE_READONLY
)
2096 if(wAttrib
& FILE_ATTRIBUTE_HIDDEN
)
2100 if(wAttrib
& FILE_ATTRIBUTE_SYSTEM
)
2104 if(wAttrib
& FILE_ATTRIBUTE_ARCHIVE
)
2108 if(wAttrib
& FILE_ATTRIBUTE_COMPRESSED
)
2117 /*************************************************************************
2120 * free a aPidl struct
2122 void _ILFreeaPidl(LPITEMIDLIST
* apidl
, UINT cidl
)
2128 for (i
= 0; i
< cidl
; i
++) SHFree(apidl
[i
]);
2133 /*************************************************************************
2136 * copies an aPidl struct
2138 LPITEMIDLIST
* _ILCopyaPidl(LPCITEMIDLIST
* apidlsrc
, UINT cidl
)
2141 LPITEMIDLIST
* apidldest
= (LPITEMIDLIST
*)SHAlloc(cidl
* sizeof(LPITEMIDLIST
));
2142 if(!apidlsrc
) return NULL
;
2144 for (i
= 0; i
< cidl
; i
++)
2145 apidldest
[i
] = ILClone(apidlsrc
[i
]);
2150 /*************************************************************************
2151 * _ILCopyCidaToaPidl
2153 * creates aPidl from CIDA
2155 LPITEMIDLIST
* _ILCopyCidaToaPidl(LPITEMIDLIST
* pidl
, LPIDA cida
)
2158 LPITEMIDLIST
* dst
= (LPITEMIDLIST
*)SHAlloc(cida
->cidl
* sizeof(LPITEMIDLIST
));
2160 if(!dst
) return NULL
;
2163 *pidl
= ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[0]]));
2165 for (i
= 0; i
< cida
->cidl
; i
++)
2166 dst
[i
] = ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[i
+ 1]]));