4 * Copyright 1998 Juergen Schmied
7 * a pidl == NULL means desktop and is legal
15 #include "debugtools.h"
19 #include "wine/undocshell.h"
20 #include "shell32_main.h"
25 DEFAULT_DEBUG_CHANNEL(pidl
);
26 DECLARE_DEBUG_CHANNEL(shell
);
28 void pdump (LPCITEMIDLIST pidl
)
32 LPITEMIDLIST pidltemp
= pidl
;
36 /* silence the sub-functions */
37 bIsShellDebug
= TRACE_ON(shell
);
38 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_shell
, FALSE
);
39 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_pidl
, FALSE
);
43 MESSAGE ("-------- pidl=NULL (Desktop)\n");
47 MESSAGE ("-------- pidl=%p\n", pidl
);
48 if (pidltemp
->mkid
.cb
)
53 LPPIDLDATA pData
= _ILGetDataPointer(pidltemp
);
54 DWORD type
= pData
->type
;
55 LPSTR szLongName
= _ILGetTextPointer(pidltemp
);
56 LPSTR szShortName
= _ILGetSTextPointer(pidltemp
);
57 char szName
[MAX_PATH
];
59 _ILSimpleGetText(pidltemp
, szName
, MAX_PATH
);
60 if( PT_FOLDER
== type
)
61 dwAttrib
= pData
->u
.folder
.uFileAttribs
;
62 else if( PT_VALUE
== type
)
63 dwAttrib
= pData
->u
.file
.uFileAttribs
;
65 MESSAGE ("-- pidl=%p size=%u type=%lx attr=0x%08lx name=%s (%s,%s)\n",
66 pidltemp
, pidltemp
->mkid
.cb
,type
,dwAttrib
,szName
,debugstr_a(szLongName
), debugstr_a(szShortName
));
68 pidltemp
= ILGetNext(pidltemp
);
70 } while (pidltemp
->mkid
.cb
);
74 MESSAGE ("empty pidl (Desktop)\n");
79 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_shell
, bIsShellDebug
);
80 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_pidl
, TRUE
);
83 #define BYTES_PRINTED 32
84 BOOL
pcheck (LPCITEMIDLIST pidl
)
85 { DWORD type
, ret
=TRUE
;
88 LPITEMIDLIST pidltemp
= pidl
;
90 bIsPidlDebug
= TRACE_ON(shell
);
91 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_pidl
, FALSE
);
93 if (pidltemp
&& pidltemp
->mkid
.cb
)
95 { type
= _ILGetDataPointer(pidltemp
)->type
;
115 char szTemp
[BYTES_PRINTED
*4 + 1];
119 memset(szTemp
, ' ', BYTES_PRINTED
*4 + 1);
120 for ( i
= 0; (i
<pidltemp
->mkid
.cb
) && (i
<BYTES_PRINTED
); i
++)
122 c
= ((unsigned char *)pidltemp
)[i
];
124 szTemp
[i
*3+0] = ((c
>>4)>9)? (c
>>4)+55 : (c
>>4)+48;
125 szTemp
[i
*3+1] = ((0x0F&c
)>9)? (0x0F&c
)+55 : (0x0F&c
)+48;
127 szTemp
[i
+BYTES_PRINTED
*3] = (c
>=0x20 && c
<=0x80) ? c
: '.';
129 szTemp
[BYTES_PRINTED
*4] = 0x00;
130 ERR("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp
->mkid
.cb
,type
, szTemp
);
134 pidltemp
= ILGetNext(pidltemp
);
135 } while (pidltemp
->mkid
.cb
);
137 __SET_DEBUGGING(__DBCL_TRACE
, __wine_dbch_pidl
, bIsPidlDebug
);
141 /*************************************************************************
142 * ILGetDisplayName [SHELL32.15]
144 BOOL WINAPI
ILGetDisplayName(LPCITEMIDLIST pidl
,LPSTR path
)
146 TRACE_(shell
)("pidl=%p %p semi-stub\n",pidl
,path
);
147 return SHGetPathFromIDListA(pidl
, path
);
149 /*************************************************************************
150 * ILFindLastID [SHELL32.16]
153 * observed: pidl=Desktop return=pidl
155 LPITEMIDLIST WINAPI
ILFindLastID(LPITEMIDLIST pidl
)
156 { LPITEMIDLIST pidlLast
= pidl
;
158 TRACE("(pidl=%p)\n",pidl
);
160 while (pidl
->mkid
.cb
)
163 pidl
= ILGetNext(pidl
);
167 /*************************************************************************
168 * ILRemoveLastID [SHELL32.17]
171 * when pidl=Desktop return=FALSE
173 BOOL WINAPI
ILRemoveLastID(LPCITEMIDLIST pidl
)
175 TRACE_(shell
)("pidl=%p\n",pidl
);
177 if (!pidl
|| !pidl
->mkid
.cb
)
179 ILFindLastID(pidl
)->mkid
.cb
= 0;
183 /*************************************************************************
184 * ILClone [SHELL32.18]
189 LPITEMIDLIST WINAPI
ILClone (LPCITEMIDLIST pidl
)
191 LPITEMIDLIST newpidl
;
196 len
= ILGetSize(pidl
);
197 newpidl
= (LPITEMIDLIST
)SHAlloc(len
);
199 memcpy(newpidl
,pidl
,len
);
201 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
206 /*************************************************************************
207 * ILCloneFirst [SHELL32.19]
210 * duplicates the first idlist of a complex pidl
212 LPITEMIDLIST WINAPI
ILCloneFirst(LPCITEMIDLIST pidl
)
214 LPITEMIDLIST pidlNew
= NULL
;
216 TRACE("pidl=%p \n",pidl
);
222 pidlNew
= (LPITEMIDLIST
) SHAlloc (len
+2);
225 memcpy(pidlNew
,pidl
,len
+2); /* 2 -> mind a desktop pidl */
228 ILGetNext(pidlNew
)->mkid
.cb
= 0x00;
231 TRACE("-- newpidl=%p\n",pidlNew
);
235 /*************************************************************************
239 * the first two bytes are the len, the pidl is following then
241 HRESULT WINAPI
ILLoadFromStream (IStream
* pStream
, LPITEMIDLIST
* ppPidl
)
244 HRESULT ret
= E_FAIL
;
247 TRACE_(shell
)("%p %p\n", pStream
, ppPidl
);
254 IStream_AddRef (pStream
);
256 if (SUCCEEDED(IStream_Read(pStream
, (LPVOID
)&wLen
, 2, &dwBytesRead
)))
257 { *ppPidl
= SHAlloc (wLen
);
258 if (SUCCEEDED(IStream_Read(pStream
, *ppPidl
, wLen
, &dwBytesRead
)))
267 /* we are not jet fully compatible */
268 if (!pcheck(*ppPidl
))
274 IStream_Release (pStream
);
278 /*************************************************************************
279 * SHILCreateFromPath [SHELL32.28]
282 * wraper for IShellFolder::ParseDisplayName()
284 HRESULT WINAPI
SHILCreateFromPathA (LPCSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
286 WCHAR lpszDisplayName
[MAX_PATH
];
288 HRESULT ret
= E_FAIL
;
290 TRACE_(shell
)("%s %p 0x%08lx\n",path
,ppidl
,attributes
?*attributes
:0);
292 if (!MultiByteToWideChar( CP_ACP
, 0, path
, -1, lpszDisplayName
, MAX_PATH
))
293 lpszDisplayName
[MAX_PATH
-1] = 0;
295 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
297 ret
= IShellFolder_ParseDisplayName(sf
,0, NULL
,lpszDisplayName
,&pchEaten
,ppidl
,attributes
);
298 IShellFolder_Release(sf
);
302 HRESULT WINAPI
SHILCreateFromPathW (LPCWSTR path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
305 HRESULT ret
= E_FAIL
;
307 TRACE_(shell
)("%s %p 0x%08lx\n",debugstr_w(path
),ppidl
,attributes
?*attributes
:0);
309 if (SUCCEEDED (SHGetDesktopFolder(&sf
)))
311 ret
= IShellFolder_ParseDisplayName(sf
,0, NULL
, (LPWSTR
) path
, &pchEaten
, ppidl
, attributes
);
312 IShellFolder_Release(sf
);
316 HRESULT WINAPI
SHILCreateFromPathAW (LPCVOID path
, LPITEMIDLIST
* ppidl
, DWORD
* attributes
)
318 if ( SHELL_OsIsUnicode())
319 return SHILCreateFromPathW (path
, ppidl
, attributes
);
320 return SHILCreateFromPathA (path
, ppidl
, attributes
);
323 /*************************************************************************
324 * SHCloneSpecialIDList [SHELL32.89]
328 * nFolder [in] CSIDL_xxxxx ??
333 * exported by ordinal
335 LPITEMIDLIST WINAPI
SHCloneSpecialIDList(HWND hwndOwner
,DWORD nFolder
,DWORD x3
)
336 { LPITEMIDLIST ppidl
;
337 WARN_(shell
)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
338 hwndOwner
,nFolder
,x3
);
340 SHGetSpecialFolderLocation(hwndOwner
, nFolder
, &ppidl
);
345 /*************************************************************************
346 * ILGlobalClone [SHELL32.97]
349 LPITEMIDLIST WINAPI
ILGlobalClone(LPCITEMIDLIST pidl
)
351 LPITEMIDLIST newpidl
;
356 len
= ILGetSize(pidl
);
357 newpidl
= (LPITEMIDLIST
)pCOMCTL32_Alloc(len
);
359 memcpy(newpidl
,pidl
,len
);
361 TRACE("pidl=%p newpidl=%p\n",pidl
, newpidl
);
367 /*************************************************************************
368 * ILIsEqual [SHELL32.21]
371 BOOL WINAPI
ILIsEqual(LPCITEMIDLIST pidl1
, LPCITEMIDLIST pidl2
)
373 char szData1
[MAX_PATH
];
374 char szData2
[MAX_PATH
];
376 LPITEMIDLIST pidltemp1
= pidl1
;
377 LPITEMIDLIST pidltemp2
= pidl2
;
379 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
381 /* explorer reads from registry directly (StreamMRU),
382 so we can only check here */
383 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
))) return FALSE
;
388 if ( (!pidl1
) || (!pidl2
) ) return FALSE
;
390 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
392 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
393 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
395 if (strcasecmp ( szData1
, szData2
)!=0 )
398 pidltemp1
= ILGetNext(pidltemp1
);
399 pidltemp2
= ILGetNext(pidltemp2
);
402 if (!pidltemp1
->mkid
.cb
&& !pidltemp2
->mkid
.cb
)
409 /*************************************************************************
410 * ILIsParent [SHELL32.23]
412 * parent=a/b child=a/b/c -> true, c is in folder a/b
413 * child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
414 * child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
416 BOOL WINAPI
ILIsParent( LPCITEMIDLIST pidlParent
, LPCITEMIDLIST pidlChild
, BOOL bImmediate
)
418 char szData1
[MAX_PATH
];
419 char szData2
[MAX_PATH
];
421 LPITEMIDLIST pParent
= pidlParent
;
422 LPITEMIDLIST pChild
= pidlChild
;
424 TRACE("%p %p %x\n", pidlParent
, pidlChild
, bImmediate
);
426 while (pParent
->mkid
.cb
&& pChild
->mkid
.cb
)
428 _ILSimpleGetText(pParent
, szData1
, MAX_PATH
);
429 _ILSimpleGetText(pChild
, szData2
, MAX_PATH
);
431 if (strcasecmp ( szData1
, szData2
)!=0 )
434 pParent
= ILGetNext(pParent
);
435 pChild
= ILGetNext(pChild
);
438 if ( pParent
->mkid
.cb
|| ! pChild
->mkid
.cb
) /* child shorter or has equal length to parent */
441 if ( ILGetNext(pChild
)->mkid
.cb
&& bImmediate
) /* not immediate descent */
447 /*************************************************************************
448 * ILFindChild [SHELL32.24]
451 * Compares elements from pidl1 and pidl2.
453 * pidl1 is desktop pidl2
454 * pidl1 shorter pidl2 pointer to first different element of pidl2
455 * if there was at least one equal element
456 * pidl2 shorter pidl1 0
457 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
459 LPITEMIDLIST WINAPI
ILFindChild(LPCITEMIDLIST pidl1
,LPCITEMIDLIST pidl2
)
461 char szData1
[MAX_PATH
];
462 char szData2
[MAX_PATH
];
464 LPITEMIDLIST pidltemp1
= pidl1
;
465 LPITEMIDLIST pidltemp2
= pidl2
;
466 LPITEMIDLIST ret
=NULL
;
468 TRACE("pidl1=%p pidl2=%p\n",pidl1
, pidl2
);
470 /* explorer reads from registry directly (StreamMRU),
471 so we can only check here */
472 if ((!pcheck (pidl1
)) || (!pcheck (pidl2
)))
478 if ( _ILIsDesktop(pidl1
) )
484 while (pidltemp1
->mkid
.cb
&& pidltemp2
->mkid
.cb
)
486 _ILSimpleGetText(pidltemp1
, szData1
, MAX_PATH
);
487 _ILSimpleGetText(pidltemp2
, szData2
, MAX_PATH
);
489 if (strcasecmp(szData1
,szData2
))
492 pidltemp1
= ILGetNext(pidltemp1
);
493 pidltemp2
= ILGetNext(pidltemp2
);
497 if (pidltemp1
->mkid
.cb
)
499 ret
= NULL
; /* elements of pidl1 left*/
502 TRACE_(shell
)("--- %p\n", ret
);
503 return ret
; /* pidl 1 is shorter */
506 /*************************************************************************
507 * ILCombine [SHELL32.25]
510 * Concatenates two complex idlists.
511 * The pidl is the first one, pidlsub the next one
512 * Does not destroy the passed in idlists!
514 LPITEMIDLIST WINAPI
ILCombine(LPCITEMIDLIST pidl1
,LPCITEMIDLIST pidl2
)
517 LPITEMIDLIST pidlNew
;
519 TRACE("pidl=%p pidl=%p\n",pidl1
,pidl2
);
521 if(!pidl1
&& !pidl2
) return NULL
;
528 pidlNew
= ILClone(pidl2
);
534 pidlNew
= ILClone(pidl1
);
538 len1
= ILGetSize(pidl1
)-2;
539 len2
= ILGetSize(pidl2
);
540 pidlNew
= SHAlloc(len1
+len2
);
544 memcpy(pidlNew
,pidl1
,len1
);
545 memcpy(((BYTE
*)pidlNew
)+len1
,pidl2
,len2
);
548 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
551 /*************************************************************************
552 * SHGetRealIDL [SHELL32.98]
556 LPITEMIDLIST WINAPI
SHGetRealIDL(LPSHELLFOLDER lpsf
, LPITEMIDLIST pidl
, DWORD z
)
558 FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf
,pidl
,z
);
564 /*************************************************************************
565 * SHLogILFromFSIL [SHELL32.95]
568 * pild = CSIDL_DESKTOP ret = 0
569 * pild = CSIDL_DRIVES ret = 0
571 LPITEMIDLIST WINAPI
SHLogILFromFSIL(LPITEMIDLIST pidl
)
573 FIXME("(pidl=%p)\n",pidl
);
580 /*************************************************************************
581 * ILGetSize [SHELL32.152]
582 * gets the byte size of an idlist including zero terminator (pidl)
591 * exported by ordinal
593 DWORD WINAPI
ILGetSize(LPITEMIDLIST pidl
)
595 LPSHITEMID si
= &(pidl
->mkid
);
601 si
= (LPSHITEMID
)(((LPBYTE
)si
)+si
->cb
);
605 TRACE("pidl=%p size=%lu\n",pidl
, len
);
609 /*************************************************************************
610 * ILGetNext [SHELL32.153]
611 * gets the next simple pidl of a complex pidl
613 * observed return values:
616 * simple pidl -> pointer to 0x0000 element
619 LPITEMIDLIST WINAPI
ILGetNext(LPITEMIDLIST pidl
)
623 TRACE("(pidl=%p)\n",pidl
);
630 pidl
= (LPITEMIDLIST
) (((LPBYTE
)pidl
)+len
);
636 /*************************************************************************
637 * ILAppend [SHELL32.154]
640 * Adds the single item to the idlist indicated by pidl.
641 * if bEnd is 0, adds the item to the front of the list,
642 * otherwise adds the item to the end. (???)
643 * Destroys the passed in idlist! (???)
645 LPITEMIDLIST WINAPI
ILAppend(LPITEMIDLIST pidl
,LPCITEMIDLIST item
,BOOL bEnd
)
649 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl
,item
,bEnd
);
654 if (_ILIsDesktop(pidl
))
656 idlRet
= ILClone(item
);
664 idlRet
=ILCombine(pidl
,item
);
668 idlRet
=ILCombine(item
,pidl
);
674 /*************************************************************************
675 * ILFree [SHELL32.155]
678 * free_check_ptr - frees memory (if not NULL)
679 * allocated by SHMalloc allocator
680 * exported by ordinal
682 DWORD WINAPI
ILFree(LPITEMIDLIST pidl
)
684 TRACE("(pidl=0x%08lx)\n",(DWORD
)pidl
);
686 if(!pidl
) return FALSE
;
690 /*************************************************************************
691 * ILGlobalFree [SHELL32.156]
694 void WINAPI
ILGlobalFree( LPCITEMIDLIST pidl
)
699 pCOMCTL32_Free(pidl
);
701 /*************************************************************************
702 * ILCreateFromPath [SHELL32.157]
705 LPITEMIDLIST WINAPI
ILCreateFromPathA (LPCSTR path
)
707 LPITEMIDLIST pidlnew
;
708 DWORD attributes
= 0;
710 TRACE_(shell
)("%s\n",path
);
712 if (SUCCEEDED (SHILCreateFromPathA (path
, &pidlnew
, &attributes
)))
716 LPITEMIDLIST WINAPI
ILCreateFromPathW (LPCWSTR path
)
718 LPITEMIDLIST pidlnew
;
719 DWORD attributes
= 0;
721 TRACE_(shell
)("%s\n",debugstr_w(path
));
723 if (SUCCEEDED (SHILCreateFromPathW (path
, &pidlnew
, &attributes
)))
727 LPITEMIDLIST WINAPI
ILCreateFromPathAW (LPCVOID path
)
729 if ( SHELL_OsIsUnicode())
730 return ILCreateFromPathW (path
);
731 return ILCreateFromPathA (path
);
733 /*************************************************************************
734 * SHSimpleIDListFromPath [SHELL32.162]
736 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathA (LPCSTR lpszPath
)
738 LPITEMIDLIST pidl
=NULL
;
740 WIN32_FIND_DATAA stffile
;
742 TRACE("path=%s\n", lpszPath
);
744 if (!lpszPath
) return NULL
;
746 hFile
= FindFirstFileA(lpszPath
, &stffile
);
748 if ( hFile
!= INVALID_HANDLE_VALUE
)
750 if (stffile
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
752 pidl
= _ILCreateFolder (&stffile
);
756 pidl
= _ILCreateValue (&stffile
);
762 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathW (LPCWSTR lpszPath
)
764 char lpszTemp
[MAX_PATH
];
765 TRACE("path=%s\n",debugstr_w(lpszPath
));
767 if (!WideCharToMultiByte( CP_ACP
, 0, lpszPath
, -1, lpszTemp
, sizeof(lpszTemp
), NULL
, NULL
))
768 lpszTemp
[sizeof(lpszTemp
)-1] = 0;
770 return SHSimpleIDListFromPathA (lpszTemp
);
773 LPITEMIDLIST WINAPI
SHSimpleIDListFromPathAW (LPCVOID lpszPath
)
775 if ( SHELL_OsIsUnicode())
776 return SHSimpleIDListFromPathW (lpszPath
);
777 return SHSimpleIDListFromPathA (lpszPath
);
780 /*************************************************************************
781 * SHGetSpecialFolderLocation [SHELL32.223]
783 * gets the folder locations from the registry and creates a pidl
784 * creates missing reg keys and directorys
788 * nFolder [I] CSIDL_xxxxx
789 * ppidl [O] PIDL of a special folder
792 HRESULT WINAPI
SHGetSpecialFolderLocation(
795 LPITEMIDLIST
* ppidl
)
797 CHAR szPath
[MAX_PATH
];
798 HRESULT hr
= E_INVALIDARG
;
800 TRACE_(shell
)("(%04x,0x%x,%p)\n", hwndOwner
,nFolder
,ppidl
);
808 *ppidl
= _ILCreateDesktop();
812 *ppidl
= _ILCreateMyComputer();
816 *ppidl
= _ILCreateNetwork ();
820 *ppidl
= _ILCreateControl ();
824 *ppidl
= _ILCreatePrinter ();
827 case CSIDL_BITBUCKET
:
828 *ppidl
= _ILCreateBitBucket ();
832 if (SHGetSpecialFolderPathA(hwndOwner
, szPath
, nFolder
, TRUE
))
835 TRACE_(shell
)("Value=%s\n",szPath
);
836 hr
= SHILCreateFromPathA(szPath
, ppidl
, &attributes
);
839 if(*ppidl
) hr
= NOERROR
;
842 TRACE_(shell
)("-- (new pidl %p)\n",*ppidl
);
846 /*************************************************************************
847 * SHGetFolderLocation [SHELL32]
850 * the pidl can be a simple one. since we cant get the path out of the pidl
851 * we have to take all data from the pidl
853 HRESULT WINAPI
SHGetFolderLocation(
860 FIXME("0x%04x 0x%08x 0x%08x 0x%08lx %p\n",
861 hwnd
, csidl
, hToken
, dwFlags
, ppidl
);
862 return SHGetSpecialFolderLocation(hwnd
, csidl
, ppidl
);
865 /*************************************************************************
866 * SHGetDataFromIDListA [SHELL32.247]
869 * the pidl can be a simple one. since we cant get the path out of the pidl
870 * we have to take all data from the pidl
872 HRESULT WINAPI
SHGetDataFromIDListA(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
874 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
877 if (!psf
|| !dest
) return E_INVALIDARG
;
881 case SHGDFIL_FINDDATA
:
883 WIN32_FIND_DATAA
* pfd
= dest
;
885 if ( len
< sizeof (WIN32_FIND_DATAA
)) return E_INVALIDARG
;
887 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
888 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
889 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
890 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
891 lstrcpynA(pfd
->cFileName
,_ILGetTextPointer(pidl
), MAX_PATH
);
892 lstrcpynA(pfd
->cAlternateFileName
,_ILGetSTextPointer(pidl
), 14);
896 case SHGDFIL_NETRESOURCE
:
897 case SHGDFIL_DESCRIPTIONID
:
898 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
902 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
907 /*************************************************************************
908 * SHGetDataFromIDListW [SHELL32.247]
911 HRESULT WINAPI
SHGetDataFromIDListW(LPSHELLFOLDER psf
, LPCITEMIDLIST pidl
, int nFormat
, LPVOID dest
, int len
)
913 TRACE_(shell
)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf
,pidl
,nFormat
,dest
,len
);
917 if (! psf
|| !dest
) return E_INVALIDARG
;
921 case SHGDFIL_FINDDATA
:
923 WIN32_FIND_DATAW
* pfd
= dest
;
925 if ( len
< sizeof (WIN32_FIND_DATAW
)) return E_INVALIDARG
;
927 ZeroMemory(pfd
, sizeof (WIN32_FIND_DATAA
));
928 _ILGetFileDateTime( pidl
, &(pfd
->ftLastWriteTime
));
929 pfd
->dwFileAttributes
= _ILGetFileAttributes(pidl
, NULL
, 0);
930 pfd
->nFileSizeLow
= _ILGetFileSize ( pidl
, NULL
, 0);
931 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetTextPointer(pidl
), -1,
932 pfd
->cFileName
, MAX_PATH
))
933 pfd
->cFileName
[MAX_PATH
-1] = 0;
934 if (!MultiByteToWideChar( CP_ACP
, 0, _ILGetSTextPointer(pidl
), -1,
935 pfd
->cAlternateFileName
, 14 ))
936 pfd
->cFileName
[13] = 0;
939 case SHGDFIL_NETRESOURCE
:
940 case SHGDFIL_DESCRIPTIONID
:
941 FIXME_(shell
)("SHGDFIL %i stub\n", nFormat
);
945 ERR_(shell
)("Unknown SHGDFIL %i, please report\n", nFormat
);
951 /*************************************************************************
952 * SHGetPathFromIDListA [SHELL32.261][NT 4.0: SHELL32.220]
959 * path from a passed PIDL.
963 * desktop pidl gives path to desktopdirectory back
964 * special pidls returning FALSE
967 * fnGetDisplayNameOf can return different types of OLEString
969 BOOL WINAPI
SHGetPathFromIDListA (LPCITEMIDLIST pidl
,LPSTR pszPath
)
971 LPSHELLFOLDER shellfolder
;
973 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
975 if (!pidl
) return FALSE
;
979 if(_ILIsDesktop(pidl
))
981 SHGetSpecialFolderPathA(0, pszPath
, CSIDL_DESKTOPDIRECTORY
, FALSE
);
983 else if (_ILIsSpecialFolder(ILFindLastID(pidl
)))
985 /* we are somewhere in a special folder */
990 if (SHGetDesktopFolder(&shellfolder
)==S_OK
)
992 IShellFolder_GetDisplayNameOf(shellfolder
,pidl
,SHGDN_FORPARSING
,&str
);
993 StrRetToStrNA (pszPath
, MAX_PATH
, &str
, pidl
);
994 IShellFolder_Release(shellfolder
);
997 TRACE_(shell
)("-- (%s)\n",pszPath
);
1001 /*************************************************************************
1002 * SHGetPathFromIDListW [SHELL32.262]
1004 BOOL WINAPI
SHGetPathFromIDListW (LPCITEMIDLIST pidl
,LPWSTR pszPath
)
1005 { char sTemp
[MAX_PATH
];
1007 TRACE_(shell
)("(pidl=%p)\n", pidl
);
1009 SHGetPathFromIDListA (pidl
, sTemp
);
1010 MultiByteToWideChar( CP_ACP
, 0, sTemp
, -1, pszPath
, MAX_PATH
);
1012 TRACE_(shell
)("-- (%s)\n",debugstr_w(pszPath
));
1017 /*************************************************************************
1018 * SHBindToParent [shell version 5.0]
1020 HRESULT WINAPI
SHBindToParent(LPCITEMIDLIST pidl
, REFIID riid
, LPVOID
*ppv
, LPCITEMIDLIST
*ppidlLast
)
1023 LPITEMIDLIST pidlChild
, pidlParent
;
1026 TRACE_(shell
)("pidl=%p\n", pidl
);
1030 if (ppidlLast
) *ppidlLast
= NULL
;
1032 if (_ILIsPidlSimple(pidl
))
1034 /* we are on desktop level */
1036 *ppidlLast
= ILClone(pidl
);
1037 hr
= SHGetDesktopFolder((IShellFolder
**)ppv
);
1041 pidlChild
= ILClone(ILFindLastID(pidl
));
1042 pidlParent
= ILClone(pidl
);
1043 ILRemoveLastID(pidlParent
);
1045 hr
= SHGetDesktopFolder(&psf
);
1048 hr
= IShellFolder_BindToObject(psf
, pidlParent
, NULL
, riid
, ppv
);
1050 if (SUCCEEDED(hr
) && ppidlLast
)
1051 *ppidlLast
= pidlChild
;
1055 SHFree (pidlParent
);
1056 if (psf
) IShellFolder_Release(psf
);
1060 TRACE_(shell
)("-- psf=%p pidl=%p ret=0x%08lx\n", *ppv
, (ppidlLast
)?*ppidlLast
:NULL
, hr
);
1064 /*************************************************************************
1065 * SHGetPathFromIDListAW [SHELL32.221][NT 4.0: SHELL32.219]
1067 BOOL WINAPI
SHGetPathFromIDListAW(LPCITEMIDLIST pidl
,LPVOID pszPath
)
1069 TRACE_(shell
)("(pidl=%p,%p)\n",pidl
,pszPath
);
1071 if (SHELL_OsIsUnicode())
1072 return SHGetPathFromIDListW(pidl
,pszPath
);
1073 return SHGetPathFromIDListA(pidl
,pszPath
);
1076 /**************************************************************************
1078 * internal functions
1080 * ### 1. section creating pidls ###
1082 *************************************************************************
1083 * _ILCreateDesktop()
1084 * _ILCreateIExplore()
1085 * _ILCreateMyComputer()
1090 LPITEMIDLIST
_ILCreateDesktop()
1092 return _ILCreate(PT_DESKTOP
, NULL
, 0);
1095 LPITEMIDLIST
_ILCreateMyComputer()
1097 return _ILCreate(PT_MYCOMP
, &CLSID_MyComputer
, sizeof(GUID
));
1100 LPITEMIDLIST
_ILCreateIExplore()
1102 return _ILCreate(PT_MYCOMP
, &CLSID_Internet
, sizeof(GUID
));
1105 LPITEMIDLIST
_ILCreateControl()
1107 return _ILCreate(PT_SPECIAL
, &CLSID_ControlPanel
, sizeof(GUID
));
1110 LPITEMIDLIST
_ILCreatePrinter()
1112 return _ILCreate(PT_SPECIAL
, &CLSID_Printers
, sizeof(GUID
));
1115 LPITEMIDLIST
_ILCreateNetwork()
1117 return _ILCreate(PT_MYCOMP
, &CLSID_NetworkPlaces
, sizeof(GUID
));
1120 LPITEMIDLIST
_ILCreateBitBucket()
1122 return _ILCreate(PT_MYCOMP
, &CLSID_RecycleBin
, sizeof(GUID
));
1125 LPITEMIDLIST
_ILCreateDrive( LPCSTR lpszNew
)
1127 lstrcpynA (sTemp
,lpszNew
,4);
1130 TRACE("(%s)\n",sTemp
);
1131 return _ILCreate(PT_DRIVE
,(LPVOID
)&sTemp
[0],4);
1134 LPITEMIDLIST
_ILCreateFolder( WIN32_FIND_DATAA
* stffile
)
1136 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1137 char * pbuff
= buff
;
1141 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1143 /* prepare buffer with both names */
1144 len
= strlen (stffile
->cFileName
) + 1;
1145 memcpy (pbuff
, stffile
->cFileName
, len
);
1148 if (stffile
->cAlternateFileName
)
1150 len1
= strlen (stffile
->cAlternateFileName
)+1;
1151 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1159 pidl
= _ILCreate(PT_FOLDER
, (LPVOID
)buff
, len
+ len1
);
1161 /* set attributes */
1165 pData
= _ILGetDataPointer(pidl
);
1166 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1167 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1168 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1174 LPITEMIDLIST
_ILCreateValue(WIN32_FIND_DATAA
* stffile
)
1176 char buff
[MAX_PATH
+ 14 +1]; /* see WIN32_FIND_DATA */
1177 char * pbuff
= buff
;
1181 TRACE("(%s, %s)\n",stffile
->cAlternateFileName
, stffile
->cFileName
);
1183 /* prepare buffer with both names */
1184 len
= strlen (stffile
->cFileName
) + 1;
1185 memcpy (pbuff
, stffile
->cFileName
, len
);
1188 if (stffile
->cAlternateFileName
)
1190 len1
= strlen (stffile
->cAlternateFileName
)+1;
1191 memcpy (pbuff
, stffile
->cAlternateFileName
, len1
);
1199 pidl
= _ILCreate(PT_VALUE
, (LPVOID
)buff
, len
+ len1
);
1201 /* set attributes */
1205 pData
= _ILGetDataPointer(pidl
);
1206 FileTimeToDosDateTime(&(stffile
->ftLastWriteTime
),&pData
->u
.folder
.uFileDate
,&pData
->u
.folder
.uFileTime
);
1207 pData
->u
.folder
.dwFileSize
= stffile
->nFileSizeLow
;
1208 pData
->u
.folder
.uFileAttribs
=stffile
->dwFileAttributes
;
1214 LPITEMIDLIST
_ILCreateSpecial(LPCSTR szGUID
)
1219 if (!MultiByteToWideChar( CP_ACP
, 0, szGUID
, -1, buffer
, sizeof(buffer
)/sizeof(WCHAR
) ))
1221 CLSIDFromString( buffer
, &iid
);
1222 return _ILCreate(PT_MYCOMP
, &iid
, sizeof(IID
));
1225 /**************************************************************************
1227 * Creates a new PIDL
1228 * type = PT_DESKTOP | PT_DRIVE | PT_FOLDER | PT_VALUE
1230 * uInSize = size of data (raw)
1233 LPITEMIDLIST
_ILCreate(PIDLTYPE type
, LPCVOID pIn
, UINT uInSize
)
1235 LPITEMIDLIST pidlOut
= NULL
, pidlTemp
= NULL
;
1240 TRACE("(0x%02x %p %i)\n",type
,pIn
,uInSize
);
1249 uSize
= 2 + 2 + sizeof(GUID
);
1256 uSize
= 2 + 12 + uInSize
;
1259 FIXME("can't create type: 0x%08x\n",type
);
1263 if(!(pidlOut
= SHAlloc(uSize
+ 2))) return NULL
;
1264 ZeroMemory(pidlOut
, uSize
+ 2);
1265 pidlOut
->mkid
.cb
= uSize
;
1270 TRACE("- create Desktop\n");
1275 pData
=_ILGetDataPointer(pidlOut
);
1277 memcpy(&(pData
->u
.mycomp
.guid
), pIn
, uInSize
);
1278 TRACE("- create GUID-pidl\n");
1282 pData
=_ILGetDataPointer(pidlOut
);
1284 pszDest
= _ILGetTextPointer(pidlOut
);
1285 memcpy(pszDest
, pIn
, uInSize
);
1286 TRACE("- create Drive: %s\n",debugstr_a(pszDest
));
1291 pData
=_ILGetDataPointer(pidlOut
);
1293 pszDest
= _ILGetTextPointer(pidlOut
);
1294 memcpy(pszDest
, pIn
, uInSize
);
1295 TRACE("- create Value: %s\n",debugstr_a(pszDest
));
1299 pidlTemp
= ILGetNext(pidlOut
);
1301 pidlTemp
->mkid
.cb
= 0x00;
1303 TRACE("-- (pidl=%p, size=%u)\n", pidlOut
, uSize
);
1307 /**************************************************************************
1310 * Gets the text for the drive eg. 'c:\'
1315 DWORD
_ILGetDrive(LPCITEMIDLIST pidl
,LPSTR pOut
, UINT uSize
)
1316 { TRACE("(%p,%p,%u)\n",pidl
,pOut
,uSize
);
1318 if(_ILIsMyComputer(pidl
))
1319 pidl
= ILGetNext(pidl
);
1321 if (pidl
&& _ILIsDrive(pidl
))
1322 return _ILSimpleGetText(pidl
, pOut
, uSize
);
1327 /**************************************************************************
1329 * ### 2. section testing pidls ###
1331 **************************************************************************
1334 * _ILIsSpecialFolder()
1340 BOOL
_ILIsDesktop(LPCITEMIDLIST pidl
)
1341 { TRACE("(%p)\n",pidl
);
1342 return ( !pidl
|| (pidl
&& pidl
->mkid
.cb
== 0x00) );
1345 BOOL
_ILIsMyComputer(LPCITEMIDLIST pidl
)
1347 REFIID iid
= _ILGetGUIDPointer(pidl
);
1349 TRACE("(%p)\n",pidl
);
1352 return IsEqualIID(iid
, &CLSID_MyComputer
);
1356 BOOL
_ILIsSpecialFolder (LPCITEMIDLIST pidl
)
1358 LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1359 TRACE("(%p)\n",pidl
);
1360 return (pidl
&& ( (lpPData
&& (PT_MYCOMP
== lpPData
->type
|| PT_SPECIAL
== lpPData
->type
)) ||
1361 (pidl
&& pidl
->mkid
.cb
== 0x00)
1365 BOOL
_ILIsDrive(LPCITEMIDLIST pidl
)
1366 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1367 TRACE("(%p)\n",pidl
);
1368 return (pidl
&& lpPData
&& (PT_DRIVE
== lpPData
->type
||
1369 PT_DRIVE1
== lpPData
->type
||
1370 PT_DRIVE2
== lpPData
->type
||
1371 PT_DRIVE3
== lpPData
->type
));
1374 BOOL
_ILIsFolder(LPCITEMIDLIST pidl
)
1375 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1376 TRACE("(%p)\n",pidl
);
1377 return (pidl
&& lpPData
&& (PT_FOLDER
== lpPData
->type
|| PT_FOLDER1
== lpPData
->type
));
1380 BOOL
_ILIsValue(LPCITEMIDLIST pidl
)
1381 { LPPIDLDATA lpPData
= _ILGetDataPointer(pidl
);
1382 TRACE("(%p)\n",pidl
);
1383 return (pidl
&& lpPData
&& PT_VALUE
== lpPData
->type
);
1386 /**************************************************************************
1389 BOOL
_ILIsPidlSimple ( LPCITEMIDLIST pidl
)
1393 if(! _ILIsDesktop(pidl
)) /* pidl=NULL or mkid.cb=0 */
1395 WORD len
= pidl
->mkid
.cb
;
1396 LPCITEMIDLIST pidlnext
= (LPCITEMIDLIST
) (((LPBYTE
)pidl
) + len
);
1397 if (pidlnext
->mkid
.cb
)
1401 TRACE("%s\n", ret
? "Yes" : "No");
1405 /**************************************************************************
1407 * ### 3. section getting values from pidls ###
1410 /**************************************************************************
1413 * gets the text for the first item in the pidl (eg. simple pidl)
1415 * returns the lenght of the string
1417 DWORD
_ILSimpleGetText (LPCITEMIDLIST pidl
, LPSTR szOut
, UINT uOutSize
)
1422 char szTemp
[MAX_PATH
];
1424 TRACE("(%p %p %x)\n",pidl
,szOut
,uOutSize
);
1426 if (!pidl
) return 0;
1431 if (_ILIsDesktop(pidl
))
1434 if (HCR_GetClassName(&CLSID_ShellDesktop
, szTemp
, MAX_PATH
))
1437 lstrcpynA(szOut
, szTemp
, uOutSize
);
1439 dwReturn
= strlen (szTemp
);
1442 else if (( szSrc
= _ILGetTextPointer(pidl
) ))
1446 lstrcpynA(szOut
, szSrc
, uOutSize
);
1448 dwReturn
= strlen(szSrc
);
1450 else if (( riid
= _ILGetGUIDPointer(pidl
) ))
1452 /* special folder */
1453 if ( HCR_GetClassName(riid
, szTemp
, MAX_PATH
) )
1456 lstrcpynA(szOut
, szTemp
, uOutSize
);
1458 dwReturn
= strlen (szTemp
);
1463 ERR("-- no text\n");
1466 TRACE("-- (%p=%s 0x%08lx)\n",szOut
,(char*)szOut
,dwReturn
);
1470 /**************************************************************************
1472 * ### 4. getting pointers to parts of pidls ###
1474 **************************************************************************
1475 * _ILGetDataPointer()
1477 LPPIDLDATA
_ILGetDataPointer(LPITEMIDLIST pidl
)
1479 if(pidl
&& pidl
->mkid
.cb
!= 0x00)
1480 return (LPPIDLDATA
) &(pidl
->mkid
.abID
);
1484 /**************************************************************************
1485 * _ILGetTextPointer()
1486 * gets a pointer to the long filename string stored in the pidl
1488 LPSTR
_ILGetTextPointer(LPCITEMIDLIST pidl
)
1489 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1491 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1495 switch (pdata
->type
)
1505 return (LPSTR
)&(pdata
->u
.drive
.szDriveName
);
1511 return (LPSTR
)&(pdata
->u
.file
.szNames
);
1517 return (LPSTR
)&(pdata
->u
.network
.szNames
);
1523 /**************************************************************************
1524 * _ILGetSTextPointer()
1525 * gets a pointer to the short filename string stored in the pidl
1527 LPSTR
_ILGetSTextPointer(LPCITEMIDLIST pidl
)
1528 {/* TRACE(pidl,"(pidl%p)\n", pidl);*/
1530 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1534 switch (pdata
->type
)
1539 return (LPSTR
)(pdata
->u
.file
.szNames
+ strlen (pdata
->u
.file
.szNames
) + 1);
1542 return (LPSTR
)(pdata
->u
.network
.szNames
+ strlen (pdata
->u
.network
.szNames
) + 1);
1548 /**************************************************************************
1549 * _ILGetGUIDPointer()
1551 * returns reference to guid stored in some pidls
1553 REFIID
_ILGetGUIDPointer(LPCITEMIDLIST pidl
)
1555 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1559 switch (pdata
->type
)
1563 return (REFIID
) &(pdata
->u
.mycomp
.guid
);
1569 /*************************************************************************
1570 * _ILGetFileDateTime
1572 * Given the ItemIdList, get the FileTime
1575 * pidl [I] The ItemIDList
1576 * pFt [I] the resulted FILETIME of the file
1579 * True if Successful
1584 BOOL
_ILGetFileDateTime(LPCITEMIDLIST pidl
, FILETIME
*pFt
)
1586 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1588 if(! pdata
) return FALSE
;
1590 switch (pdata
->type
)
1593 DosDateTimeToFileTime(pdata
->u
.folder
.uFileDate
, pdata
->u
.folder
.uFileTime
, pFt
);
1596 DosDateTimeToFileTime(pdata
->u
.file
.uFileDate
, pdata
->u
.file
.uFileTime
, pFt
);
1604 BOOL
_ILGetFileDate (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1609 if (! _ILGetFileDateTime( pidl
, &ft
)) return FALSE
;
1611 FileTimeToLocalFileTime(&ft
, &lft
);
1612 FileTimeToSystemTime (&lft
, &time
);
1613 return GetDateFormatA(LOCALE_USER_DEFAULT
,DATE_SHORTDATE
,&time
, NULL
, pOut
, uOutSize
);
1616 /*************************************************************************
1619 * Given the ItemIdList, get the FileSize
1622 * pidl [I] The ItemIDList
1623 * pOut [I] The buffer to save the result
1624 * uOutsize [I] The size of the buffer
1630 * pOut can be null when no string is needed
1633 DWORD
_ILGetFileSize (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1635 LPPIDLDATA pdata
=_ILGetDataPointer(pidl
);
1638 if(! pdata
) return 0;
1640 switch (pdata
->type
)
1643 dwSize
= pdata
->u
.file
.dwFileSize
;
1644 if (pOut
) StrFormatByteSizeA(dwSize
, pOut
, uOutSize
);
1647 if (pOut
) *pOut
= 0x00;
1651 BOOL
_ILGetExtension (LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1653 char szTemp
[MAX_PATH
];
1654 const char * pPoint
;
1655 LPITEMIDLIST pidlTemp
=pidl
;
1657 TRACE("pidl=%p\n",pidl
);
1659 if (!pidl
) return FALSE
;
1661 pidlTemp
= ILFindLastID(pidl
);
1663 if (!_ILIsValue(pidlTemp
)) return FALSE
;
1664 if (!_ILSimpleGetText(pidlTemp
, szTemp
, MAX_PATH
)) return FALSE
;
1666 pPoint
= PathFindExtensionA(szTemp
);
1668 if (! *pPoint
) return FALSE
;
1671 lstrcpynA(pOut
, pPoint
, uOutSize
);
1677 /*************************************************************************
1680 * Given the ItemIdList, get the file type description
1683 * pidl [I] The ItemIDList (simple)
1684 * pOut [I] The buffer to save the result
1685 * uOutsize [I] The size of the buffer
1691 * This function copies as much as possible into the buffer.
1693 void _ILGetFileType(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1695 if(_ILIsValue(pidl
))
1702 if (_ILGetExtension (pidl
, sTemp
, 64))
1704 if (!( HCR_MapTypeToValue(sTemp
, sTemp
, 64, TRUE
)
1705 && HCR_MapTypeToValue(sTemp
, pOut
, uOutSize
, FALSE
)))
1707 lstrcpynA (pOut
, sTemp
, uOutSize
- 6);
1708 strcat (pOut
, "-file");
1714 lstrcpynA(pOut
, "Folder", uOutSize
);
1718 /*************************************************************************
1719 * _ILGetFileAttributes
1721 * Given the ItemIdList, get the Attrib string format
1724 * pidl [I] The ItemIDList
1725 * pOut [I] The buffer to save the result
1726 * uOutsize [I] The size of the Buffer
1732 * return value 0 in case of error is a valid return value
1735 DWORD
_ILGetFileAttributes(LPCITEMIDLIST pidl
, LPSTR pOut
, UINT uOutSize
)
1737 LPPIDLDATA pData
=_ILGetDataPointer(pidl
);
1741 if(! pData
) return 0;
1746 wAttrib
= pData
->u
.folder
.uFileAttribs
;
1749 wAttrib
= pData
->u
.file
.uFileAttribs
;
1756 if(wAttrib
& FILE_ATTRIBUTE_READONLY
)
1760 if(wAttrib
& FILE_ATTRIBUTE_HIDDEN
)
1764 if(wAttrib
& FILE_ATTRIBUTE_SYSTEM
)
1768 if(wAttrib
& FILE_ATTRIBUTE_ARCHIVE
)
1772 if(wAttrib
& FILE_ATTRIBUTE_COMPRESSED
)
1781 /*************************************************************************
1784 * free a aPidl struct
1786 void _ILFreeaPidl(LPITEMIDLIST
* apidl
, UINT cidl
)
1792 for(i
= 0; i
< cidl
; i
++) SHFree(apidl
[i
]);
1797 /*************************************************************************
1800 * copys a aPidl struct
1802 LPITEMIDLIST
* _ILCopyaPidl(LPITEMIDLIST
* apidlsrc
, UINT cidl
)
1805 LPITEMIDLIST
* apidldest
= (LPITEMIDLIST
*)SHAlloc(cidl
* sizeof(LPITEMIDLIST
));
1806 if(!apidlsrc
) return NULL
;
1808 for(i
= 0; i
< cidl
; i
++)
1809 apidldest
[i
] = ILClone(apidlsrc
[i
]);
1814 /*************************************************************************
1815 * _ILCopyCidaToaPidl
1817 * creates aPidl from CIDA
1819 LPITEMIDLIST
* _ILCopyCidaToaPidl(LPITEMIDLIST
* pidl
, LPCIDA cida
)
1822 LPITEMIDLIST
* dst
= (LPITEMIDLIST
*)SHAlloc(cida
->cidl
* sizeof(LPITEMIDLIST
));
1824 if(!dst
) return NULL
;
1827 *pidl
= ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[0]]));
1829 for(i
= 0; i
< cida
->cidl
; i
++)
1830 dst
[i
] = ILClone((LPITEMIDLIST
)(&((LPBYTE
)cida
)[cida
->aoffset
[i
+ 1]]));