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"
36 #include "undocshell.h"
37 #include "shell32_main.h"
43 #include "wine/debug.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(pidl
);
46 WINE_DECLARE_DEBUG_CHANNEL(shell
);
48 /* from comctl32.dll */
49 extern LPVOID WINAPI
Alloc(INT
);
50 extern BOOL WINAPI
Free(LPVOID
);
52 /*************************************************************************
53 * ILGetDisplayName [SHELL32.15]
55 BOOL WINAPI
ILGetDisplayName(LPCITEMIDLIST pidl
,LPSTR path
)
57 TRACE_(shell
)("pidl=%p %p semi-stub\n",pidl
,path
);
58 return SHGetPathFromIDListA(pidl
, path
);
60 /*************************************************************************
61 * ILFindLastID [SHELL32.16]
64 * observed: pidl=Desktop return=pidl
66 LPITEMIDLIST WINAPI
ILFindLastID(LPITEMIDLIST pidl
)
67 { LPITEMIDLIST pidlLast
= pidl
;
69 TRACE("(pidl=%p)\n",pidl
);
74 pidl
= ILGetNext(pidl
);
78 /*************************************************************************
79 * ILRemoveLastID [SHELL32.17]
82 * when pidl=Desktop return=FALSE
84 BOOL WINAPI
ILRemoveLastID(LPCITEMIDLIST pidl
)
86 TRACE_(shell
)("pidl=%p\n",pidl
);
88 if (!pidl
|| !pidl
->mkid
.cb
)
90 ILFindLastID(pidl
)->mkid
.cb
= 0;
94 /*************************************************************************
95 * ILClone [SHELL32.18]
100 LPITEMIDLIST WINAPI
ILClone (LPCITEMIDLIST pidl
)
102 LPITEMIDLIST newpidl
;
107 len
= ILGetSize(pidl
);
108 newpidl
= (LPITEMIDLIST
)SHAlloc(len
);
110 memcpy(newpidl
,pidl
,len
);
112 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
117 /*************************************************************************
118 * ILCloneFirst [SHELL32.19]
121 * duplicates the first idlist of a complex pidl
123 LPITEMIDLIST WINAPI
ILCloneFirst(LPCITEMIDLIST pidl
)
125 LPITEMIDLIST pidlNew
= NULL
;
127 TRACE("pidl=%p \n",pidl
);
133 pidlNew
= (LPITEMIDLIST
) SHAlloc (len
+2);
136 memcpy(pidlNew
,pidl
,len
+2); /* 2 -> mind a desktop pidl */
139 ILGetNext(pidlNew
)->mkid
.cb
= 0x00;
142 TRACE("-- newpidl=%p\n",pidlNew
);
147 /*************************************************************************
148 * ILLoadFromStream (SHELL32.26)
151 * the first two bytes are the len, the pidl is following then
153 HRESULT WINAPI
ILLoadFromStream (IStream
* pStream
, LPITEMIDLIST
* ppPidl
)
156 HRESULT ret
= E_FAIL
;
159 TRACE_(shell
)("%p %p\n", pStream
, ppPidl
);
166 IStream_AddRef (pStream
);
168 if (SUCCEEDED(IStream_Read(pStream
, (LPVOID
)&wLen
, 2, &dwBytesRead
)))
169 { *ppPidl
= SHAlloc (wLen
);
170 if (SUCCEEDED(IStream_Read(pStream
, *ppPidl
, wLen
, &dwBytesRead
)))
179 /* we are not yet fully compatible */
180 if (!pcheck(*ppPidl
))
186 IStream_Release (pStream
);
191 /*************************************************************************
192 * ILSaveToStream (SHELL32.27)
195 * the first two bytes are the len, the pidl is following then
197 HRESULT WINAPI
ILSaveToStream (IStream
* pStream
, LPCITEMIDLIST pPidl
)
201 HRESULT ret
= E_FAIL
;
203 TRACE_(shell
)("%p %p\n", pStream
, pPidl
);
205 IStream_AddRef (pStream
);
208 while (pidl
->mkid
.cb
)
210 wLen
+= sizeof(WORD
) + pidl
->mkid
.cb
;
211 pidl
= ILGetNext(pidl
);
214 if (SUCCEEDED(IStream_Write(pStream
, (LPVOID
)&wLen
, 2, NULL
)))
216 if (SUCCEEDED(IStream_Write(pStream
, pPidl
, wLen
, NULL
)))
222 IStream_Release (pStream
);
227 /*************************************************************************
228 * SHILCreateFromPath [SHELL32.28]
231 * wraper for IShellFolder::ParseDisplayName()
233 HRESULT WINAPI
SHILCreateFromPathA (LPCSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
235 WCHAR lpszDisplayName
[MAX_PATH
];
237 HRESULT ret
= E_FAIL
;
239 TRACE_(shell
)("%s %p 0x%08lx\n",path
,ppidl
,attributes
?*attributes
:0);
241 if (!MultiByteToWideChar( CP_ACP
, 0, path
, -1, lpszDisplayName
, MAX_PATH
))
242 lpszDisplayName
[MAX_PATH
-1] = 0;
244 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
246 ret
= IShellFolder_ParseDisplayName(sf
,0, NULL
,lpszDisplayName
,&pchEaten
,ppidl
,attributes
);
247 IShellFolder_Release(sf
);
251 HRESULT WINAPI
SHILCreateFromPathW (LPCWSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
254 HRESULT ret
= E_FAIL
;
256 TRACE_(shell
)("%s %p 0x%08lx\n",debugstr_w(path
),ppidl
,attributes
?*attributes
:0);
258 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
260 ret
= IShellFolder_ParseDisplayName(sf
,0, NULL
, (LPWSTR
) path
, &pchEaten
, ppidl
, attributes
);
261 IShellFolder_Release(sf
);
265 HRESULT WINAPI
SHILCreateFromPathAW (LPCVOID path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
267 if ( SHELL_OsIsUnicode())
268 return SHILCreateFromPathW (path
, ppidl
, attributes
);
269 return SHILCreateFromPathA (path
, ppidl
, attributes
);
272 /*************************************************************************
273 * SHCloneSpecialIDList [SHELL32.89]
277 * nFolder [in] CSIDL_xxxxx ??
282 * exported by ordinal
284 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND hwndOwner
,DWORD nFolder
,DWORD x3
)
285 { LPITEMIDLIST ppidl
;
286 WARN_(shell
)("(hwnd=%p,csidl=0x%lx,0x%lx):semi-stub.\n",
287 hwndOwner
,nFolder
,x3
);
289 SHGetSpecialFolderLocation(hwndOwner
, nFolder
, &ppidl
);
294 /*************************************************************************
295 * ILGlobalClone [SHELL32.20]
298 LPITEMIDLIST WINAPI
ILGlobalClone(LPCITEMIDLIST pidl
)
300 LPITEMIDLIST newpidl
;
305 len
= ILGetSize(pidl
);
306 newpidl
= (LPITEMIDLIST
)Alloc(len
);
308 memcpy(newpidl
,pidl
,len
);
310 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
316 /*************************************************************************
317 * ILIsEqual [SHELL32.21]
320 BOOL WINAPI
ILIsEqual(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
322 char szData1
[MAX_PATH
];
323 char szData2
[MAX_PATH
];
325 LPITEMIDLIST pidltemp1
= pidl1
;
326 LPITEMIDLIST pidltemp2
= pidl2
;
328 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
330 /* explorer reads from registry directly (StreamMRU),
331 so we can only check here */
332 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
))) return FALSE
;
337 if ( (!pidl1
) || (!pidl2
) ) return FALSE
;
339 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
341 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
342 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
344 if (strcasecmp ( szData1
, szData2
)!=0 )
347 pidltemp1
= ILGetNext(pidltemp1
);
348 pidltemp2
= ILGetNext(pidltemp2
);
351 if (!pidltemp1
->mkid
.cb
&& !pidltemp2
->mkid
.cb
)
358 /*************************************************************************
359 * ILIsParent [SHELL32.23]
361 * parent=a/b child=a/b/c -> true, c is in folder a/b
362 * child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
363 * child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
365 BOOL WINAPI
ILIsParent( LPCITEMIDLIST pidlParent
, LPCITEMIDLIST pidlChild
, BOOL bImmediate
)
367 char szData1
[MAX_PATH
];
368 char szData2
[MAX_PATH
];
370 LPITEMIDLIST pParent
= pidlParent
;
371 LPITEMIDLIST pChild
= pidlChild
;
373 TRACE("%p %p %x\n", pidlParent
, pidlChild
, bImmediate
);
375 while (pParent
->mkid
.cb
&& pChild
->mkid
.cb
)
377 _ILSimpleGetText(pParent
, szData1
, MAX_PATH
);
378 _ILSimpleGetText(pChild
, szData2
, MAX_PATH
);
380 if (strcasecmp ( szData1
, szData2
)!=0 )
383 pParent
= ILGetNext(pParent
);
384 pChild
= ILGetNext(pChild
);
387 if ( pParent
->mkid
.cb
|| ! pChild
->mkid
.cb
) /* child shorter or has equal length to parent */
390 if ( ILGetNext(pChild
)->mkid
.cb
&& bImmediate
) /* not immediate descent */
396 /*************************************************************************
397 * ILFindChild [SHELL32.24]
400 * Compares elements from pidl1 and pidl2.
402 * pidl1 is desktop pidl2
403 * pidl1 shorter pidl2 pointer to first different element of pidl2
404 * if there was at least one equal element
405 * pidl2 shorter pidl1 0
406 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
408 LPITEMIDLIST WINAPI
ILFindChild(LPCITEMIDLIST pidl1
,LPCITEMIDLIST pidl2
)
410 char szData1
[MAX_PATH
];
411 char szData2
[MAX_PATH
];
413 LPITEMIDLIST pidltemp1
= pidl1
;
414 LPITEMIDLIST pidltemp2
= pidl2
;
415 LPITEMIDLIST ret
=NULL
;
417 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
419 /* explorer reads from registry directly (StreamMRU),
420 so we can only check here */
421 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
)))
427 if ( _ILIsDesktop(pidl1
) )
433 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
435 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
436 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
438 if (strcasecmp(szData1
,szData2
))
441 pidltemp1
= ILGetNext(pidltemp1
);
442 pidltemp2
= ILGetNext(pidltemp2
);
446 if (pidltemp1
->mkid
.cb
)
448 ret
= NULL
; /* elements of pidl1 left*/
451 TRACE_(shell
)("--- %p\n", ret
);
452 return ret
; /* pidl 1 is shorter */
455 /*************************************************************************
456 * ILCombine [SHELL32.25]
459 * Concatenates two complex idlists.
460 * The pidl is the first one, pidlsub the next one
461 * Does not destroy the passed in idlists!
463 LPITEMIDLIST WINAPI
ILCombine(LPCITEMIDLIST pidl1
,LPCITEMIDLIST pidl2
)
466 LPITEMIDLIST pidlNew
;
468 TRACE("pidl=%p pidl=%p\n",pidl1
,pidl2
);
470 if(!pidl1
&& !pidl2
) return NULL
;
477 pidlNew
= ILClone(pidl2
);
483 pidlNew
= ILClone(pidl1
);
487 len1
= ILGetSize(pidl1
)-2;
488 len2
= ILGetSize(pidl2
);
489 pidlNew
= SHAlloc(len1
+len2
);
493 memcpy(pidlNew
,pidl1
,len1
);
494 memcpy(((BYTE
*)pidlNew
)+len1
,pidl2
,len2
);
497 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
500 /*************************************************************************
501 * SHGetRealIDL [SHELL32.98]
505 LPITEMIDLIST WINAPI
SHGetRealIDL(LPSHELLFOLDER lpsf
, LPITEMIDLIST pidl
, DWORD z
)
507 FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf
,pidl
,z
);
513 /*************************************************************************
514 * SHLogILFromFSIL [SHELL32.95]
517 * pild = CSIDL_DESKTOP ret = 0
518 * pild = CSIDL_DRIVES ret = 0
520 LPITEMIDLIST WINAPI
SHLogILFromFSIL(LPITEMIDLIST pidl
)
522 FIXME("(pidl=%p)\n",pidl
);
529 /*************************************************************************
530 * ILGetSize [SHELL32.152]
531 * gets the byte size of an idlist including zero terminator (pidl)
540 * exported by ordinal
542 DWORD WINAPI
ILGetSize(LPITEMIDLIST pidl
)
544 LPSHITEMID si
= &(pidl
->mkid
);
550 si
= (LPSHITEMID
)(((LPBYTE
)si
)+si
->cb
);
554 TRACE("pidl=%p size=%lu\n",pidl
, len
);
558 /*************************************************************************
559 * ILGetNext [SHELL32.153]
560 * gets the next simple pidl of a complex pidl
562 * observed return values:
565 * simple pidl -> pointer to 0x0000 element
568 LPITEMIDLIST WINAPI
ILGetNext(LPITEMIDLIST pidl
)
579 pidl
= (LPITEMIDLIST
) (((LPBYTE
)pidl
)+len
);
580 TRACE("-- %p\n", pidl
);
586 /*************************************************************************
587 * ILAppend [SHELL32.154]
590 * Adds the single item to the idlist indicated by pidl.
591 * if bEnd is 0, adds the item to the front of the list,
592 * otherwise adds the item to the end. (???)
593 * Destroys the passed in idlist! (???)
595 LPITEMIDLIST WINAPI
ILAppend(LPITEMIDLIST pidl
,LPCITEMIDLIST item
,BOOL bEnd
)
599 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl
,item
,bEnd
);
604 if (_ILIsDesktop(pidl
))
606 idlRet
= ILClone(item
);
614 idlRet
=ILCombine(pidl
,item
);
618 idlRet
=ILCombine(item
,pidl
);
624 /*************************************************************************
625 * ILFree [SHELL32.155]
628 * free_check_ptr - frees memory (if not NULL)
629 * allocated by SHMalloc allocator
630 * exported by ordinal
632 DWORD WINAPI
ILFree(LPITEMIDLIST pidl
)
634 TRACE("(pidl=0x%08lx)\n",(DWORD
)pidl
);
636 if(!pidl
) return FALSE
;
640 /*************************************************************************
641 * ILGlobalFree [SHELL32.156]
644 void WINAPI
ILGlobalFree( LPCITEMIDLIST pidl
)
651 /*************************************************************************
652 * ILCreateFromPath [SHELL32.157]
655 LPITEMIDLIST WINAPI
ILCreateFromPathA (LPCSTR path
)
657 LPITEMIDLIST pidlnew
;
658 DWORD attributes
= 0;
660 TRACE_(shell
)("%s\n",path
);
662 if (SUCCEEDED (SHILCreateFromPathA (path
, &pidlnew
, &attributes
)))
666 LPITEMIDLIST WINAPI
ILCreateFromPathW (LPCWSTR path
)
668 LPITEMIDLIST pidlnew
;
669 DWORD attributes
= 0;
671 TRACE_(shell
)("%s\n",debugstr_w(path
));
673 if (SUCCEEDED (SHILCreateFromPathW (path
, &pidlnew
, &attributes
)))
677 LPITEMIDLIST WINAPI
ILCreateFromPathAW (LPCVOID path
)
679 if ( SHELL_OsIsUnicode())
680 return ILCreateFromPathW (path
);
681 return ILCreateFromPathA (path
);
683 /*************************************************************************
684 * SHSimpleIDListFromPath [SHELL32.162]
686 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathA (LPCSTR lpszPath
)
688 LPITEMIDLIST pidl
=NULL
;
690 WIN32_FIND_DATAA stffile
;
692 TRACE("path=%s\n", lpszPath
);
694 if (!lpszPath
) return NULL
;
696 hFile
= FindFirstFileA(lpszPath
, &stffile
);
698 if ( hFile
!= INVALID_HANDLE_VALUE
)
700 if (stffile
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
702 pidl
= _ILCreateFolder (&stffile
);
706 pidl
= _ILCreateValue (&stffile
);
712 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathW (LPCWSTR lpszPath
)
714 char lpszTemp
[MAX_PATH
];
715 TRACE("path=%s\n",debugstr_w(lpszPath
));
717 if (!WideCharToMultiByte( CP_ACP
, 0, lpszPath
, -1, lpszTemp
, sizeof(lpszTemp
), NULL
, NULL
))
718 lpszTemp
[sizeof(lpszTemp
)-1] = 0;
720 return SHSimpleIDListFromPathA (lpszTemp
);
723 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathAW (LPCVOID lpszPath
)
725 if ( SHELL_OsIsUnicode())
726 return SHSimpleIDListFromPathW (lpszPath
);
727 return SHSimpleIDListFromPathA (lpszPath
);
730 /*************************************************************************
731 * SHGetSpecialFolderLocation [SHELL32.@]
733 * gets the folder locations from the registry and creates a pidl
734 * creates missing reg keys and directories
738 * nFolder [I] CSIDL_xxxxx
739 * ppidl [O] PIDL of a special folder
742 HRESULT WINAPI
SHGetSpecialFolderLocation(
745 LPITEMIDLIST
* ppidl
)
747 CHAR szPath
[MAX_PATH
];
748 HRESULT hr
= E_INVALIDARG
;
750 TRACE_(shell
)("(%p,0x%x,%p)\n", hwndOwner
,nFolder
,ppidl
);
758 *ppidl
= _ILCreateDesktop();
762 *ppidl
= _ILCreateMyComputer();
766 *ppidl
= _ILCreateNetwork ();
770 *ppidl
= _ILCreateControl ();
774 *ppidl
= _ILCreatePrinter ();
777 case CSIDL_BITBUCKET
:
778 *ppidl
= _ILCreateBitBucket ();
782 if (SHGetSpecialFolderPathA(hwndOwner
, szPath
, nFolder
, TRUE
))
785 TRACE_(shell
)("Value=%s\n",szPath
);
786 hr
= SHILCreateFromPathA(szPath
, ppidl
, &attributes
);
789 if(*ppidl
) hr
= NOERROR
;
792 TRACE_(shell
)("-- (new pidl %p)\n",*ppidl
);
796 /*************************************************************************
797 * SHGetFolderLocation [SHELL32.@]
800 * the pidl can be a simple one. since we cant get the path out of the pidl
801 * we have to take all data from the pidl
803 HRESULT WINAPI
SHGetFolderLocation(
810 FIXME("%p 0x%08x %p 0x%08lx %p\n",
811 hwnd
, csidl
, hToken
, dwFlags
, ppidl
);
812 return SHGetSpecialFolderLocation(hwnd
, csidl
, ppidl
);
815 /*************************************************************************
816 * SHGetDataFromIDListA [SHELL32.247]
819 * the pidl can be a simple one. since we cant get the path out of the pidl
820 * we have to take all data from the pidl
822 HRESULT WINAPI
SHGetDataFromIDListA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
824 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
827 if (!psf
|| !dest
) return E_INVALIDARG
;
831 case SHGDFIL_FINDDATA
:
833 WIN32_FIND_DATAA
* pfd
= dest
;
835 if ( len
< sizeof (WIN32_FIND_DATAA
)) return E_INVALIDARG
;
837 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
838 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
839 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
840 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
841 lstrcpynA(pfd
->cFileName
,_ILGetTextPointer(pidl
), MAX_PATH
);
842 lstrcpynA(pfd
->cAlternateFileName
,_ILGetSTextPointer(pidl
), 14);
846 case SHGDFIL_NETRESOURCE
:
847 case SHGDFIL_DESCRIPTIONID
:
848 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
852 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
857 /*************************************************************************
858 * SHGetDataFromIDListW [SHELL32.248]
861 HRESULT WINAPI
SHGetDataFromIDListW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
863 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
867 if (! psf
|| !dest
) return E_INVALIDARG
;
871 case SHGDFIL_FINDDATA
:
873 WIN32_FIND_DATAW
* pfd
= dest
;
875 if ( len
< sizeof (WIN32_FIND_DATAW
)) return E_INVALIDARG
;
877 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
878 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
879 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
880 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
881 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetTextPointer(pidl
), -1,
882 pfd
->cFileName
, MAX_PATH
))
883 pfd
->cFileName
[MAX_PATH
-1] = 0;
884 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetSTextPointer(pidl
), -1,
885 pfd
->cAlternateFileName
, 14 ))
886 pfd
->cFileName
[13] = 0;
889 case SHGDFIL_NETRESOURCE
:
890 case SHGDFIL_DESCRIPTIONID
:
891 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
895 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
901 /*************************************************************************
902 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
909 * path from a passed PIDL.
913 * desktop pidl gives path to desktopdirectory back
914 * special pidls returning FALSE
916 BOOL WINAPI
SHGetPathFromIDListA(LPCITEMIDLIST pidl
, LPSTR pszPath
)
920 LPSHELLFOLDER shellfolder
;
922 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
925 if (!pidl
) return FALSE
;
927 hr
= SHGetDesktopFolder(&shellfolder
);
928 if (SUCCEEDED (hr
)) {
929 hr
= IShellFolder_GetDisplayNameOf(shellfolder
,pidl
,SHGDN_FORPARSING
,&str
);
931 StrRetToStrNA (pszPath
, MAX_PATH
, &str
, pidl
);
933 IShellFolder_Release(shellfolder
);
936 TRACE_(shell
)("-- %s, 0x%08lx\n",pszPath
, hr
);
937 return SUCCEEDED(hr
);
939 /*************************************************************************
940 * SHGetPathFromIDListW [SHELL32.@]
942 BOOL WINAPI
SHGetPathFromIDListW(LPCITEMIDLIST pidl
, LPWSTR pszPath
)
946 LPSHELLFOLDER shellfolder
;
948 TRACE_(shell
)("(pidl=%p,%p)\n", pidl
, debugstr_w(pszPath
));
951 if (!pidl
) return FALSE
;
953 hr
= SHGetDesktopFolder(&shellfolder
);
955 hr
= IShellFolder_GetDisplayNameOf(shellfolder
, pidl
, SHGDN_FORPARSING
, &str
);
957 StrRetToStrNW(pszPath
, MAX_PATH
, &str
, pidl
);
959 IShellFolder_Release(shellfolder
);
962 TRACE_(shell
)("-- %s, 0x%08lx\n",debugstr_w(pszPath
), hr
);
963 return SUCCEEDED(hr
);
966 /*************************************************************************
967 * SHBindToParent [shell version 5.0]
969 HRESULT WINAPI
SHBindToParent(LPCITEMIDLIST pidl
, REFIID riid
, LPVOID
*ppv
, LPCITEMIDLIST
*ppidlLast
)
972 LPITEMIDLIST pidlChild
, pidlParent
;
975 TRACE_(shell
)("pidl=%p\n", pidl
);
979 if (ppidlLast
) *ppidlLast
= NULL
;
981 if (_ILIsPidlSimple(pidl
))
983 /* we are on desktop level */
985 *ppidlLast
= ILClone(pidl
);
986 hr
= SHGetDesktopFolder((IShellFolder
**)ppv
);
990 pidlChild
= ILClone(ILFindLastID(pidl
));
991 pidlParent
= ILClone(pidl
);
992 ILRemoveLastID(pidlParent
);
994 hr
= SHGetDesktopFolder(&psf
);
997 hr
= IShellFolder_BindToObject(psf
, pidlParent
, NULL
, riid
, ppv
);
999 if (SUCCEEDED(hr
) && ppidlLast
)
1000 *ppidlLast
= pidlChild
;
1004 SHFree (pidlParent
);
1005 if (psf
) IShellFolder_Release(psf
);
1009 TRACE_(shell
)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv
, (ppidlLast
)?*ppidlLast
:NULL
, hr
);
1013 /*************************************************************************
1014 * SHGetPathFromIDList [SHELL32.@][NT 4.0: SHELL32.219]
1016 BOOL WINAPI
SHGetPathFromIDListAW(LPCITEMIDLIST pidl
,LPVOID pszPath
)
1018 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1020 if (SHELL_OsIsUnicode())
1021 return SHGetPathFromIDListW(pidl
,pszPath
);
1022 return SHGetPathFromIDListA(pidl
,pszPath
);
1025 /**************************************************************************
1027 * internal functions
1029 * ### 1. section creating pidls ###
1031 *************************************************************************
1032 * _ILCreateDesktop()
1033 * _ILCreateIExplore()
1034 * _ILCreateMyComputer()
1039 LPITEMIDLIST
_ILCreateDesktop()
1041 return _ILCreate(PT_DESKTOP
, NULL
, 0);
1044 LPITEMIDLIST
_ILCreateMyComputer()
1046 return _ILCreate(PT_MYCOMP
, &CLSID_MyComputer
, sizeof(GUID
));
1049 LPITEMIDLIST
_ILCreateIExplore()
1051 return _ILCreate(PT_MYCOMP
, &CLSID_Internet
, sizeof(GUID
));
1054 LPITEMIDLIST
_ILCreateControl()
1056 return _ILCreate(PT_SPECIAL
, &CLSID_ControlPanel
, sizeof(GUID
));
1059 LPITEMIDLIST
_ILCreatePrinter()
1061 return _ILCreate(PT_SPECIAL
, &CLSID_Printers
, sizeof(GUID
));
1064 LPITEMIDLIST
_ILCreateNetwork()
1066 return _ILCreate(PT_MYCOMP
, &CLSID_NetworkPlaces
, sizeof(GUID
));
1069 LPITEMIDLIST
_ILCreateBitBucket()
1071 return _ILCreate(PT_MYCOMP
, &CLSID_RecycleBin
, sizeof(GUID
));
1074 LPITEMIDLIST
_ILCreateDrive( LPCSTR lpszNew
)
1076 lstrcpynA (sTemp
,lpszNew
,4);
1079 TRACE("(%s)\n",sTemp
);
1080 return _ILCreate(PT_DRIVE
,(LPVOID
)&sTemp
[0],4);
1083 LPITEMIDLIST
_ILCreateFolder( WIN32_FIND_DATAA
* stffile
)
1085 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1086 char * pbuff
= buff
;
1090 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1092 /* prepare buffer with both names */
1093 len
= strlen (stffile
->cFileName
) + 1;
1094 memcpy (pbuff
, stffile
->cFileName
, len
);
1097 if (stffile
->cAlternateFileName
)
1099 len1
= strlen (stffile
->cAlternateFileName
)+1;
1100 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1108 pidl
= _ILCreate(PT_FOLDER
, (LPVOID
)buff
, len
+ len1
);
1110 /* set attributes */
1114 pData
= _ILGetDataPointer(pidl
);
1115 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1116 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1117 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1123 LPITEMIDLIST
_ILCreateValue(WIN32_FIND_DATAA
* stffile
)
1125 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1126 char * pbuff
= buff
;
1130 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1132 /* prepare buffer with both names */
1133 len
= strlen (stffile
->cFileName
) + 1;
1134 memcpy (pbuff
, stffile
->cFileName
, len
);
1137 if (stffile
->cAlternateFileName
)
1139 len1
= strlen (stffile
->cAlternateFileName
)+1;
1140 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1148 pidl
= _ILCreate(PT_VALUE
, (LPVOID
)buff
, len
+ len1
);
1150 /* set attributes */
1154 pData
= _ILGetDataPointer(pidl
);
1155 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1156 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1157 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1163 LPITEMIDLIST
_ILCreateSpecial(LPCSTR szGUID
)
1167 if (!SUCCEEDED(SHCLSIDFromStringA(szGUID
, &iid
)))
1169 ERR("%s is not a GUID\n", szGUID
);
1172 return _ILCreate(PT_MYCOMP
, &iid
, sizeof(IID
));
1175 /**************************************************************************
1177 * Creates a new PIDL
1178 * type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1180 * uInSize = size of data (raw)
1183 LPITEMIDLIST
_ILCreate(PIDLTYPE type
, LPCVOID pIn
, UINT uInSize
)
1185 LPITEMIDLIST pidlOut
= NULL
, pidlTemp
= NULL
;
1190 TRACE("(0x%02x %p %i)\n",type
,pIn
,uInSize
);
1199 uSize
= 2 + 2 + sizeof(GUID
);
1206 uSize
= 2 + 12 + uInSize
;
1209 FIXME("can't create type: 0x%08x\n",type
);
1213 if(!(pidlOut
= SHAlloc(uSize
+ 2))) return NULL
;
1214 ZeroMemory(pidlOut
, uSize
+ 2);
1215 pidlOut
->mkid
.cb
= uSize
;
1220 TRACE("- create Desktop\n");
1225 pData
=_ILGetDataPointer(pidlOut
);
1227 memcpy(&(pData
->u
.mycomp
.guid
), pIn
, uInSize
);
1228 TRACE("-- create GUID-pidl %s\n", debugstr_guid(&(pData
->u
.mycomp
.guid
)));
1232 pData
=_ILGetDataPointer(pidlOut
);
1234 pszDest
= _ILGetTextPointer(pidlOut
);
1235 memcpy(pszDest
, pIn
, uInSize
);
1236 TRACE("-- create Drive: %s\n",debugstr_a(pszDest
));
1241 pData
=_ILGetDataPointer(pidlOut
);
1243 pszDest
= _ILGetTextPointer(pidlOut
);
1244 memcpy(pszDest
, pIn
, uInSize
);
1245 TRACE("-- create Value: %s\n",debugstr_a(pszDest
));
1249 pidlTemp
= ILGetNext(pidlOut
);
1251 pidlTemp
->mkid
.cb
= 0x00;
1253 TRACE("-- (pidl=%p, size=%u)\n", pidlOut
, uSize
);
1257 /**************************************************************************
1260 * Gets the text for the drive eg. 'c:\'
1265 DWORD
_ILGetDrive(LPCITEMIDLIST pidl
,LPSTR pOut
, UINT uSize
)
1266 { TRACE("(%p,%p,%u)\n",pidl
,pOut
,uSize
);
1268 if(_ILIsMyComputer(pidl
))
1269 pidl
= ILGetNext(pidl
);
1271 if (pidl
&& _ILIsDrive(pidl
))
1272 return _ILSimpleGetText(pidl
, pOut
, uSize
);
1277 /**************************************************************************
1279 * ### 2. section testing pidls ###
1281 **************************************************************************
1284 * _ILIsSpecialFolder()
1290 BOOL
_ILIsDesktop(LPCITEMIDLIST pidl
)
1291 { TRACE("(%p)\n",pidl
);
1292 return pidl
&& pidl
->mkid
.cb
? 0 : 1;
1295 BOOL
_ILIsMyComputer(LPCITEMIDLIST pidl
)
1297 REFIID iid
= _ILGetGUIDPointer(pidl
);
1299 TRACE("(%p)\n",pidl
);
1302 return IsEqualIID(iid
, &CLSID_MyComputer
);
1306 BOOL
_ILIsSpecialFolder (LPCITEMIDLIST pidl
)
1308 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1309 TRACE("(%p)\n",pidl
);
1310 return (pidl
&& ( (lpPData
&& (PT_MYCOMP
== lpPData
->type
|| PT_SPECIAL
== lpPData
->type
)) ||
1311 (pidl
&& pidl
->mkid
.cb
== 0x00)
1315 BOOL
_ILIsDrive(LPCITEMIDLIST pidl
)
1316 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1317 TRACE("(%p)\n",pidl
);
1318 return (pidl
&& lpPData
&& (PT_DRIVE
== lpPData
->type
||
1319 PT_DRIVE1
== lpPData
->type
||
1320 PT_DRIVE2
== lpPData
->type
||
1321 PT_DRIVE3
== lpPData
->type
));
1324 BOOL
_ILIsFolder(LPCITEMIDLIST pidl
)
1325 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1326 TRACE("(%p)\n",pidl
);
1327 return (pidl
&& lpPData
&& (PT_FOLDER
== lpPData
->type
|| PT_FOLDER1
== lpPData
->type
));
1330 BOOL
_ILIsValue(LPCITEMIDLIST pidl
)
1331 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1332 TRACE("(%p)\n",pidl
);
1333 return (pidl
&& lpPData
&& PT_VALUE
== lpPData
->type
);
1336 /**************************************************************************
1339 BOOL
_ILIsPidlSimple ( LPCITEMIDLIST pidl
)
1343 if(! _ILIsDesktop(pidl
)) /* pidl=NULL or mkid.cb=0 */
1345 WORD len
= pidl
->mkid
.cb
;
1346 LPCITEMIDLIST pidlnext
= (LPCITEMIDLIST
) (((LPBYTE
)pidl
) + len
);
1347 if (pidlnext
->mkid
.cb
)
1351 TRACE("%s\n", ret
? "Yes" : "No");
1355 /**************************************************************************
1357 * ### 3. section getting values from pidls ###
1360 /**************************************************************************
1363 * gets the text for the first item in the pidl (eg. simple pidl)
1365 * returns the length of the string
1367 DWORD
_ILSimpleGetText (LPCITEMIDLIST pidl
, LPSTR szOut
, UINT uOutSize
)
1372 char szTemp
[MAX_PATH
];
1374 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1376 if (!pidl
) return 0;
1381 if (_ILIsDesktop(pidl
))
1384 if (HCR_GetClassNameA(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
1387 lstrcpynA(szOut
, szTemp
, uOutSize
);
1389 dwReturn
= strlen (szTemp
);
1392 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
1396 lstrcpynA(szOut
, szSrc
, uOutSize
);
1398 dwReturn
= strlen(szSrc
);
1400 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
1402 /* special folder */
1403 if ( HCR_GetClassNameA(riid
, szTemp
, MAX_PATH
) )
1406 lstrcpynA(szOut
, szTemp
, uOutSize
);
1408 dwReturn
= strlen (szTemp
);
1413 ERR("-- no text\n");
1416 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,debugstr_a(szOut
),dwReturn
);
1420 /**************************************************************************
1422 * ### 4. getting pointers to parts of pidls ###
1424 **************************************************************************
1425 * _ILGetDataPointer()
1427 LPPIDLDATA
_ILGetDataPointer(LPITEMIDLIST pidl
)
1429 if(pidl
&& pidl
->mkid
.cb
!= 0x00)
1430 return (LPPIDLDATA
) &(pidl
->mkid
.abID
);
1434 /**************************************************************************
1435 * _ILGetTextPointer()
1436 * gets a pointer to the long filename string stored in the pidl
1438 LPSTR
_ILGetTextPointer(LPCITEMIDLIST pidl
)
1439 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1441 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1445 switch (pdata
->type
)
1455 return (LPSTR
)&(pdata
->u
.drive
.szDriveName
);
1462 return (LPSTR
)&(pdata
->u
.file
.szNames
);
1468 return (LPSTR
)&(pdata
->u
.network
.szNames
);
1474 /**************************************************************************
1475 * _ILGetSTextPointer()
1476 * gets a pointer to the short filename string stored in the pidl
1478 LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
)
1479 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1481 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1485 switch (pdata
->type
)
1491 return (LPSTR
)(pdata
->u
.file
.szNames
+ strlen (pdata
->u
.file
.szNames
) + 1);
1494 return (LPSTR
)(pdata
->u
.network
.szNames
+ strlen (pdata
->u
.network
.szNames
) + 1);
1500 /**************************************************************************
1501 * _ILGetGUIDPointer()
1503 * returns reference to guid stored in some pidls
1505 REFIID
_ILGetGUIDPointer(LPCITEMIDLIST pidl
)
1507 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1509 TRACE("%p\n", pidl
);
1513 TRACE("pdata->type 0x%04x\n", pdata
->type
);
1514 switch (pdata
->type
)
1518 return (REFIID
) &(pdata
->u
.mycomp
.guid
);
1521 TRACE("Unknown pidl type 0x%04x\n", pdata
->type
);
1528 /*************************************************************************
1529 * _ILGetFileDateTime
1531 * Given the ItemIdList, get the FileTime
1534 * pidl [I] The ItemIDList
1535 * pFt [I] the resulted FILETIME of the file
1538 * True if Successful
1543 BOOL
_ILGetFileDateTime(LPCITEMIDLIST pidl
, FILETIME
*pFt
)
1545 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1547 if(! pdata
) return FALSE
;
1549 switch (pdata
->type
)
1552 DosDateTimeToFileTime(pdata
->u
.folder
.uFileDate
, pdata
->u
.folder
.uFileTime
, pFt
);
1555 DosDateTimeToFileTime(pdata
->u
.file
.uFileDate
, pdata
->u
.file
.uFileTime
, pFt
);
1563 BOOL
_ILGetFileDate (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1569 if (_ILGetFileDateTime( pidl
, &ft
)) {
1570 FileTimeToLocalFileTime(&ft
, &lft
);
1571 FileTimeToSystemTime (&lft
, &time
);
1572 ret
= GetDateFormatA(LOCALE_USER_DEFAULT
,DATE_SHORTDATE
,&time
, NULL
, pOut
, uOutSize
);
1581 /*************************************************************************
1584 * Given the ItemIdList, get the FileSize
1587 * pidl [I] The ItemIDList
1588 * pOut [I] The buffer to save the result
1589 * uOutsize [I] The size of the buffer
1595 * pOut can be null when no string is needed
1598 DWORD
_ILGetFileSize (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1600 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1603 if(! pdata
) return 0;
1605 switch (pdata
->type
)
1608 dwSize
= pdata
->u
.file
.dwFileSize
;
1609 if (pOut
) StrFormatByteSizeA(dwSize
, pOut
, uOutSize
);
1612 if (pOut
) *pOut
= 0x00;
1616 BOOL
_ILGetExtension (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1618 char szTemp
[MAX_PATH
];
1619 const char * pPoint
;
1620 LPITEMIDLIST pidlTemp
=pidl
;
1622 TRACE("pidl=%p\n",pidl
);
1624 if (!pidl
) return FALSE
;
1626 pidlTemp
= ILFindLastID(pidl
);
1628 if (!_ILIsValue(pidlTemp
)) return FALSE
;
1629 if (!_ILSimpleGetText(pidlTemp
, szTemp
, MAX_PATH
)) return FALSE
;
1631 pPoint
= PathFindExtensionA(szTemp
);
1633 if (! *pPoint
) return FALSE
;
1636 lstrcpynA(pOut
, pPoint
, uOutSize
);
1642 /*************************************************************************
1645 * Given the ItemIdList, get the file type description
1648 * pidl [I] The ItemIDList (simple)
1649 * pOut [I] The buffer to save the result
1650 * uOutsize [I] The size of the buffer
1656 * This function copies as much as possible into the buffer.
1658 void _ILGetFileType(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1660 if(_ILIsValue(pidl
))
1667 if (_ILGetExtension (pidl
, sTemp
, 64))
1669 if (!( HCR_MapTypeToValueA(sTemp
, sTemp
, 64, TRUE
)
1670 && HCR_MapTypeToValueA(sTemp
, pOut
, uOutSize
, FALSE
)))
1672 lstrcpynA (pOut
, sTemp
, uOutSize
- 6);
1673 strcat (pOut
, "-file");
1679 lstrcpynA(pOut
, "Folder", uOutSize
);
1683 /*************************************************************************
1684 * _ILGetFileAttributes
1686 * Given the ItemIdList, get the Attrib string format
1689 * pidl [I] The ItemIDList
1690 * pOut [I] The buffer to save the result
1691 * uOutsize [I] The size of the Buffer
1697 * return value 0 in case of error is a valid return value
1700 DWORD
_ILGetFileAttributes(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1702 LPPIDLDATA pData
=_ILGetDataPointer(pidl
);
1706 if(! pData
) return 0;
1711 wAttrib
= pData
->u
.folder
.uFileAttribs
;
1714 wAttrib
= pData
->u
.file
.uFileAttribs
;
1721 if(wAttrib
& FILE_ATTRIBUTE_READONLY
)
1725 if(wAttrib
& FILE_ATTRIBUTE_HIDDEN
)
1729 if(wAttrib
& FILE_ATTRIBUTE_SYSTEM
)
1733 if(wAttrib
& FILE_ATTRIBUTE_ARCHIVE
)
1737 if(wAttrib
& FILE_ATTRIBUTE_COMPRESSED
)
1746 /*************************************************************************
1749 * free a aPidl struct
1751 void _ILFreeaPidl(LPITEMIDLIST
* apidl
, UINT cidl
)
1757 for (i
= 0; i
< cidl
; i
++) SHFree(apidl
[i
]);
1762 /*************************************************************************
1765 * copies an aPidl struct
1767 LPITEMIDLIST
* _ILCopyaPidl(LPITEMIDLIST
* apidlsrc
, UINT cidl
)
1770 LPITEMIDLIST
* apidldest
= (LPITEMIDLIST
*)SHAlloc(cidl
* sizeof(LPITEMIDLIST
));
1771 if(!apidlsrc
) return NULL
;
1773 for (i
= 0; i
< cidl
; i
++)
1774 apidldest
[i
] = ILClone(apidlsrc
[i
]);
1779 /*************************************************************************
1780 * _ILCopyCidaToaPidl
1782 * creates aPidl from CIDA
1784 LPITEMIDLIST
* _ILCopyCidaToaPidl(LPITEMIDLIST
* pidl
, LPIDA cida
)
1787 LPITEMIDLIST
* dst
= (LPITEMIDLIST
*)SHAlloc(cida
->cidl
* sizeof(LPITEMIDLIST
));
1789 if(!dst
) return NULL
;
1792 *pidl
= ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[0]]));
1794 for (i
= 0; i
< cida
->cidl
; i
++)
1795 dst
[i
] = ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[i
+ 1]]));