4 * Copyright 1998 Juergen Schmied
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 * a pidl == NULL means desktop and is legal
25 #include <wine/config.h>
27 #define WIN32_NO_STATUS
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
36 #include <undocshell.h>
38 #include <shlguid_undoc.h>
39 #include <wine/debug.h>
40 #include <wine/unicode.h>
43 #include "shell32_main.h"
46 WINE_DEFAULT_DEBUG_CHANNEL(pidl
);
47 WINE_DECLARE_DEBUG_CHANNEL(shell
);
49 /* from comctl32.dll */
50 extern LPVOID WINAPI
Alloc(INT
);
51 extern BOOL WINAPI
Free(LPVOID
);
53 static LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
);
54 static LPWSTR
_ILGetTextPointerW(LPCITEMIDLIST pidl
);
56 /*************************************************************************
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 relative 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 static BOOL
ILGetDisplayNameExA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPSTR path
, DWORD type
)
76 WCHAR wPath
[MAX_PATH
];
78 TRACE("%p %p %p %d\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
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 %x\n", psf
, pidl
, path
, type
);
105 ret
= SHGetDesktopFolder(&lsf
);
112 case ILGDN_FORPARSING
:
113 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
119 flag
= SHGDN_INFOLDER
;
122 FIXME("Unknown type parameter = %x\n", type
);
123 flag
= SHGDN_FORPARSING
| SHGDN_FORADDRESSBAR
;
127 if (!*(const WORD
*)pidl
|| type
== ILGDN_FORPARSING
)
129 ret
= IShellFolder_GetDisplayNameOf(lsf
, pidl
, flag
, &strret
);
132 if(!StrRetToStrNW(path
, MAX_PATH
, &strret
, pidl
))
138 ret
= SHBindToParent(pidl
, &IID_IShellFolder
, (LPVOID
*)&psfParent
, &pidllast
);
141 ret
= IShellFolder_GetDisplayNameOf(psfParent
, pidllast
, flag
, &strret
);
144 if(!StrRetToStrNW(path
, MAX_PATH
, &strret
, pidllast
))
147 IShellFolder_Release(psfParent
);
151 TRACE("%p %p %s\n", psf
, pidl
, debugstr_w(path
));
154 IShellFolder_Release(lsf
);
155 return SUCCEEDED(ret
);
158 /*************************************************************************
159 * ILGetDisplayNameEx [SHELL32.186]
161 BOOL WINAPI
ILGetDisplayNameEx(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, LPVOID path
, DWORD type
)
163 TRACE_(shell
)("%p %p %p %d\n", psf
, pidl
, path
, type
);
165 if (SHELL_OsIsUnicode())
166 return ILGetDisplayNameExW(psf
, pidl
, path
, type
);
167 return ILGetDisplayNameExA(psf
, pidl
, path
, type
);
170 /*************************************************************************
171 * ILGetDisplayName [SHELL32.15]
173 BOOL WINAPI
ILGetDisplayName(LPCITEMIDLIST pidl
, LPVOID path
)
175 TRACE_(shell
)("%p %p\n", pidl
, path
);
177 if (SHELL_OsIsUnicode())
178 return ILGetDisplayNameExW(NULL
, pidl
, path
, ILGDN_FORPARSING
);
179 return ILGetDisplayNameExA(NULL
, pidl
, path
, ILGDN_FORPARSING
);
182 /*************************************************************************
183 * ILFindLastID [SHELL32.16]
186 * observed: pidl=Desktop return=pidl
188 LPITEMIDLIST WINAPI
ILFindLastID(LPCITEMIDLIST pidl
)
190 LPCITEMIDLIST pidlLast
= pidl
;
192 TRACE("(pidl=%p)\n",pidl
);
197 while (pidl
->mkid
.cb
)
200 pidl
= ILGetNext(pidl
);
202 return (LPITEMIDLIST
)pidlLast
;
205 /*************************************************************************
206 * ILRemoveLastID [SHELL32.17]
209 * when pidl=Desktop return=FALSE
211 BOOL WINAPI
ILRemoveLastID(LPITEMIDLIST pidl
)
213 TRACE_(shell
)("pidl=%p\n",pidl
);
215 if (_ILIsEmpty(pidl
))
217 ILFindLastID(pidl
)->mkid
.cb
= 0;
221 /*************************************************************************
222 * ILClone [SHELL32.18]
225 * duplicate an idlist
227 LPITEMIDLIST WINAPI
ILClone (LPCITEMIDLIST pidl
)
230 LPITEMIDLIST newpidl
;
235 len
= ILGetSize(pidl
);
236 newpidl
= SHAlloc(len
);
238 memcpy(newpidl
,pidl
,len
);
240 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
246 /*************************************************************************
247 * ILCloneFirst [SHELL32.19]
250 * duplicates the first idlist of a complex pidl
252 LPITEMIDLIST WINAPI
ILCloneFirst(LPCITEMIDLIST pidl
)
255 LPITEMIDLIST pidlNew
= NULL
;
257 TRACE("pidl=%p\n", pidl
);
263 pidlNew
= SHAlloc(len
+2);
266 memcpy(pidlNew
,pidl
,len
+2); /* 2 -> mind a desktop pidl */
269 ILGetNext(pidlNew
)->mkid
.cb
= 0x00;
272 TRACE("-- newpidl=%p\n",pidlNew
);
277 /*************************************************************************
278 * ILLoadFromStream (SHELL32.26)
281 * the first two bytes are the len, the pidl is following then
283 HRESULT WINAPI
ILLoadFromStream (IStream
* pStream
, LPITEMIDLIST
* ppPidl
)
287 HRESULT ret
= E_FAIL
;
290 TRACE_(shell
)("%p %p\n", pStream
, ppPidl
);
295 IStream_AddRef (pStream
);
297 if (SUCCEEDED(IStream_Read(pStream
, &wLen
, 2, &dwBytesRead
)))
299 TRACE("PIDL length is %d\n", wLen
);
302 *ppPidl
= SHAlloc (wLen
);
303 if (SUCCEEDED(IStream_Read(pStream
, *ppPidl
, wLen
, &dwBytesRead
)))
305 TRACE("Stream read OK\n");
310 WARN("reading pidl failed\n");
322 /* we are not yet fully compatible */
323 if (*ppPidl
&& !pcheck(*ppPidl
))
325 WARN("Check failed\n");
330 IStream_Release (pStream
);
335 /*************************************************************************
336 * ILSaveToStream (SHELL32.27)
339 * the first two bytes are the len, the pidl is following then
341 HRESULT WINAPI
ILSaveToStream (IStream
* pStream
, LPCITEMIDLIST pPidl
)
344 HRESULT ret
= E_FAIL
;
346 TRACE_(shell
)("%p %p\n", pStream
, pPidl
);
348 IStream_AddRef (pStream
);
350 wLen
= ILGetSize(pPidl
);
352 if (SUCCEEDED(IStream_Write(pStream
, &wLen
, 2, NULL
)))
354 if (SUCCEEDED(IStream_Write(pStream
, pPidl
, wLen
, NULL
)))
357 IStream_Release (pStream
);
362 /*************************************************************************
363 * SHILCreateFromPath [SHELL32.28]
365 * Create an ItemIDList from a path
370 * attributes [I/O] requested attributes on call and actual attributes when
371 * the function returns
374 * NO_ERROR if successful, or an OLE errer code otherwise
377 * Wrapper for IShellFolder_ParseDisplayName().
379 HRESULT WINAPI
SHILCreateFromPathA(LPCSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
381 WCHAR lpszDisplayName
[MAX_PATH
];
383 TRACE_(shell
)("%s %p 0x%08x\n", path
, ppidl
, attributes
? *attributes
: 0);
385 if (!MultiByteToWideChar(CP_ACP
, 0, path
, -1, lpszDisplayName
, MAX_PATH
))
386 lpszDisplayName
[MAX_PATH
-1] = 0;
388 return SHILCreateFromPathW(lpszDisplayName
, ppidl
, attributes
);
391 HRESULT WINAPI
SHILCreateFromPathW(LPCWSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
395 HRESULT ret
= E_FAIL
;
397 TRACE_(shell
)("%s %p 0x%08x\n", debugstr_w(path
), ppidl
, attributes
? *attributes
: 0);
399 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
401 ret
= IShellFolder_ParseDisplayName(sf
, 0, NULL
, (LPWSTR
)path
, &pchEaten
, ppidl
, attributes
);
402 IShellFolder_Release(sf
);
407 HRESULT WINAPI
SHILCreateFromPathAW (LPCVOID path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
409 if ( SHELL_OsIsUnicode())
410 return SHILCreateFromPathW (path
, ppidl
, attributes
);
411 return SHILCreateFromPathA (path
, ppidl
, attributes
);
414 /*************************************************************************
415 * SHCloneSpecialIDList [SHELL32.89]
417 * Create an ItemIDList to one of the special folders.
421 * nFolder [in] CSIDL_xxxxx
422 * fCreate [in] Create folder if it does not exist
425 * Success: The newly created pidl
426 * Failure: NULL, if inputs are invalid.
429 * exported by ordinal.
430 * Caller is responsible for deallocating the returned ItemIDList with the
431 * shells IMalloc interface, aka ILFree.
433 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND hwndOwner
, int nFolder
, BOOL fCreate
)
436 TRACE_(shell
)("(hwnd=%p,csidl=0x%x,%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
)
462 LPITEMIDLIST newpidl
;
467 len
= ILGetSize(pidl
);
468 newpidl
= Alloc(len
);
470 memcpy(newpidl
,pidl
,len
);
472 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
478 /*************************************************************************
479 * ILIsEqual [SHELL32.21]
482 BOOL WINAPI
ILIsEqual(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
484 char szData1
[MAX_PATH
];
485 char szData2
[MAX_PATH
];
487 LPCITEMIDLIST pidltemp1
= pidl1
;
488 LPCITEMIDLIST pidltemp2
= pidl2
;
490 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
493 * Explorer reads from registry directly (StreamMRU),
494 * so we can only check here
496 if (!pcheck(pidl1
) || !pcheck (pidl2
))
502 if (!pidl1
|| !pidl2
)
505 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
507 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
508 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
510 if (strcasecmp( szData1
, szData2
))
513 pidltemp1
= ILGetNext(pidltemp1
);
514 pidltemp2
= ILGetNext(pidltemp2
);
517 if (!pidltemp1
->mkid
.cb
&& !pidltemp2
->mkid
.cb
)
523 /*************************************************************************
524 * ILIsParent [SHELL32.23]
526 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
531 * bImmediate [I] only return true if the parent is the direct parent
535 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
539 * parent = a/b, child = a/b/c -> true, c is in folder a/b
540 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
541 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
542 * child = a/b -> false if bImmediate is true
543 * child = a/b -> true if bImmediate is false
545 BOOL WINAPI
ILIsParent(LPCITEMIDLIST pidlParent
, LPCITEMIDLIST pidlChild
, BOOL bImmediate
)
547 char szData1
[MAX_PATH
];
548 char szData2
[MAX_PATH
];
549 LPCITEMIDLIST pParent
= pidlParent
;
550 LPCITEMIDLIST pChild
= pidlChild
;
552 TRACE("%p %p %x\n", pidlParent
, pidlChild
, bImmediate
);
554 if (!pParent
|| !pChild
)
557 while (pParent
->mkid
.cb
&& pChild
->mkid
.cb
)
559 _ILSimpleGetText(pParent
, szData1
, MAX_PATH
);
560 _ILSimpleGetText(pChild
, szData2
, MAX_PATH
);
562 if (strcasecmp( szData1
, szData2
))
565 pParent
= ILGetNext(pParent
);
566 pChild
= ILGetNext(pChild
);
569 /* child has shorter name than parent */
570 if (pParent
->mkid
.cb
)
573 /* not immediate descent */
574 if ((!pChild
->mkid
.cb
|| ILGetNext(pChild
)->mkid
.cb
) && bImmediate
)
580 /*************************************************************************
581 * ILFindChild [SHELL32.24]
583 * Compares elements from pidl1 and pidl2.
590 * pidl1 is desktop pidl2
591 * pidl1 shorter pidl2 pointer to first different element of pidl2
592 * if there was at least one equal element
593 * pidl2 shorter pidl1 0
594 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
597 * exported by ordinal.
599 LPITEMIDLIST WINAPI
ILFindChild(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
601 char szData1
[MAX_PATH
];
602 char szData2
[MAX_PATH
];
604 LPCITEMIDLIST pidltemp1
= pidl1
;
605 LPCITEMIDLIST pidltemp2
= pidl2
;
606 LPCITEMIDLIST ret
=NULL
;
608 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
610 /* explorer reads from registry directly (StreamMRU),
611 so we can only check here */
612 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
)))
618 if (_ILIsDesktop(pidl1
))
624 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
626 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
627 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
629 if (strcasecmp(szData1
,szData2
))
632 pidltemp1
= ILGetNext(pidltemp1
);
633 pidltemp2
= ILGetNext(pidltemp2
);
637 if (pidltemp1
->mkid
.cb
)
638 ret
= NULL
; /* elements of pidl1 left*/
640 TRACE_(shell
)("--- %p\n", ret
);
641 return (LPITEMIDLIST
)ret
; /* pidl 1 is shorter */
644 /*************************************************************************
645 * ILCombine [SHELL32.25]
647 * Concatenates two complex ItemIDLists.
650 * pidl1 [I] first complex ItemIDLists
651 * pidl2 [I] complex ItemIDLists to append
654 * if both pidl's == NULL NULL
655 * if pidl1 == NULL cloned pidl2
656 * if pidl2 == NULL cloned pidl1
657 * otherwise new pidl with pidl2 appended to pidl1
660 * exported by ordinal.
661 * Does not destroy the passed in ItemIDLists!
663 LPITEMIDLIST WINAPI
ILCombine(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
666 LPITEMIDLIST pidlNew
;
668 TRACE("pidl=%p pidl=%p\n",pidl1
,pidl2
);
670 if (!pidl1
&& !pidl2
) return NULL
;
677 pidlNew
= ILClone(pidl2
);
683 pidlNew
= ILClone(pidl1
);
687 len1
= ILGetSize(pidl1
)-2;
688 len2
= ILGetSize(pidl2
);
689 pidlNew
= SHAlloc(len1
+len2
);
693 memcpy(pidlNew
,pidl1
,len1
);
694 memcpy(((BYTE
*)pidlNew
)+len1
,pidl2
,len2
);
697 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
701 /*************************************************************************
702 * SHGetRealIDL [SHELL32.98]
706 HRESULT WINAPI
SHGetRealIDL(LPSHELLFOLDER lpsf
, LPCITEMIDLIST pidlSimple
, LPITEMIDLIST
*pidlReal
)
708 IDataObject
* pDataObj
;
711 hr
= IShellFolder_GetUIObjectOf(lpsf
, 0, 1, &pidlSimple
,
712 &IID_IDataObject
, 0, (LPVOID
*)&pDataObj
);
718 fmt
.cfFormat
= RegisterClipboardFormatW(CFSTR_SHELLIDLISTW
);
720 fmt
.dwAspect
= DVASPECT_CONTENT
;
722 fmt
.tymed
= TYMED_HGLOBAL
;
724 hr
= IDataObject_GetData(pDataObj
, &fmt
, &medium
);
726 IDataObject_Release(pDataObj
);
730 /*assert(pida->cidl==1);*/
731 LPIDA pida
= GlobalLock(medium
.u
.hGlobal
);
733 LPCITEMIDLIST pidl_folder
= (LPCITEMIDLIST
) ((LPBYTE
)pida
+pida
->aoffset
[0]);
734 LPCITEMIDLIST pidl_child
= (LPCITEMIDLIST
) ((LPBYTE
)pida
+pida
->aoffset
[1]);
736 *pidlReal
= ILCombine(pidl_folder
, pidl_child
);
741 GlobalUnlock(medium
.u
.hGlobal
);
742 GlobalFree(medium
.u
.hGlobal
);
749 /*************************************************************************
750 * SHLogILFromFSIL [SHELL32.95]
753 * pild = CSIDL_DESKTOP ret = 0
754 * pild = CSIDL_DRIVES ret = 0
756 LPITEMIDLIST WINAPI
SHLogILFromFSIL(LPITEMIDLIST pidl
)
758 FIXME("(pidl=%p)\n",pidl
);
765 /*************************************************************************
766 * ILGetSize [SHELL32.152]
768 * Gets the byte size of an ItemIDList including zero terminator
771 * pidl [I] ItemIDList
774 * size of pidl in bytes
777 * exported by ordinal
779 UINT WINAPI
ILGetSize(LPCITEMIDLIST pidl
)
791 si
= (LPCSHITEMID
)(((const BYTE
*)si
)+si
->cb
);
795 TRACE("pidl=%p size=%u\n",pidl
, len
);
799 /*************************************************************************
800 * ILGetNext [SHELL32.153]
802 * Gets the next ItemID of an ItemIDList
805 * pidl [I] ItemIDList
810 * simple pidl -> pointer to 0x0000 element
813 * exported by ordinal.
815 LPITEMIDLIST WINAPI
ILGetNext(LPCITEMIDLIST pidl
)
826 pidl
= (LPCITEMIDLIST
) (((const BYTE
*)pidl
)+len
);
827 TRACE("-- %p\n", pidl
);
828 return (LPITEMIDLIST
)pidl
;
834 /*************************************************************************
835 * ILAppendID [SHELL32.154]
837 * Adds the single ItemID item to the ItemIDList indicated by pidl.
838 * If bEnd is FALSE, inserts the item in the front of the list,
839 * otherwise it adds the item to the end. (???)
842 * pidl [I] ItemIDList to extend
843 * item [I] ItemID to prepend/append
844 * bEnd [I] Indicates if the item should be appended
847 * Destroys the passed in idlist! (???)
849 LPITEMIDLIST WINAPI
ILAppendID(LPITEMIDLIST pidl
, LPCSHITEMID item
, BOOL bEnd
)
852 LPCITEMIDLIST itemid
= (LPCITEMIDLIST
)item
;
854 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl
,item
,bEnd
);
859 if (_ILIsDesktop(pidl
))
861 idlRet
= ILClone(itemid
);
867 idlRet
= ILCombine(pidl
, itemid
);
869 idlRet
= ILCombine(itemid
, pidl
);
875 /*************************************************************************
876 * ILFree [SHELL32.155]
878 * Frees memory (if not NULL) allocated by SHMalloc allocator
887 * exported by ordinal
889 void WINAPI
ILFree(LPITEMIDLIST pidl
)
891 TRACE("(pidl=%p)\n",pidl
);
895 /*************************************************************************
896 * ILGlobalFree [SHELL32.156]
898 * Frees memory (if not NULL) allocated by Alloc allocator
907 * exported by ordinal.
909 void WINAPI
ILGlobalFree( LPITEMIDLIST pidl
)
916 /*************************************************************************
917 * ILCreateFromPathA [SHELL32.189]
919 * Creates a complex ItemIDList from a path and returns it.
925 * the newly created complex ItemIDList or NULL if failed
928 * exported by ordinal.
930 LPITEMIDLIST WINAPI
ILCreateFromPathA (LPCSTR path
)
932 LPITEMIDLIST pidlnew
= NULL
;
934 TRACE_(shell
)("%s\n", debugstr_a(path
));
936 if (SUCCEEDED(SHILCreateFromPathA(path
, &pidlnew
, NULL
)))
941 /*************************************************************************
942 * ILCreateFromPathW [SHELL32.190]
944 * See ILCreateFromPathA.
946 LPITEMIDLIST WINAPI
ILCreateFromPathW (LPCWSTR path
)
948 LPITEMIDLIST pidlnew
= NULL
;
950 TRACE_(shell
)("%s\n", debugstr_w(path
));
952 if (SUCCEEDED(SHILCreateFromPathW(path
, &pidlnew
, NULL
)))
957 /*************************************************************************
958 * ILCreateFromPath [SHELL32.157]
960 LPITEMIDLIST WINAPI
ILCreateFromPathAW (LPCVOID path
)
962 if ( SHELL_OsIsUnicode())
963 return ILCreateFromPathW (path
);
964 return ILCreateFromPathA (path
);
967 /*************************************************************************
968 * _ILParsePathW [internal]
970 * Creates an ItemIDList from a path and returns it.
973 * path [I] path to parse and convert into an ItemIDList
974 * lpFindFile [I] pointer to buffer to initialize the FileSystem
975 * Bind Data object with
976 * bBindCtx [I] indicates to create a BindContext and assign a
977 * FileSystem Bind Data object
978 * ppidl [O] the newly create ItemIDList
979 * prgfInOut [I/O] requested attributes on input and actual
980 * attributes on return
983 * NO_ERROR on success or an OLE error code
986 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
987 * creates a BindContext object and assigns a FileSystem Bind Data object
988 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
989 * IShellFolder uses that FileSystem Bind Data object of the BindContext
990 * to pass data about the current path element to the next object. This
991 * is used to avoid having to verify the current path element on disk, so
992 * that creating an ItemIDList from a nonexistent path still can work.
994 static HRESULT
_ILParsePathW(LPCWSTR path
, LPWIN32_FIND_DATAW lpFindFile
,
995 BOOL bBindCtx
, LPITEMIDLIST
*ppidl
, LPDWORD prgfInOut
)
997 LPSHELLFOLDER pSF
= NULL
;
1001 TRACE("%s %p %d (%p)->%p (%p)->0x%x\n", debugstr_w(path
), lpFindFile
, bBindCtx
,
1002 ppidl
, ppidl
? *ppidl
: NULL
,
1003 prgfInOut
, prgfInOut
? *prgfInOut
: 0);
1005 ret
= SHGetDesktopFolder(&pSF
);
1009 if (lpFindFile
|| bBindCtx
)
1010 ret
= IFileSystemBindData_Constructor(lpFindFile
, &pBC
);
1014 ret
= IShellFolder_ParseDisplayName(pSF
, 0, pBC
, (LPOLESTR
)path
, NULL
, ppidl
, prgfInOut
);
1019 IBindCtx_Release(pBC
);
1023 IShellFolder_Release(pSF
);
1025 if (FAILED(ret
) && ppidl
)
1028 TRACE("%s %p 0x%x\n", debugstr_w(path
), ppidl
? *ppidl
: NULL
, prgfInOut
? *prgfInOut
: 0);
1033 /*************************************************************************
1034 * SHSimpleIDListFromPath [SHELL32.162]
1036 * Creates a simple ItemIDList from a path and returns it. This function
1037 * does not fail on nonexistent paths.
1040 * path [I] path to parse and convert into an ItemIDList
1043 * the newly created simple ItemIDList
1046 * Simple in the name does not mean a relative ItemIDList but rather a
1047 * fully qualified list, where only the file name is filled in and the
1048 * directory flag for those ItemID elements this is known about, eg.
1049 * it is not the last element in the ItemIDList or the actual directory
1051 * exported by ordinal.
1053 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathA(LPCSTR lpszPath
)
1055 LPITEMIDLIST pidl
= NULL
;
1056 LPWSTR wPath
= NULL
;
1059 TRACE("%s\n", debugstr_a(lpszPath
));
1063 len
= MultiByteToWideChar(CP_ACP
, 0, lpszPath
, -1, NULL
, 0);
1064 wPath
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1065 MultiByteToWideChar(CP_ACP
, 0, lpszPath
, -1, wPath
, len
);
1068 _ILParsePathW(wPath
, NULL
, TRUE
, &pidl
, NULL
);
1070 HeapFree(GetProcessHeap(), 0, wPath
);
1071 TRACE("%s %p\n", debugstr_a(lpszPath
), pidl
);
1075 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathW(LPCWSTR lpszPath
)
1077 LPITEMIDLIST pidl
= NULL
;
1079 TRACE("%s\n", debugstr_w(lpszPath
));
1081 _ILParsePathW(lpszPath
, NULL
, TRUE
, &pidl
, NULL
);
1082 TRACE("%s %p\n", debugstr_w(lpszPath
), pidl
);
1086 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathAW(LPCVOID lpszPath
)
1088 if ( SHELL_OsIsUnicode())
1089 return SHSimpleIDListFromPathW (lpszPath
);
1090 return SHSimpleIDListFromPathA (lpszPath
);
1093 /*************************************************************************
1094 * SHGetDataFromIDListA [SHELL32.247]
1097 * the pidl can be a simple one. since we can't get the path out of the pidl
1098 * we have to take all data from the pidl
1100 HRESULT WINAPI
SHGetDataFromIDListA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
,
1101 int nFormat
, LPVOID dest
, int len
)
1103 LPSTR filename
, shortname
;
1104 WIN32_FIND_DATAA
* pfd
;
1106 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1110 return E_INVALIDARG
;
1114 case SHGDFIL_FINDDATA
:
1117 if (_ILIsDrive(pidl
) || _ILIsSpecialFolder(pidl
))
1118 return E_INVALIDARG
;
1120 if (len
< sizeof(WIN32_FIND_DATAA
))
1121 return E_INVALIDARG
;
1123 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
1124 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1125 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1126 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1128 filename
= _ILGetTextPointer(pidl
);
1129 shortname
= _ILGetSTextPointer(pidl
);
1132 lstrcpynA(pfd
->cFileName
, filename
, sizeof(pfd
->cFileName
));
1134 pfd
->cFileName
[0] = '\0';
1137 lstrcpynA(pfd
->cAlternateFileName
, shortname
, sizeof(pfd
->cAlternateFileName
));
1139 pfd
->cAlternateFileName
[0] = '\0';
1142 case SHGDFIL_NETRESOURCE
:
1143 case SHGDFIL_DESCRIPTIONID
:
1144 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1148 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1151 return E_INVALIDARG
;
1154 /*************************************************************************
1155 * SHGetDataFromIDListW [SHELL32.248]
1158 HRESULT WINAPI
SHGetDataFromIDListW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
,
1159 int nFormat
, LPVOID dest
, int len
)
1161 LPSTR filename
, shortname
;
1162 WIN32_FIND_DATAW
* pfd
= dest
;
1164 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
1169 return E_INVALIDARG
;
1173 case SHGDFIL_FINDDATA
:
1176 if (_ILIsDrive(pidl
))
1177 return E_INVALIDARG
;
1179 if (len
< sizeof(WIN32_FIND_DATAW
))
1180 return E_INVALIDARG
;
1182 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAW
));
1183 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
1184 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
1185 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
1187 filename
= _ILGetTextPointer(pidl
);
1188 shortname
= _ILGetSTextPointer(pidl
);
1191 pfd
->cFileName
[0] = '\0';
1192 else if (!MultiByteToWideChar(CP_ACP
, 0, filename
, -1, pfd
->cFileName
, MAX_PATH
))
1193 pfd
->cFileName
[MAX_PATH
-1] = 0;
1196 pfd
->cAlternateFileName
[0] = '\0';
1197 else if (!MultiByteToWideChar(CP_ACP
, 0, shortname
, -1, pfd
->cAlternateFileName
, 14))
1198 pfd
->cAlternateFileName
[13] = 0;
1201 case SHGDFIL_NETRESOURCE
:
1202 case SHGDFIL_DESCRIPTIONID
:
1203 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
1207 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
1210 return E_INVALIDARG
;
1213 /*************************************************************************
1214 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1218 * pszPath [OUT] path
1221 * path from a passed PIDL.
1224 * NULL returns FALSE
1225 * desktop pidl gives path to desktop directory back
1226 * special pidls returning FALSE
1228 BOOL WINAPI
SHGetPathFromIDListA(LPCITEMIDLIST pidl
, LPSTR pszPath
)
1230 WCHAR wszPath
[MAX_PATH
];
1233 bSuccess
= SHGetPathFromIDListW(pidl
, wszPath
);
1234 WideCharToMultiByte(CP_ACP
, 0, wszPath
, -1, pszPath
, MAX_PATH
, NULL
, NULL
);
1239 /*************************************************************************
1240 * SHGetPathFromIDListW [SHELL32.@]
1242 * See SHGetPathFromIDListA.
1244 BOOL WINAPI
SHGetPathFromIDListW(LPCITEMIDLIST pidl
, LPWSTR pszPath
)
1247 LPCITEMIDLIST pidlLast
;
1248 LPSHELLFOLDER psfFolder
;
1252 TRACE_(shell
)("(pidl=%p,%p)\n", pidl
, pszPath
);
1259 hr
= SHBindToParent(pidl
, &IID_IShellFolder
, (VOID
**)&psfFolder
, &pidlLast
);
1262 ERR("SHBindToParent failed: %x\n", hr
);
1266 dwAttributes
= SFGAO_FILESYSTEM
;
1267 hr
= IShellFolder_GetAttributesOf(psfFolder
, 1, &pidlLast
, &dwAttributes
);
1268 if (FAILED(hr
) || !(dwAttributes
& SFGAO_FILESYSTEM
)) {
1269 WARN("Wrong dwAttributes or GetAttributesOf failed: %x\n", hr
);
1270 IShellFolder_Release(psfFolder
);
1274 hr
= IShellFolder_GetDisplayNameOf(psfFolder
, pidlLast
, SHGDN_FORPARSING
, &strret
);
1275 IShellFolder_Release(psfFolder
);
1276 if (FAILED(hr
)) return FALSE
;
1278 hr
= StrRetToBufW(&strret
, pidlLast
, pszPath
, MAX_PATH
);
1280 TRACE_(shell
)("-- %s, 0x%08x\n",debugstr_w(pszPath
), hr
);
1281 return SUCCEEDED(hr
);
1284 /*************************************************************************
1285 * SHBindToParent [shell version 5.0]
1287 HRESULT WINAPI
SHBindToParent(LPCITEMIDLIST pidl
, REFIID riid
, LPVOID
*ppv
, LPCITEMIDLIST
*ppidlLast
)
1289 IShellFolder
* psfDesktop
;
1292 TRACE_(shell
)("pidl=%p\n", pidl
);
1296 return E_INVALIDARG
;
1302 hr
= SHGetDesktopFolder(&psfDesktop
);
1306 if (_ILIsPidlSimple(pidl
))
1308 /* we are on desktop level */
1309 hr
= IShellFolder_QueryInterface(psfDesktop
, riid
, ppv
);
1313 LPITEMIDLIST pidlParent
= ILClone(pidl
);
1314 ILRemoveLastID(pidlParent
);
1315 hr
= IShellFolder_BindToObject(psfDesktop
, pidlParent
, NULL
, riid
, ppv
);
1316 SHFree (pidlParent
);
1319 IShellFolder_Release(psfDesktop
);
1321 if (SUCCEEDED(hr
) && ppidlLast
)
1322 *ppidlLast
= ILFindLastID(pidl
);
1324 TRACE_(shell
)("-- psf=%p pidl=%p ret=0x%08x\n", *ppv
, (ppidlLast
)?*ppidlLast
:NULL
, hr
);
1328 /*************************************************************************
1329 * SHParseDisplayName [shell version 6.0]
1331 HRESULT WINAPI
SHParseDisplayName(LPCWSTR pszName
, IBindCtx
*pbc
,
1332 LPITEMIDLIST
*ppidl
, SFGAOF sfgaoIn
, SFGAOF
*psfgaoOut
)
1334 IShellFolder
*psfDesktop
;
1336 ULONG dwAttr
=sfgaoIn
;
1339 return E_INVALIDARG
;
1341 if (!pszName
|| !psfgaoOut
)
1344 return E_INVALIDARG
;
1347 hr
= SHGetDesktopFolder(&psfDesktop
);
1354 hr
= IShellFolder_ParseDisplayName(psfDesktop
, (HWND
)NULL
, pbc
, (LPOLESTR
)pszName
, (ULONG
*)NULL
, ppidl
, &dwAttr
);
1356 IShellFolder_Release(psfDesktop
);
1359 *psfgaoOut
= dwAttr
;
1368 /*************************************************************************
1369 * SHGetNameFromIDList [SHELL32.@]
1371 HRESULT WINAPI
SHGetNameFromIDList(PCIDLIST_ABSOLUTE pidl
, SIGDN sigdnName
, PWSTR
*ppszName
)
1373 IShellFolder
*psfparent
;
1374 LPCITEMIDLIST child_pidl
;
1378 TRACE("%p 0x%08x %p\n", pidl
, sigdnName
, ppszName
);
1381 ret
= SHBindToParent(pidl
, &IID_IShellFolder
, (void**)&psfparent
, &child_pidl
);
1386 /* sigdnName & 0xffff */
1387 case SIGDN_NORMALDISPLAY
: /* SHGDN_NORMAL */
1388 case SIGDN_PARENTRELATIVEPARSING
: /* SHGDN_INFOLDER | SHGDN_FORPARSING */
1389 case SIGDN_PARENTRELATIVEEDITING
: /* SHGDN_INFOLDER | SHGDN_FOREDITING */
1390 case SIGDN_DESKTOPABSOLUTEPARSING
: /* SHGDN_FORPARSING */
1391 case SIGDN_DESKTOPABSOLUTEEDITING
: /* SHGDN_FOREDITING | SHGDN_FORADDRESSBAR*/
1392 case SIGDN_PARENTRELATIVEFORADDRESSBAR
: /* SIGDN_INFOLDER | SHGDN_FORADDRESSBAR */
1393 case SIGDN_PARENTRELATIVE
: /* SIGDN_INFOLDER */
1395 disp_name
.uType
= STRRET_WSTR
;
1396 ret
= IShellFolder_GetDisplayNameOf(psfparent
, child_pidl
,
1400 ret
= StrRetToStrW(&disp_name
, pidl
, ppszName
);
1404 case SIGDN_FILESYSPATH
:
1405 *ppszName
= CoTaskMemAlloc(sizeof(WCHAR
)*MAX_PATH
);
1406 if(SHGetPathFromIDListW(pidl
, *ppszName
))
1408 TRACE("Got string %s\n", debugstr_w(*ppszName
));
1413 CoTaskMemFree(*ppszName
);
1420 FIXME("Unsupported SIGDN %x\n", sigdnName
);
1424 IShellFolder_Release(psfparent
);
1429 /*************************************************************************
1430 * SHGetIDListFromObject [SHELL32.@]
1432 HRESULT WINAPI
SHGetIDListFromObject(IUnknown
*punk
, PIDLIST_ABSOLUTE
*ppidl
)
1434 IPersistIDList
*ppersidl
;
1435 IPersistFolder2
*ppf2
;
1441 return E_NOINTERFACE
;
1445 /* Try IPersistIDList */
1446 ret
= IUnknown_QueryInterface(punk
, &IID_IPersistIDList
, (void**)&ppersidl
);
1449 TRACE("IPersistIDList (%p)\n", ppersidl
);
1450 ret
= IPersistIDList_GetIDList(ppersidl
, ppidl
);
1451 IPersistIDList_Release(ppersidl
);
1456 /* Try IPersistFolder2 */
1457 ret
= IUnknown_QueryInterface(punk
, &IID_IPersistFolder2
, (void**)&ppf2
);
1460 TRACE("IPersistFolder2 (%p)\n", ppf2
);
1461 ret
= IPersistFolder2_GetCurFolder(ppf2
, ppidl
);
1462 IPersistFolder2_Release(ppf2
);
1467 /* Try IDataObject */
1468 ret
= IUnknown_QueryInterface(punk
, &IID_IDataObject
, (void**)&pdo
);
1472 TRACE("IDataObject (%p)\n", pdo
);
1473 ret
= SHGetItemFromDataObject(pdo
, DOGIF_ONLY_IF_ONE
,
1474 &IID_IShellItem
, (void**)&psi
);
1477 ret
= SHGetIDListFromObject((IUnknown
*)psi
, ppidl
);
1478 IShellItem_Release(psi
);
1480 IDataObject_Release(pdo
);
1486 /* Try IFolderView */
1487 ret
= IUnknown_QueryInterface(punk
, &IID_IFolderView
, (void**)&pfv
);
1491 TRACE("IFolderView (%p)\n", pfv
);
1492 ret
= IFolderView_GetFolder(pfv
, &IID_IShellFolder
, (void**)&psf
);
1495 /* We might be able to get IPersistFolder2 from a shellfolder. */
1496 ret
= SHGetIDListFromObject((IUnknown
*)psf
, ppidl
);
1498 IFolderView_Release(pfv
);
1505 #endif /* !__REACTOS__ */
1507 /**************************************************************************
1509 * internal functions
1511 * ### 1. section creating pidls ###
1513 *************************************************************************
1516 /* Basic PIDL constructor. Allocates size + 5 bytes, where:
1517 * - two bytes are SHITEMID.cb
1518 * - one byte is PIDLDATA.type
1519 * - two bytes are the NULL PIDL terminator
1520 * Sets type of the returned PIDL to type.
1522 static LPITEMIDLIST
_ILAlloc(PIDLTYPE type
, unsigned int size
)
1524 LPITEMIDLIST pidlOut
= NULL
;
1526 pidlOut
= SHAlloc(size
+ 5);
1530 LPITEMIDLIST pidlNext
;
1532 ZeroMemory(pidlOut
, size
+ 5);
1533 pidlOut
->mkid
.cb
= size
+ 3;
1535 pData
= _ILGetDataPointer(pidlOut
);
1539 pidlNext
= ILGetNext(pidlOut
);
1541 pidlNext
->mkid
.cb
= 0x00;
1542 TRACE("-- (pidl=%p, size=%u)\n", pidlOut
, size
);
1548 LPITEMIDLIST
_ILCreateDesktop(void)
1559 LPITEMIDLIST
_ILCreateMyComputer(void)
1562 return _ILCreateGuid(PT_GUID
, &CLSID_MyComputer
);
1565 LPITEMIDLIST
_ILCreateMyDocuments(void)
1568 return _ILCreateGuid(PT_GUID
, &CLSID_MyDocuments
);
1571 LPITEMIDLIST
_ILCreateIExplore(void)
1574 return _ILCreateGuid(PT_GUID
, &CLSID_Internet
);
1577 LPITEMIDLIST
_ILCreateControlPanel(void)
1579 LPITEMIDLIST parent
= _ILCreateGuid(PT_GUID
, &CLSID_MyComputer
), ret
= NULL
;
1584 LPITEMIDLIST cpl
= _ILCreateGuid(PT_SHELLEXT
, &CLSID_ControlPanel
);
1588 ret
= ILCombine(parent
, cpl
);
1596 LPITEMIDLIST
_ILCreatePrinters(void)
1598 LPITEMIDLIST parent
= _ILCreateGuid(PT_GUID
, &CLSID_MyComputer
), ret
= NULL
;
1603 LPITEMIDLIST printers
= _ILCreateGuid(PT_YAGUID
, &CLSID_Printers
);
1607 ret
= ILCombine(parent
, printers
);
1615 LPITEMIDLIST
_ILCreateNetwork(void)
1618 return _ILCreateGuid(PT_GUID
, &CLSID_NetworkPlaces
);
1621 LPITEMIDLIST
_ILCreateBitBucket(void)
1624 return _ILCreateGuid(PT_GUID
, &CLSID_RecycleBin
);
1627 LPITEMIDLIST
_ILCreateAdminTools(void)
1630 return _ILCreateGuid(PT_GUID
, &CLSID_AdminFolderShortcut
); //FIXME
1633 LPITEMIDLIST
_ILCreateGuid(PIDLTYPE type
, REFIID guid
)
1635 LPITEMIDLIST pidlOut
;
1637 if (type
== PT_SHELLEXT
|| type
== PT_GUID
|| type
== PT_YAGUID
)
1639 pidlOut
= _ILAlloc(type
, sizeof(GUIDStruct
));
1642 LPPIDLDATA pData
= _ILGetDataPointer(pidlOut
);
1644 pData
->u
.guid
.guid
= *guid
;
1645 TRACE("-- create GUID-pidl %s\n",
1646 debugstr_guid(&(pData
->u
.guid
.guid
)));
1651 WARN("%d: invalid type for GUID\n", type
);
1657 LPITEMIDLIST
_ILCreateGuidFromStrA(LPCSTR szGUID
)
1661 if (FAILED(SHCLSIDFromStringA(szGUID
, &iid
)))
1663 ERR("%s is not a GUID\n", szGUID
);
1666 return _ILCreateGuid(PT_GUID
, &iid
);
1669 LPITEMIDLIST
_ILCreateGuidFromStrW(LPCWSTR szGUID
)
1673 if (FAILED(SHCLSIDFromStringW(szGUID
, &iid
)))
1675 ERR("%s is not a GUID\n", debugstr_w(szGUID
));
1678 return _ILCreateGuid(PT_GUID
, &iid
);
1681 LPITEMIDLIST
_ILCreateFromFindDataW( const WIN32_FIND_DATAW
*wfd
)
1683 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1684 DWORD len
, len1
, wlen
, alen
;
1691 TRACE("(%s, %s)\n",debugstr_w(wfd
->cAlternateFileName
), debugstr_w(wfd
->cFileName
));
1693 /* prepare buffer with both names */
1694 len
= WideCharToMultiByte(CP_ACP
,0,wfd
->cFileName
,-1,buff
,MAX_PATH
,NULL
,NULL
);
1695 len1
= WideCharToMultiByte(CP_ACP
,0,wfd
->cAlternateFileName
,-1, buff
+len
, sizeof(buff
)-len
, NULL
, NULL
);
1698 type
= (wfd
->dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ? PT_FOLDER
: PT_VALUE
;
1700 wlen
= lstrlenW(wfd
->cFileName
) + 1;
1701 pidl
= _ILAlloc(type
, FIELD_OFFSET(FileStruct
, szNames
[alen
+ (alen
& 1)]) +
1702 FIELD_OFFSET(FileStructW
, wszName
[wlen
]) + sizeof(WORD
));
1705 LPPIDLDATA pData
= _ILGetDataPointer(pidl
);
1706 FileStruct
*fs
= &pData
->u
.file
;
1710 FileTimeToDosDateTime( &wfd
->ftLastWriteTime
, &fs
->uFileDate
, &fs
->uFileTime
);
1711 fs
->dwFileSize
= wfd
->nFileSizeLow
;
1712 fs
->uFileAttribs
= wfd
->dwFileAttributes
;
1713 memcpy(fs
->szNames
, buff
, alen
);
1715 fsw
= (FileStructW
*)(pData
->u
.file
.szNames
+ alen
+ (alen
& 0x1));
1716 fsw
->cbLen
= FIELD_OFFSET(FileStructW
, wszName
[wlen
]) + sizeof(WORD
);
1717 FileTimeToDosDateTime( &wfd
->ftCreationTime
, &fsw
->uCreationDate
, &fsw
->uCreationTime
);
1718 FileTimeToDosDateTime( &wfd
->ftLastAccessTime
, &fsw
->uLastAccessDate
, &fsw
->uLastAccessTime
);
1719 memcpy(fsw
->wszName
, wfd
->cFileName
, wlen
* sizeof(WCHAR
));
1721 pOffsetW
= (WORD
*)((LPBYTE
)pidl
+ pidl
->mkid
.cb
- sizeof(WORD
));
1722 *pOffsetW
= (LPBYTE
)fsw
- (LPBYTE
)pidl
;
1723 TRACE("-- Set Value: %s\n",debugstr_w(fsw
->wszName
));
1729 HRESULT
_ILCreateFromPathW(LPCWSTR szPath
, LPITEMIDLIST
* ppidl
)
1732 WIN32_FIND_DATAW stffile
;
1735 return E_INVALIDARG
;
1737 hFile
= FindFirstFileW(szPath
, &stffile
);
1738 if (hFile
== INVALID_HANDLE_VALUE
)
1739 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
1743 *ppidl
= _ILCreateFromFindDataW(&stffile
);
1745 return *ppidl
? S_OK
: E_OUTOFMEMORY
;
1748 LPITEMIDLIST
_ILCreateDrive(LPCWSTR lpszNew
)
1750 LPITEMIDLIST pidlOut
;
1752 TRACE("(%s)\n",debugstr_w(lpszNew
));
1754 pidlOut
= _ILAlloc(PT_DRIVE
, sizeof(DriveStruct
));
1759 pszDest
= _ILGetTextPointer(pidlOut
);
1762 strcpy(pszDest
, "x:\\");
1763 pszDest
[0]=toupperW(lpszNew
[0]);
1764 TRACE("-- create Drive: %s\n", debugstr_a(pszDest
));
1770 LPITEMIDLIST
_ILCreateEntireNetwork(void)
1772 LPITEMIDLIST pidlOut
;
1776 pidlOut
= _ILAlloc(PT_NETWORK
, FIELD_OFFSET(PIDLDATA
, u
.network
.szNames
[sizeof("Entire Network")]));
1779 LPPIDLDATA pData
= _ILGetDataPointer(pidlOut
);
1781 pData
->u
.network
.dummy
= 0;
1782 strcpy(pData
->u
.network
.szNames
, "Entire Network");
1787 /**************************************************************************
1790 * Gets the text for the drive eg. 'c:\'
1795 DWORD
_ILGetDrive(LPCITEMIDLIST pidl
,LPSTR pOut
, UINT uSize
)
1797 TRACE("(%p,%p,%u)\n",pidl
,pOut
,uSize
);
1799 if(_ILIsMyComputer(pidl
))
1800 pidl
= ILGetNext(pidl
);
1802 if (pidl
&& _ILIsDrive(pidl
))
1803 return _ILSimpleGetText(pidl
, pOut
, uSize
);
1808 /**************************************************************************
1810 * ### 2. section testing pidls ###
1812 **************************************************************************
1816 * _ILIsSpecialFolder()
1822 BOOL
_ILIsUnicode(LPCITEMIDLIST pidl
)
1824 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1826 TRACE("(%p)\n",pidl
);
1828 return (pidl
&& lpPData
&& PT_VALUEW
== lpPData
->type
);
1831 BOOL
_ILIsDesktop(LPCITEMIDLIST pidl
)
1833 TRACE("(%p)\n",pidl
);
1835 return !pidl
|| !pidl
->mkid
.cb
;
1838 BOOL
_ILIsMyDocuments(LPCITEMIDLIST pidl
)
1840 IID
*iid
= _ILGetGUIDPointer(pidl
);
1842 TRACE("(%p)\n", pidl
);
1845 return IsEqualIID(iid
, &CLSID_MyDocuments
);
1849 BOOL
_ILIsNetHood(LPCITEMIDLIST pidl
)
1851 IID
*iid
= _ILGetGUIDPointer(pidl
);
1853 TRACE("(%p)\n", pidl
);
1856 return IsEqualIID(iid
, &CLSID_NetworkPlaces
);
1860 BOOL
_ILIsMyComputer(LPCITEMIDLIST pidl
)
1862 REFIID iid
= _ILGetGUIDPointer(pidl
);
1864 TRACE("(%p)\n",pidl
);
1867 return IsEqualIID(iid
, &CLSID_MyComputer
);
1871 BOOL
_ILIsBitBucket(LPCITEMIDLIST pidl
)
1873 IID
*iid
= _ILGetGUIDPointer(pidl
);
1875 TRACE("(%p)\n", pidl
);
1878 return IsEqualIID(iid
, &CLSID_RecycleBin
);
1882 BOOL
_ILIsSpecialFolder (LPCITEMIDLIST pidl
)
1884 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1886 TRACE("(%p)\n",pidl
);
1888 return (pidl
&& ( (lpPData
&& (PT_GUID
== lpPData
->type
|| PT_SHELLEXT
== lpPData
->type
|| PT_YAGUID
== lpPData
->type
)) ||
1889 (pidl
&& pidl
->mkid
.cb
== 0x00)
1893 BOOL
_ILIsDrive(LPCITEMIDLIST pidl
)
1895 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1897 TRACE("(%p)\n",pidl
);
1899 return (pidl
&& lpPData
&& (PT_DRIVE
== lpPData
->type
||
1900 PT_DRIVE1
== lpPData
->type
||
1901 PT_DRIVE2
== lpPData
->type
||
1902 PT_DRIVE3
== lpPData
->type
));
1905 BOOL
_ILIsFolder(LPCITEMIDLIST pidl
)
1907 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1909 TRACE("(%p)\n",pidl
);
1911 return (pidl
&& lpPData
&& (PT_FOLDER
== lpPData
->type
|| PT_FOLDER1
== lpPData
->type
));
1914 BOOL
_ILIsValue(LPCITEMIDLIST pidl
)
1916 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1918 TRACE("(%p)\n",pidl
);
1920 return (pidl
&& lpPData
&& PT_VALUE
== lpPData
->type
);
1923 BOOL
_ILIsCPanelStruct(LPCITEMIDLIST pidl
)
1925 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1927 TRACE("(%p)\n",pidl
);
1929 return (pidl
&& lpPData
&& (lpPData
->type
== 0));
1932 /**************************************************************************
1935 BOOL
_ILIsPidlSimple(LPCITEMIDLIST pidl
)
1939 if(! _ILIsDesktop(pidl
)) /* pidl=NULL or mkid.cb=0 */
1941 WORD len
= pidl
->mkid
.cb
;
1942 LPCITEMIDLIST pidlnext
= (LPCITEMIDLIST
) (((const BYTE
*)pidl
) + len
);
1944 if (pidlnext
->mkid
.cb
)
1948 TRACE("%s\n", ret
? "Yes" : "No");
1952 /**************************************************************************
1954 * ### 3. section getting values from pidls ###
1957 /**************************************************************************
1960 * gets the text for the first item in the pidl (eg. simple pidl)
1962 * returns the length of the string
1964 DWORD
_ILSimpleGetText (LPCITEMIDLIST pidl
, LPSTR szOut
, UINT uOutSize
)
1970 char szTemp
[MAX_PATH
];
1972 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1980 if (_ILIsDesktop(pidl
))
1983 if (HCR_GetClassNameA(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
1986 lstrcpynA(szOut
, szTemp
, uOutSize
);
1988 dwReturn
= strlen (szTemp
);
1991 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
1995 lstrcpynA(szOut
, szSrc
, uOutSize
);
1997 dwReturn
= strlen(szSrc
);
1999 else if (( szSrcW
= _ILGetTextPointerW(pidl
) ))
2001 /* unicode filesystem */
2002 WideCharToMultiByte(CP_ACP
,0,szSrcW
, -1, szTemp
, MAX_PATH
, NULL
, NULL
);
2005 lstrcpynA(szOut
, szTemp
, uOutSize
);
2007 dwReturn
= strlen (szTemp
);
2009 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
2011 /* special folder */
2012 if ( HCR_GetClassNameA(riid
, szTemp
, MAX_PATH
) )
2015 lstrcpynA(szOut
, szTemp
, uOutSize
);
2017 dwReturn
= strlen (szTemp
);
2022 ERR("-- no text\n");
2025 TRACE("-- (%p=%s 0x%08x)\n",szOut
,debugstr_a(szOut
),dwReturn
);
2029 /**************************************************************************
2032 * gets the text for the first item in the pidl (eg. simple pidl)
2034 * returns the length of the string
2036 DWORD
_ILSimpleGetTextW (LPCITEMIDLIST pidl
, LPWSTR szOut
, UINT uOutSize
)
2039 FileStructW
*pFileStructW
= _ILGetFileStructW(pidl
);
2041 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
2044 lstrcpynW(szOut
, pFileStructW
->wszName
, uOutSize
);
2045 dwReturn
= lstrlenW(pFileStructW
->wszName
);
2048 WCHAR szTemp
[MAX_PATH
];
2059 if (_ILIsDesktop(pidl
))
2062 if (HCR_GetClassNameW(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
2065 lstrcpynW(szOut
, szTemp
, uOutSize
);
2067 dwReturn
= lstrlenW (szTemp
);
2070 else if (( szSrcW
= _ILGetTextPointerW(pidl
) ))
2072 /* unicode filesystem */
2074 lstrcpynW(szOut
, szSrcW
, uOutSize
);
2076 dwReturn
= lstrlenW(szSrcW
);
2078 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
2081 MultiByteToWideChar(CP_ACP
, 0, szSrc
, -1, szTemp
, MAX_PATH
);
2084 lstrcpynW(szOut
, szTemp
, uOutSize
);
2086 dwReturn
= lstrlenW (szTemp
);
2088 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
2090 /* special folder */
2091 if ( HCR_GetClassNameW(riid
, szTemp
, MAX_PATH
) )
2094 lstrcpynW(szOut
, szTemp
, uOutSize
);
2096 dwReturn
= lstrlenW (szTemp
);
2101 ERR("-- no text\n");
2105 TRACE("-- (%p=%s 0x%08x)\n",szOut
,debugstr_w(szOut
),dwReturn
);
2109 /**************************************************************************
2111 * ### 4. getting pointers to parts of pidls ###
2113 **************************************************************************
2114 * _ILGetDataPointer()
2116 LPPIDLDATA
_ILGetDataPointer(LPCITEMIDLIST pidl
)
2118 if(!_ILIsEmpty(pidl
))
2119 return (LPPIDLDATA
)pidl
->mkid
.abID
;
2123 /**************************************************************************
2124 * _ILGetTextPointerW()
2125 * gets a pointer to the unicode long filename string stored in the pidl
2127 static LPWSTR
_ILGetTextPointerW(LPCITEMIDLIST pidl
)
2129 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
2131 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2136 switch (pdata
->type
)
2147 /*return (LPSTR)&(pdata->u.drive.szDriveName);*/
2155 /*return (LPSTR)&(pdata->u.file.szNames);*/
2161 case PT_NETPROVIDER
:
2163 /*return (LPSTR)&(pdata->u.network.szNames);*/
2167 return (LPWSTR
)pdata
->u
.file
.szNames
;
2173 /**************************************************************************
2174 * _ILGetTextPointer()
2175 * gets a pointer to the long filename string stored in the pidl
2177 LPSTR
_ILGetTextPointer(LPCITEMIDLIST pidl
)
2179 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
2181 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2186 switch (pdata
->type
)
2197 return pdata
->u
.drive
.szDriveName
;
2204 return pdata
->u
.file
.szNames
;
2209 case PT_NETPROVIDER
:
2211 return pdata
->u
.network
.szNames
;
2213 #ifdef __REACTOS__ /* r54423 */
2215 return pdata
->u
.cpanel
.szName
;
2221 /**************************************************************************
2222 * _ILGetSTextPointer()
2223 * gets a pointer to the short filename string stored in the pidl
2225 static LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
)
2227 /* TRACE(pidl,"(pidl%p)\n", pidl); */
2229 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
2234 switch (pdata
->type
)
2240 return pdata
->u
.file
.szNames
+ strlen (pdata
->u
.file
.szNames
) + 1;
2243 return pdata
->u
.network
.szNames
+ strlen (pdata
->u
.network
.szNames
) + 1;
2248 /**************************************************************************
2249 * _ILGetGUIDPointer()
2251 * returns reference to guid stored in some pidls
2253 IID
* _ILGetGUIDPointer(LPCITEMIDLIST pidl
)
2255 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
2257 TRACE("%p\n", pidl
);
2262 TRACE("pdata->type 0x%04x\n", pdata
->type
);
2263 switch (pdata
->type
)
2268 return &(pdata
->u
.guid
.guid
);
2271 TRACE("Unknown pidl type 0x%04x\n", pdata
->type
);
2277 /******************************************************************************
2278 * _ILGetFileStructW [Internal]
2280 * Get pointer the a SHITEMID's FileStructW field if present
2283 * pidl [I] The SHITEMID
2286 * Success: Pointer to pidl's FileStructW field.
2289 FileStructW
* _ILGetFileStructW(LPCITEMIDLIST pidl
) {
2290 FileStructW
*pFileStructW
;
2293 if (!(_ILIsValue(pidl
) || _ILIsFolder(pidl
)))
2296 cbOffset
= *(const WORD
*)((const BYTE
*)pidl
+ pidl
->mkid
.cb
- sizeof(WORD
));
2297 pFileStructW
= (FileStructW
*)((LPBYTE
)pidl
+ cbOffset
);
2299 /* Currently I don't see a fool prove way to figure out if a pidl is for sure of WinXP
2300 * style with a FileStructW member. If we switch all our shellfolder-implementations to
2301 * the new format, this won't be a problem. For now, we do as many sanity checks as possible. */
2302 if ((cbOffset
& 0x1) || /* FileStructW member is word aligned in the pidl */
2303 /* FileStructW is positioned after FileStruct */
2304 cbOffset
< sizeof(pidl
->mkid
.cb
) + sizeof(PIDLTYPE
) + sizeof(FileStruct
) ||
2305 /* There has to be enough space at cbOffset in the pidl to hold FileStructW and cbOffset */
2306 cbOffset
> pidl
->mkid
.cb
- sizeof(cbOffset
) - sizeof(FileStructW
) ||
2307 pidl
->mkid
.cb
!= cbOffset
+ pFileStructW
->cbLen
)
2309 WARN("Invalid pidl format (cbOffset = %d)!\n", cbOffset
);
2313 return pFileStructW
;
2316 /*************************************************************************
2317 * _ILGetFileDateTime
2319 * Given the ItemIdList, get the FileTime
2322 * pidl [I] The ItemIDList
2323 * pFt [I] the resulted FILETIME of the file
2326 * True if Successful
2331 BOOL
_ILGetFileDateTime(LPCITEMIDLIST pidl
, FILETIME
*pFt
)
2333 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2338 switch (pdata
->type
)
2342 DosDateTimeToFileTime(pdata
->u
.file
.uFileDate
, pdata
->u
.file
.uFileTime
, pFt
);
2350 BOOL
_ILGetFileDate (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2356 if (_ILGetFileDateTime( pidl
, &ft
))
2358 FileTimeToLocalFileTime(&ft
, &lft
);
2359 FileTimeToSystemTime (&lft
, &time
);
2361 ret
= GetDateFormatA(LOCALE_USER_DEFAULT
,DATE_SHORTDATE
,&time
, NULL
, pOut
, uOutSize
);
2364 /* Append space + time without seconds */
2366 GetTimeFormatA(LOCALE_USER_DEFAULT
, TIME_NOSECONDS
, &time
, NULL
, &pOut
[ret
], uOutSize
- ret
);
2377 /*************************************************************************
2380 * Given the ItemIdList, get the FileSize
2383 * pidl [I] The ItemIDList
2384 * pOut [I] The buffer to save the result
2385 * uOutsize [I] The size of the buffer
2391 * pOut can be null when no string is needed
2394 DWORD
_ILGetFileSize (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2396 LPPIDLDATA pdata
= _ILGetDataPointer(pidl
);
2402 switch (pdata
->type
)
2405 dwSize
= pdata
->u
.file
.dwFileSize
;
2407 StrFormatKBSizeA(dwSize
, pOut
, uOutSize
);
2415 BOOL
_ILGetExtension (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2417 char szTemp
[MAX_PATH
];
2418 const char * pPoint
;
2419 LPCITEMIDLIST pidlTemp
=pidl
;
2421 TRACE("pidl=%p\n",pidl
);
2426 pidlTemp
= ILFindLastID(pidl
);
2428 if (!_ILIsValue(pidlTemp
))
2430 if (!_ILSimpleGetText(pidlTemp
, szTemp
, MAX_PATH
))
2433 pPoint
= PathFindExtensionA(szTemp
);
2439 lstrcpynA(pOut
, pPoint
, uOutSize
);
2445 /*************************************************************************
2448 * Given the ItemIdList, get the file type description
2451 * pidl [I] The ItemIDList (simple)
2452 * pOut [I] The buffer to save the result
2453 * uOutsize [I] The size of the buffer
2459 * This function copies as much as possible into the buffer.
2461 void _ILGetFileType(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2463 #ifdef __REACTOS__ /* r32966 */
2467 if(_ILIsValue(pidl
))
2473 #ifdef __REACTOS__ /* r32966 */
2474 if (_ILGetExtension (pidl
, sType
, 64))
2476 if (HCR_MapTypeToValueA(sType
, sTemp
, 64, TRUE
))
2478 /* retrieve description */
2479 if(HCR_MapTypeToValueA(sTemp
, pOut
, uOutSize
, FALSE
))
2482 /* display Ext-file as description */
2483 strcpy(pOut
, sType
);
2485 /* load localized file string */
2487 if(LoadStringA(shell32_hInstance
, IDS_SHV_COLUMN1
, sTemp
, 64))
2491 strcat(pOut
, sTemp
);
2495 if (_ILGetExtension (pidl
, sTemp
, 64))
2497 if (!( HCR_MapTypeToValueA(sTemp
, sTemp
, 64, TRUE
)
2498 && HCR_MapTypeToValueA(sTemp
, pOut
, uOutSize
, FALSE
)))
2500 lstrcpynA (pOut
, sTemp
, uOutSize
- 6);
2501 strcat (pOut
, "-file");
2507 #ifdef __REACTOS__ /* r32966 */
2510 LoadStringA(shell32_hInstance
, IDS_DIRECTORY
, pOut
, uOutSize
);
2511 /* make sure its null terminated */
2512 pOut
[uOutSize
-1] = '\0';
2515 lstrcpynA(pOut
, "Folder", uOutSize
);
2519 /*************************************************************************
2520 * _ILGetFileAttributes
2522 * Given the ItemIdList, get the Attrib string format
2525 * pidl [I] The ItemIDList
2526 * pOut [I] The buffer to save the result
2527 * uOutsize [I] The size of the Buffer
2533 * return value 0 in case of error is a valid return value
2536 DWORD
_ILGetFileAttributes(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
2538 LPPIDLDATA pData
= _ILGetDataPointer(pidl
);
2549 wAttrib
= pData
->u
.file
.uFileAttribs
;
2556 if(wAttrib
& FILE_ATTRIBUTE_READONLY
)
2558 if(wAttrib
& FILE_ATTRIBUTE_HIDDEN
)
2560 if(wAttrib
& FILE_ATTRIBUTE_SYSTEM
)
2562 if(wAttrib
& FILE_ATTRIBUTE_ARCHIVE
)
2564 if(wAttrib
& FILE_ATTRIBUTE_COMPRESSED
)
2571 /*************************************************************************
2574 * frees an aPidl struct
2576 void _ILFreeaPidl(LPITEMIDLIST
* apidl
, UINT cidl
)
2582 for (i
= 0; i
< cidl
; i
++)
2588 /*************************************************************************
2591 * copies an aPidl struct
2593 LPITEMIDLIST
* _ILCopyaPidl(const LPCITEMIDLIST
* apidlsrc
, UINT cidl
)
2596 LPITEMIDLIST
*apidldest
;
2601 apidldest
= SHAlloc(cidl
* sizeof(LPITEMIDLIST
));
2603 for (i
= 0; i
< cidl
; i
++)
2604 apidldest
[i
] = ILClone(apidlsrc
[i
]);
2609 /*************************************************************************
2610 * _ILCopyCidaToaPidl
2612 * creates aPidl from CIDA
2614 LPITEMIDLIST
* _ILCopyCidaToaPidl(LPITEMIDLIST
* pidl
, const CIDA
* cida
)
2619 dst
= SHAlloc(cida
->cidl
* sizeof(LPITEMIDLIST
));
2624 *pidl
= ILClone((LPCITEMIDLIST
)(&((const BYTE
*)cida
)[cida
->aoffset
[0]]));
2626 for (i
= 0; i
< cida
->cidl
; i
++)
2627 dst
[i
] = ILClone((LPCITEMIDLIST
)(&((const BYTE
*)cida
)[cida
->aoffset
[i
+ 1]]));