Context Navigation

source: trunk/src/shell32/pidl.cpp@ 3313

Visit:

Last change on this file since 3313 was 3257, checked in by cbratschi, 25 years ago
floppy name resource, release fix (don't use pdump)
File size: 46.7 KB

Line
1	/* $Id: pidl.cpp,v 1.7 2000-03-28 15:28:43 cbratschi Exp $ */
2
3	/*
4	* Win32 SHELL32 for OS/2
5	*
6	* Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
7	* Project Odin Software License can be found in LICENSE.TXT
8	*
9	* pidl Handling
10	*
11	* Copyright 1998 Juergen Schmied
12	*
13	* NOTES
14	* a pidl == NULL means desktop and is legal
15	*
16	* Corel WINE 20000324 level
17	*/
18
19	/*****************************************************************************
20	* Includes *
21	*****************************************************************************/
22
23	#include <odin.h>
24	#include <odinwrap.h>
25	#include <os2sel.h>
26
27	#include <ctype.h>
28	#include <stdlib.h>
29	#include <string.h>
30	#include <assert.h>
31
32	#define ICOM_CINTERFACE 1
33	#define CINTERFACE 1
34
35	#include "debugtools.h"
36	#include "shell.h"
37	#include "shlguid.h"
38	#include "winerror.h"
39	#include "winnls.h"
40	#include "winversion.h"
41	#include "shell32_main.h"
42
43	#include "pidl.h"
44	#include "wine/undocshell.h"
45
46	#include <heapstring.h>
47	#include <misc.h>
48
49
50	ODINDEBUGCHANNEL(SHELL32-PIDL)
51
52	#ifdef DEBUG
53	void pdump (LPCITEMIDLIST pidl)
54	{ DWORD type;
55	char * szData;
56	char * szShortName;
57	char szName[MAX_PATH];
58	BOOL bIsShellDebug;
59
60	LPITEMIDLIST pidltemp = pidl;
61	if (!TRACE_ON(pidl))
62	return;
63
64	/* silence the sub-functions */
65	bIsShellDebug = TRACE_ON(shell);
66	__SET_DEBUGGING(__DBCL_TRACE, dbch_shell, FALSE);
67	__SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
68
69	if (! pidltemp)
70	{
71	MESSAGE ("-------- pidl=NULL (Desktop)\n");
72	}
73	else
74	{
75	MESSAGE ("-------- pidl=%p\n", pidl);
76	if (pidltemp->mkid.cb)
77	{
78	do
79	{
80	type = _ILGetDataPointer(pidltemp)->type;
81	szData = _ILGetTextPointer(type, _ILGetDataPointer(pidltemp));
82	szShortName = _ILGetSTextPointer(type, _ILGetDataPointer(pidltemp));
83	_ILSimpleGetText(pidltemp, szName, MAX_PATH);
84
85	MESSAGE ("-- pidl=%p size=%u type=%lx name=%s (%s,%s)\n",
86	pidltemp, pidltemp->mkid.cb,type,szName,debugstr_a(szData), debugstr_a(szShortName));
87
88	pidltemp = ILGetNext(pidltemp);
89
90	} while (pidltemp->mkid.cb);
91	}
92	else
93	{
94	MESSAGE ("empty pidl (Desktop)\n");
95	}
96	pcheck(pidl);
97	}
98
99	__SET_DEBUGGING(__DBCL_TRACE, dbch_shell, bIsShellDebug);
100	__SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, TRUE);
101
102	}
103	#endif
104
105	#define BYTES_PRINTED 32
106	BOOL pcheck (LPCITEMIDLIST pidl)
107	{ DWORD type, ret=TRUE;
108	BOOL bIsPidlDebug;
109
110	LPITEMIDLIST pidltemp = pidl;
111
112	bIsPidlDebug = TRACE_ON(shell);
113	__SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, FALSE);
114
115	if (pidltemp && pidltemp->mkid.cb)
116	{ do
117	{ type = _ILGetDataPointer(pidltemp)->type;
118	switch (type)
119	{ case PT_DESKTOP:
120	case PT_MYCOMP:
121	case PT_SPECIAL:
122	case PT_DRIVE:
123	case PT_DRIVE1:
124	case PT_DRIVE2:
125	case PT_DRIVE3:
126	case PT_FOLDER:
127	case PT_VALUE:
128	case PT_FOLDER1:
129	case PT_WORKGRP:
130	case PT_COMP:
131	case PT_NETWORK:
132	case PT_SHARE:
133	case PT_IESPECIAL:
134	break;
135	default:
136	{
137	char szTemp[BYTES_PRINTED*4 + 1];
138	int i;
139	unsigned char c;
140
141	memset(szTemp, ' ', BYTES_PRINTED*4 + 1);
142	for ( i = 0; (i<pidltemp->mkid.cb) && (i<BYTES_PRINTED); i++)
143	{
144	c = ((unsigned char *)pidltemp)[i];
145
146	szTemp[i*3+0] = ((c>>4)>9)? (c>>4)+55 : (c>>4)+48;
147	szTemp[i*3+1] = ((0x0F&c)>9)? (0x0F&c)+55 : (0x0F&c)+48;
148	szTemp[i*3+2] = ' ';
149	szTemp[i+BYTES_PRINTED*3] = (c>=0x20 && c <=0x80) ? c : '.';
150	}
151	szTemp[BYTES_PRINTED*4] = 0x00;
152	ERR_(pidl)("unknown IDLIST type size=%u type=%lx\n%s\n",pidltemp->mkid.cb,type, szTemp);
153	ret = FALSE;
154	}
155	}
156	pidltemp = ILGetNext(pidltemp);
157	} while (pidltemp->mkid.cb);
158	}
159	__SET_DEBUGGING(__DBCL_TRACE, dbch_pidl, bIsPidlDebug);
160	return ret;
161	}
162
163	/*************************************************************************
164	* ILGetDisplayName [SHELL32.15]
165	*/
166
167	ODINFUNCTION2(BOOL,ILGetDisplayName,LPCITEMIDLIST, pidl,
168	LPSTR, path)
169	{
170	TRACE_(shell)("pidl=%p %p semi-stub\n",pidl,path);
171	return SHGetPathFromIDListA(pidl, path);
172	}
173
174
175	/*************************************************************************
176	* ILFindLastID [SHELL32.16]
177	*
178	* NOTES
179	* observed: pidl=Desktop return=pidl
180	*/
181
182	ODINFUNCTION1(LPITEMIDLIST,ILFindLastID,LPITEMIDLIST, pidl)
183	{ LPITEMIDLIST pidlLast = pidl;
184
185	while (pidl->mkid.cb)
186	{
187	pidlLast = pidl;
188	pidl = ILGetNext(pidl);
189	}
190	return pidlLast;
191	}
192	/*************************************************************************
193	* ILRemoveLastID [SHELL32.17]
194	*
195	* NOTES
196	* when pidl=Desktop return=FALSE
197	*/
198
199	ODINFUNCTION1(BOOL,ILRemoveLastID,LPCITEMIDLIST, pidl)
200	{
201	if (!pidl \|\| !pidl->mkid.cb)
202	return 0;
203	ILFindLastID(pidl)->mkid.cb = 0;
204	return 1;
205	}
206
207	/*************************************************************************
208	* ILClone [SHELL32.18]
209	*
210	* NOTES
211	* dupicate an idlist
212	*/
213
214	ODINFUNCTION1(LPITEMIDLIST,ILClone,LPCITEMIDLIST,pidl)
215	{ DWORD len;
216	LPITEMIDLIST newpidl;
217
218	if (!pidl)
219	return NULL;
220
221	len = ILGetSize(pidl);
222	newpidl = (LPITEMIDLIST)SHAlloc(len);
223	if (newpidl)
224	memcpy(newpidl,pidl,len);
225
226	TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
227	pdump(pidl);
228
229	return newpidl;
230	}
231
232
233	/*************************************************************************
234	* ILCloneFirst [SHELL32.19]
235	*
236	* NOTES
237	* duplicates the first idlist of a complex pidl
238	*/
239
240	ODINFUNCTION1(LPITEMIDLIST,ILCloneFirst,LPCITEMIDLIST,pidl)
241	{ DWORD len;
242	LPITEMIDLIST pidlNew = NULL;
243
244	pdump(pidl);
245
246	if (pidl)
247	{
248	len = pidl->mkid.cb;
249	pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
250	if (pidlNew)
251	{
252	memcpy(pidlNew,pidl,len+2); /* 2 -> mind a desktop pidl */
253
254	if (len)
255	ILGetNext(pidlNew)->mkid.cb = 0x00;
256	}
257	}
258	TRACE_(pidl)("-- newpidl=%p\n",pidlNew);
259
260	return pidlNew;
261	}
262	/*************************************************************************
263	* ILLoadFromStream
264	*
265	* NOTES
266	* the first two bytes are the len, the pidl is following then
267	*/
268
269	ODINFUNCTION2(HRESULT,ILLoadFromStream,IStream*, pStream,
270	LPITEMIDLIST*, ppPidl)
271	{ WORD wLen = 0;
272	DWORD dwBytesRead;
273	HRESULT ret = E_FAIL;
274
275	if (*ppPidl)
276	{ SHFree(*ppPidl);
277	*ppPidl = NULL;
278	}
279
280	IStream_AddRef (pStream);
281
282	if (SUCCEEDED(IStream_Read(pStream, (LPVOID)&wLen, 2, &dwBytesRead)))
283	{ ppPidl = (ITEMIDLIST)SHAlloc (wLen);
284	if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
285	{ ret = S_OK;
286	}
287	else
288	{ SHFree(*ppPidl);
289	*ppPidl = NULL;
290	}
291	}
292
293	/* we are not jet fully compatible */
294	if (!pcheck(*ppPidl))
295	{ SHFree(*ppPidl);
296	*ppPidl = NULL;
297	}
298
299
300	IStream_Release (pStream);
301
302	return ret;
303	}
304	/*************************************************************************
305	* SHILCreateFromPath [SHELL32.28]
306	*
307	* NOTES
308	* wraper for IShellFolder::ParseDisplayName()
309	*/
310
311	ODINFUNCTION3(HRESULT,SHILCreateFromPathA,LPCSTR, path,
312	LPITEMIDLIST*, ppidl,
313	DWORD*, attributes)
314	{ LPSHELLFOLDER sf;
315	WCHAR lpszDisplayName[MAX_PATH];
316	DWORD pchEaten;
317	HRESULT ret = E_FAIL;
318
319	LocalToWideChar(lpszDisplayName, (LPSTR)path, MAX_PATH);
320
321	if (SUCCEEDED (SHGetDesktopFolder(&sf)))
322	{
323	ret = IShellFolder_ParseDisplayName(sf,0, NULL,lpszDisplayName,&pchEaten,ppidl,attributes);
324	IShellFolder_Release(sf);
325	}
326	return ret;
327	}
328
329	ODINFUNCTION3(HRESULT,SHILCreateFromPathW,LPCWSTR, path,
330	LPITEMIDLIST*, ppidl,
331	DWORD*, attributes)
332	{ LPSHELLFOLDER sf;
333	DWORD pchEaten;
334	HRESULT ret = E_FAIL;
335
336	if (SUCCEEDED (SHGetDesktopFolder(&sf)))
337	{
338	ret = IShellFolder_ParseDisplayName(sf,0, NULL, (LPOLESTR)path, &pchEaten, ppidl, attributes);
339	IShellFolder_Release(sf);
340	}
341	return ret;
342	}
343
344	ODINFUNCTION3(HRESULT,SHILCreateFromPathAW,LPCVOID, path,
345	LPITEMIDLIST*, ppidl,
346	DWORD*, attributes)
347	{
348	if ( VERSION_OsIsUnicode())
349	return SHILCreateFromPathW ((LPCWSTR)path, ppidl, attributes);
350	return SHILCreateFromPathA ((LPCSTR)path, ppidl, attributes);
351	}
352
353	/*************************************************************************
354	* SHCloneSpecialIDList [SHELL32.89]
355	*
356	* PARAMETERS
357	* hwndOwner [in]
358	* nFolder [in] CSIDL_xxxxx ??
359	*
360	* RETURNS
361	* pidl ??
362	* NOTES
363	* exported by ordinal
364	*/
365
366	ODINFUNCTION3(LPITEMIDLIST,SHCloneSpecialIDList,HWND, hwndOwner,
367	DWORD, nFolder,
368	DWORD, x3)
369	{ LPITEMIDLIST ppidl;
370	WARN_(shell)("(hwnd=0x%x,csidl=0x%lx,0x%lx):semi-stub.\n",
371	hwndOwner,nFolder,x3);
372
373	SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
374
375	return ppidl;
376	}
377
378	/*************************************************************************
379	* ILGlobalClone [SHELL32.97]
380	*
381	*/
382
383	ODINFUNCTION1(LPITEMIDLIST,ILGlobalClone,LPCITEMIDLIST, pidl)
384	{ DWORD len;
385	LPITEMIDLIST newpidl;
386
387	if (!pidl)
388	return NULL;
389
390	len = ILGetSize(pidl);
391	newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
392	if (newpidl)
393	memcpy(newpidl,pidl,len);
394
395	TRACE_(pidl)("pidl=%p newpidl=%p\n",pidl, newpidl);
396	pdump(pidl);
397
398	return newpidl;
399	}
400
401	/*************************************************************************
402	* ILIsEqual [SHELL32.21]
403	*
404	*/
405
406	ODINFUNCTION2(BOOL,ILIsEqual,LPCITEMIDLIST, pidl1,
407	LPCITEMIDLIST, pidl2)
408	{
409	char szData1[MAX_PATH];
410	char szData2[MAX_PATH];
411
412	LPITEMIDLIST pidltemp1 = pidl1;
413	LPITEMIDLIST pidltemp2 = pidl2;
414
415	/* explorer reads from registry directly (StreamMRU),
416	so we can only check here */
417	if ((!pcheck (pidl1)) \|\| (!pcheck (pidl2))) return FALSE;
418
419	pdump (pidl1);
420	pdump (pidl2);
421
422	if ( (!pidl1) \|\| (!pidl2) ) return FALSE;
423
424	while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
425	{
426	_ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
427	_ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
428
429	if (strcmp ( szData1, szData2 )!=0 )
430	return FALSE;
431
432	pidltemp1 = ILGetNext(pidltemp1);
433	pidltemp2 = ILGetNext(pidltemp2);
434	}
435
436	if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
437	{
438	return TRUE;
439	}
440
441	return FALSE;
442	}
443	/*************************************************************************
444	* ILIsParent [SHELL32.23]
445	*
446	* parent=a/b child=a/b/c -> true, c is in folder a/b
447	* child=a/b/c/d -> false if bImmediate is true, d is not in folder a/b
448	* child=a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
449	*/
450
451	ODINFUNCTION3(BOOL,ILIsParent,LPCITEMIDLIST, pidlParent,
452	LPCITEMIDLIST, pidlChild,
453	BOOL, bImmediate)
454	{
455	char szData1[MAX_PATH];
456	char szData2[MAX_PATH];
457
458	LPITEMIDLIST pParent = pidlParent;
459	LPITEMIDLIST pChild = pidlChild;
460
461	while (pParent->mkid.cb && pChild->mkid.cb)
462	{
463	_ILSimpleGetText(pParent, szData1, MAX_PATH);
464	_ILSimpleGetText(pChild, szData2, MAX_PATH);
465
466	if (strcmp ( szData1, szData2 )!=0 )
467	return FALSE;
468
469	pParent = ILGetNext(pParent);
470	pChild = ILGetNext(pChild);
471	}
472
473	if ( pParent->mkid.cb \|\| ! pChild->mkid.cb) /* child shorter or has equal length to parent */
474	return FALSE;
475
476	if ( ILGetNext(pChild)->mkid.cb && bImmediate) /* not immediate descent */
477	return FALSE;
478
479	return TRUE;
480	}
481
482	/*************************************************************************
483	* ILFindChild [SHELL32.24]
484	*
485	* NOTES
486	* Compares elements from pidl1 and pidl2.
487	*
488	* pidl1 is desktop pidl2
489	* pidl1 shorter pidl2 pointer to first different element of pidl2
490	* if there was at least one equal element
491	* pidl2 shorter pidl1 0
492	* pidl2 equal pidl1 pointer to last 0x00-element of pidl2
493	*/
494
495	ODINFUNCTION2(LPITEMIDLIST,ILFindChild,LPCITEMIDLIST, pidl1,
496	LPCITEMIDLIST, pidl2)
497	{
498	char szData1[MAX_PATH];
499	char szData2[MAX_PATH];
500
501	LPITEMIDLIST pidltemp1 = pidl1;
502	LPITEMIDLIST pidltemp2 = pidl2;
503	LPITEMIDLIST ret=NULL;
504
505	/* explorer reads from registry directly (StreamMRU),
506	so we can only check here */
507	if ((!pcheck (pidl1)) \|\| (!pcheck (pidl2)))
508	return FALSE;
509
510	pdump (pidl1);
511	pdump (pidl2);
512
513	if ( _ILIsDesktop(pidl1) )
514	{
515	ret = pidl2;
516	}
517	else
518	{
519	while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
520	{
521	_ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
522	_ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
523
524	if (strcmp(szData1,szData2))
525	break;
526
527	pidltemp1 = ILGetNext(pidltemp1);
528	pidltemp2 = ILGetNext(pidltemp2);
529	ret = pidltemp2;
530	}
531
532	if (pidltemp1->mkid.cb)
533	{
534	ret = NULL; /* elements of pidl1 left*/
535	}
536	}
537	TRACE_(shell)("--- %p\n", ret);
538	return ret; /* pidl 1 is shorter */
539	}
540
541	/*************************************************************************
542	* ILCombine [SHELL32.25]
543	*
544	* NOTES
545	* Concatenates two complex idlists.
546	* The pidl is the first one, pidlsub the next one
547	* Does not destroy the passed in idlists!
548	*/
549
550	ODINFUNCTION2(LPITEMIDLIST, ILCombine, LPCITEMIDLIST, pidl1,
551	LPCITEMIDLIST, pidl2)
552	{
553	DWORD len1,len2;
554	LPITEMIDLIST pidlNew;
555
556	if(!pidl1 && !pidl2) return NULL;
557
558	pdump (pidl1);
559	pdump (pidl2);
560
561	if(!pidl1)
562	{
563	pidlNew = ILClone(pidl2);
564	return pidlNew;
565	}
566
567	if(!pidl2)
568	{
569	pidlNew = ILClone(pidl1);
570	return pidlNew;
571	}
572
573	len1 = ILGetSize(pidl1)-2;
574	len2 = ILGetSize(pidl2);
575	pidlNew = (ITEMIDLIST*)SHAlloc(len1+len2);
576
577	if (pidlNew)
578	{
579	memcpy(pidlNew,pidl1,len1);
580	memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
581	}
582
583	/* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
584	return pidlNew;
585	}
586	/*************************************************************************
587	* SHGetRealIDL [SHELL32.98]
588	*
589	* NOTES
590	*/
591
592	ODINFUNCTION3(LPITEMIDLIST, SHGetRealIDL, LPSHELLFOLDER, lpsf,
593	LPITEMIDLIST, pidl,
594	DWORD, z)
595	{
596	FIXME_(pidl)("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
597
598	pdump (pidl);
599	return 0;
600	}
601
602	/*************************************************************************
603	* SHLogILFromFSIL [SHELL32.95]
604	*
605	* NOTES
606	* pild = CSIDL_DESKTOP ret = 0
607	* pild = CSIDL_DRIVES ret = 0
608	*/
609
610	ODINFUNCTION1(LPITEMIDLIST,SHLogILFromFSIL,LPITEMIDLIST,pidl)
611	{
612	FIXME_(pidl)("(pidl=%p)\n",pidl);
613
614	pdump(pidl);
615
616	return 0;
617	}
618
619	/*************************************************************************
620	* ILGetSize [SHELL32.152]
621	* gets the byte size of an idlist including zero terminator (pidl)
622	*
623	* PARAMETERS
624	* pidl ITEMIDLIST
625	*
626	* RETURNS
627	* size of pidl
628	*
629	* NOTES
630	* exported by ordinal
631	*/
632
633	ODINFUNCTION1(DWORD,ILGetSize,LPITEMIDLIST,pidl)
634	{
635	LPSHITEMID si = &(pidl->mkid);
636	DWORD len=0;
637
638	if (pidl)
639	{ while (si->cb)
640	{ len += si->cb;
641	si = (LPSHITEMID)(((LPBYTE)si)+si->cb);
642	}
643	len += 2;
644	}
645	TRACE_(pidl)("pidl=%p size=%lu\n",pidl, len);
646	return len;
647	}
648
649	/*************************************************************************
650	* ILGetNext [SHELL32.153]
651	* gets the next simple pidl of a complex pidl
652	*
653	* observed return values:
654	* null -> null
655	* desktop -> null
656	* simple pidl -> pointer to 0x0000 element
657	*
658	*/
659
660	ODINFUNCTION1(LPITEMIDLIST,ILGetNext,LPITEMIDLIST,pidl)
661	{
662	WORD len;
663
664	if(pidl)
665	{
666	len = pidl->mkid.cb;
667	if (len)
668	{
669	pidl = (LPITEMIDLIST) (((LPBYTE)pidl)+len);
670	return pidl;
671	}
672	}
673	return NULL;
674	}
675	/*************************************************************************
676	* ILAppend [SHELL32.154]
677	*
678	* NOTES
679	* Adds the single item to the idlist indicated by pidl.
680	* if bEnd is 0, adds the item to the front of the list,
681	* otherwise adds the item to the end. (???)
682	* Destroys the passed in idlist! (???)
683	*/
684
685	ODINFUNCTION3(LPITEMIDLIST,ILAppend,LPITEMIDLIST, pidl,
686	LPCITEMIDLIST, item,
687	BOOL, bEnd)
688	{
689	LPITEMIDLIST idlRet;
690
691	WARN_(pidl)("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
692
693	pdump (pidl);
694	pdump (item);
695
696	if (_ILIsDesktop(pidl))
697	{
698	idlRet = ILClone(item);
699	if (pidl)
700	SHFree (pidl);
701	return idlRet;
702	}
703
704	if (bEnd)
705	{
706	idlRet=ILCombine(pidl,item);
707	}
708	else
709	{
710	idlRet=ILCombine(item,pidl);
711	}
712
713	SHFree(pidl);
714	return idlRet;
715	}
716	/*************************************************************************
717	* ILFree [SHELL32.155]
718	*
719	* NOTES
720	* free_check_ptr - frees memory (if not NULL)
721	* allocated by SHMalloc allocator
722	* exported by ordinal
723	*/
724
725	ODINFUNCTION1(DWORD,ILFree,LPITEMIDLIST, pidl)
726	{ TRACE_(pidl)("(pidl=0x%08lx)\n",(DWORD)pidl);
727
728	if (!pidl)
729	return FALSE;
730
731	return SHFree(pidl);
732	}
733	/*************************************************************************
734	* ILGlobalFree [SHELL32.156]
735	*
736	*/
737
738	ODINFUNCTION1(DWORD,ILGlobalFree,LPITEMIDLIST, pidl)
739	{
740	TRACE_(pidl)("%p\n",pidl);
741
742	if (!pidl)
743	return FALSE;
744
745	return pCOMCTL32_Free (pidl);
746	}
747	/*************************************************************************
748	* ILCreateFromPath [SHELL32.157]
749	*
750	*/
751
752	ODINFUNCTION1(LPITEMIDLIST,ILCreateFromPathA,LPCSTR,path)
753	{
754	LPITEMIDLIST pidlnew;
755	DWORD attributes = 0;
756
757	TRACE_(shell)("%s\n",path);
758
759	if (SUCCEEDED (SHILCreateFromPathA (path, &pidlnew, &attributes)))
760	return pidlnew;
761	return FALSE;
762	}
763
764	ODINFUNCTION1(LPITEMIDLIST,ILCreateFromPathW,LPCWSTR,path)
765	{
766	LPITEMIDLIST pidlnew;
767	DWORD attributes = 0;
768
769	TRACE_(shell)("%s\n",debugstr_w(path));
770
771	if (SUCCEEDED (SHILCreateFromPathW (path, &pidlnew, &attributes)))
772	return pidlnew;
773	return FALSE;
774	}
775
776	ODINFUNCTION1(LPITEMIDLIST,ILCreateFromPathAW,LPCVOID,path)
777	{
778	if ( VERSION_OsIsUnicode())
779	return ILCreateFromPathW ((LPCWSTR)path);
780	return ILCreateFromPathA ((LPCSTR)path);
781	}
782	/*************************************************************************
783	* SHSimpleIDListFromPath [SHELL32.162]
784	*/
785
786	ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathA,LPSTR, lpszPath)
787	{
788	LPITEMIDLIST pidl=NULL;
789	HANDLE hFile;
790	WIN32_FIND_DATAA stffile;
791
792	if (!lpszPath) return NULL;
793
794	hFile = FindFirstFileA(lpszPath, &stffile);
795
796	if ( hFile != INVALID_HANDLE_VALUE )
797	{
798	if (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
799	{
800	pidl = _ILCreateFolder (&stffile);
801	}
802	else
803	{
804	pidl = _ILCreateValue (&stffile);
805	}
806	FindClose (hFile);
807	}
808	return pidl;
809	}
810
811	ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathW,LPWSTR, lpszPath)
812	{
813	char lpszTemp[MAX_PATH];
814
815	WideCharToLocal(lpszTemp, lpszPath, MAX_PATH);
816
817	return SHSimpleIDListFromPathA (lpszTemp);
818	}
819
820	ODINFUNCTION1(LPITEMIDLIST,SHSimpleIDListFromPathAW,LPVOID, lpszPath)
821	{
822	if ( VERSION_OsIsUnicode())
823	return SHSimpleIDListFromPathW ((LPWSTR)lpszPath);
824	return SHSimpleIDListFromPathA ((LPSTR)lpszPath);
825	}
826
827	/*************************************************************************
828	* SHGetSpecialFolderLocation [SHELL32.223]
829	*
830	* gets the folder locations from the registry and creates a pidl
831	* creates missing reg keys and directorys
832	*
833	* PARAMS
834	* hwndOwner [I]
835	* nFolder [I] CSIDL_xxxxx
836	* ppidl [O] PIDL of a special folder
837	*
838	*/
839	ODINFUNCTION3(HRESULT,SHGetSpecialFolderLocation,HWND, hwndOwner,
840	INT, nFolder,
841	LPITEMIDLIST*, ppidl)
842	{
843	CHAR szPath[256];
844	HRESULT hr = E_INVALIDARG;
845
846	*ppidl = NULL;
847
848	if (ppidl)
849	{
850	switch (nFolder)
851	{
852	case CSIDL_DESKTOP:
853	*ppidl = _ILCreateDesktop();
854	hr = NOERROR;
855	break;
856
857	case CSIDL_DRIVES:
858	*ppidl = _ILCreateMyComputer();
859	hr = NOERROR;
860	break;
861
862	case CSIDL_NETWORK:
863	*ppidl = _ILCreateNetwork ();
864	hr = NOERROR;
865	break;
866
867	case CSIDL_CONTROLS:
868	*ppidl = _ILCreateControl ();
869	hr = NOERROR;
870	break;
871
872	case CSIDL_PRINTERS:
873	*ppidl = _ILCreatePrinter ();
874	hr = NOERROR;
875	break;
876
877	case CSIDL_BITBUCKET:
878	*ppidl = _ILCreateBitBucket ();
879	hr = NOERROR;
880	break;
881
882	default:
883	if (SHGetSpecialFolderPathA(hwndOwner, szPath, nFolder, TRUE))
884	{
885	DWORD attributes=0;
886	TRACE_(shell)("Value=%s\n",szPath);
887	hr = SHILCreateFromPathA(szPath, ppidl, &attributes);
888	}
889	}
890	}
891
892	TRACE_(shell)("-- (new pidl %p)\n",*ppidl);
893	return hr;
894	}
895
896	/*************************************************************************
897	* SHGetDataFromIDListA [SHELL32.247]
898	*
899	* NOTES
900	* the pidl can be a simple one. since we cant get the path out of the pidl
901	* we have to take all data from the pidl
902	*/
903
904	ODINFUNCTION5(HRESULT,SHGetDataFromIDListA,LPSHELLFOLDER, psf,
905	LPCITEMIDLIST, pidl,
906	int, nFormat,
907	LPVOID, dest,
908	int, len)
909	{
910	DWORD type;
911
912	TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
913
914	if (! psf \|\| !dest ) return E_INVALIDARG;
915
916	switch (nFormat)
917	{
918	case SHGDFIL_FINDDATA:
919	{
920	WIN32_FIND_DATAA * pfd = (WIN32_FIND_DATAA*)dest;
921
922	if ( len < sizeof (WIN32_FIND_DATAA)) return E_INVALIDARG;
923
924	ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
925	_ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
926	pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
927	pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
928	type = _ILGetDataPointer(pidl)->type;
929	lstrcpynA(pfd->cFileName,_ILGetTextPointer(type,_ILGetDataPointer(pidl)), MAX_PATH);
930	lstrcpynA(pfd->cAlternateFileName,_ILGetSTextPointer(type,_ILGetDataPointer(pidl)), 14);
931	}
932	return NOERROR;
933
934	case SHGDFIL_NETRESOURCE:
935	case SHGDFIL_DESCRIPTIONID:
936	FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
937	break;
938
939	default:
940	ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
941	}
942
943	return E_INVALIDARG;
944	}
945	/*************************************************************************
946	* SHGetDataFromIDListW [SHELL32.247]
947	*
948	*/
949
950	ODINFUNCTION5(HRESULT,SHGetDataFromIDListW,LPSHELLFOLDER, psf,
951	LPCITEMIDLIST, pidl,
952	int, nFormat,
953	LPVOID, dest,
954	int, len)
955	{
956	DWORD type;
957
958	if (! psf \|\| !dest ) return E_INVALIDARG;
959
960	switch (nFormat)
961	{
962	case SHGDFIL_FINDDATA:
963	{
964	WIN32_FIND_DATAW * pfd = (WIN32_FIND_DATAW*)dest;
965
966	if ( len < sizeof (WIN32_FIND_DATAW)) return E_INVALIDARG;
967
968	ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
969	_ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
970	pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
971	pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
972	type = _ILGetDataPointer(pidl)->type;
973	lstrcpynAtoW(pfd->cFileName,_ILGetTextPointer(type,_ILGetDataPointer(pidl)), MAX_PATH);
974	lstrcpynAtoW(pfd->cAlternateFileName,_ILGetSTextPointer(type,_ILGetDataPointer(pidl)), 14);
975	}
976	return NOERROR;
977	case SHGDFIL_NETRESOURCE:
978	case SHGDFIL_DESCRIPTIONID:
979	FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
980	break;
981
982	default:
983	ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
984	}
985
986	return E_INVALIDARG;
987	}
988
989	/*************************************************************************
990	* SHGetPathFromIDListA [SHELL32.261][NT 4.0: SHELL32.220]
991	*
992	* PARAMETERS
993	* pidl, [IN] pidl
994	* pszPath [OUT] path
995	*
996	* RETURNS
997	* path from a passed PIDL.
998	*
999	* NOTES
1000	* NULL returns FALSE
1001	* desktop pidl gives path to desktopdirectory back
1002	* special pidls returning FALSE
1003	*
1004	* FIXME
1005	* fnGetDisplayNameOf can return different types of OLEString
1006	*/
1007
1008	ODINFUNCTION2(BOOL,SHGetPathFromIDListA,LPCITEMIDLIST, pidl,
1009	LPSTR, pszPath)
1010	{ STRRET str;
1011	LPSHELLFOLDER shellfolder;
1012
1013	if (!pidl) return FALSE;
1014
1015	pdump(pidl);
1016	#ifdef SHELL_NO_DESKTOP
1017	if(_ILIsDesktop(pidl))
1018	{
1019	SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
1020	}
1021	else
1022	#endif
1023	{
1024	if (SHGetDesktopFolder(&shellfolder)==S_OK)
1025	{
1026	IShellFolder_GetDisplayNameOf(shellfolder,pidl,SHGDN_FORPARSING,&str);
1027	StrRetToStrNA (pszPath, MAX_PATH, &str, pidl);
1028	IShellFolder_Release(shellfolder);
1029	}
1030	}
1031	TRACE_(shell)("-- (%s)\n",pszPath);
1032
1033	return TRUE;
1034	}
1035	/*************************************************************************
1036	* SHGetPathFromIDListW [SHELL32.262]
1037	*/
1038
1039	ODINFUNCTION2(BOOL,SHGetPathFromIDListW,LPCITEMIDLIST, pidl,
1040	LPWSTR, pszPath)
1041	{ char sTemp[MAX_PATH];
1042
1043	SHGetPathFromIDListA (pidl, sTemp);
1044	lstrcpyAtoW(pszPath, sTemp);
1045
1046	TRACE_(shell)("-- (%s)\n",debugstr_w(pszPath));
1047
1048	return TRUE;
1049	}
1050
1051	/*************************************************************************
1052	* SHBindToParent [shell version 5.0]
1053	*/
1054
1055	ODINFUNCTION4(HRESULT,SHBindToParent,LPCITEMIDLIST, pidl,
1056	REFIID, riid,
1057	LPVOID*, ppv,
1058	LPCITEMIDLIST*,ppidlLast)
1059	{
1060	IShellFolder * psf;
1061	LPITEMIDLIST pidlChild, pidlParent;
1062	HRESULT hr=E_FAIL;
1063
1064	pdump(pidl);
1065
1066	*ppv = NULL;
1067	if (ppidlLast) *ppidlLast = NULL;
1068
1069	if (_ILIsPidlSimple(pidl))
1070	{
1071	/* we are on desktop level */
1072	if (ppidlLast)
1073	*ppidlLast = ILClone(pidl);
1074	hr = SHGetDesktopFolder((IShellFolder**)ppv);
1075	}
1076	else
1077	{
1078	pidlChild = ILClone(ILFindLastID(pidl));
1079	pidlParent = ILClone(pidl);
1080	ILRemoveLastID(pidlParent);
1081
1082	hr = SHGetDesktopFolder(&psf);
1083
1084	if (SUCCEEDED(hr))
1085	hr = IShellFolder_BindToObject(psf, pidlParent, NULL, riid, ppv);
1086
1087	if (SUCCEEDED(hr) && ppidlLast)
1088	*ppidlLast = pidlChild;
1089	else
1090	ILFree (pidlChild);
1091
1092	SHFree (pidlParent);
1093	if (psf) IShellFolder_Release(psf);
1094	}
1095
1096
1097	TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08lx\n", ppv, (ppidlLast)?ppidlLast:NULL, hr);
1098	return hr;
1099	}
1100
1101	/*************************************************************************
1102	* SHGetPathFromIDListAW [SHELL32.221][NT 4.0: SHELL32.219]
1103	*/
1104
1105	ODINFUNCTION2(BOOL,SHGetPathFromIDListAW,LPCITEMIDLIST, pidl,
1106	LPVOID, pszPath)
1107	{
1108	if (VERSION_OsIsUnicode())
1109	return SHGetPathFromIDListW(pidl,(LPWSTR)pszPath);
1110	return SHGetPathFromIDListA(pidl,(LPSTR)pszPath);
1111	}
1112
1113	/**************************************************************************
1114	*
1115	* internal functions
1116	*
1117	* ### 1. section creating pidls ###
1118	*
1119	*************************************************************************
1120	* _ILCreateDesktop()
1121	* _ILCreateIExplore()
1122	* _ILCreateMyComputer()
1123	* _ILCreateDrive()
1124	* _ILCreateFolder()
1125	* _ILCreateValue()
1126	*/
1127
1128	ODINFUNCTION0(LPITEMIDLIST,_ILCreateDesktop)
1129	{
1130	return _ILCreate(PT_DESKTOP, NULL, 0);
1131	}
1132
1133	ODINFUNCTION0(LPITEMIDLIST,_ILCreateMyComputer)
1134	{
1135	return _ILCreate(PT_MYCOMP, &CLSID_MyComputer, sizeof(GUID));
1136	}
1137
1138	ODINFUNCTION0(LPITEMIDLIST,_ILCreateIExplore)
1139	{
1140	return _ILCreate(PT_MYCOMP, &CLSID_Internet, sizeof(GUID));
1141	}
1142
1143	ODINFUNCTION0(LPITEMIDLIST,_ILCreateControl)
1144	{
1145	return _ILCreate(PT_SPECIAL, &CLSID_ControlPanel, sizeof(GUID));
1146	}
1147
1148	ODINFUNCTION0(LPITEMIDLIST,_ILCreatePrinter)
1149	{
1150	return _ILCreate(PT_SPECIAL, &CLSID_Printers, sizeof(GUID));
1151	}
1152
1153	ODINFUNCTION0(LPITEMIDLIST,_ILCreateNetwork)
1154	{
1155	return _ILCreate(PT_MYCOMP, &CLSID_NetworkPlaces, sizeof(GUID));
1156	}
1157
1158	ODINFUNCTION0(LPITEMIDLIST,_ILCreateBitBucket)
1159	{
1160	return _ILCreate(PT_MYCOMP, &CLSID_RecycleBin, sizeof(GUID));
1161	}
1162
1163	ODINFUNCTION1(LPITEMIDLIST,_ILCreateDrive,LPCSTR,lpszNew)
1164	{ char sTemp[4];
1165	lstrcpynA (sTemp,lpszNew,4);
1166	sTemp[2]='\\';
1167	sTemp[3]=0x00;
1168	TRACE_(pidl)("(%s)\n",sTemp);
1169	return _ILCreate(PT_DRIVE,(LPVOID)&sTemp[0],4);
1170	}
1171
1172	ODINFUNCTION1(LPITEMIDLIST,_ILCreateFolder,WIN32_FIND_DATAA*, stffile )
1173	{
1174	char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1175	char * pbuff = buff;
1176	ULONG len, len1;
1177	LPITEMIDLIST pidl;
1178
1179	TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1180
1181	/* prepare buffer with both names */
1182	len = strlen (stffile->cFileName) + 1;
1183	memcpy (pbuff, stffile->cFileName, len);
1184	pbuff += len;
1185
1186	if (stffile->cAlternateFileName)
1187	{
1188	len1 = strlen (stffile->cAlternateFileName)+1;
1189	memcpy (pbuff, stffile->cAlternateFileName, len1);
1190	}
1191	else
1192	{
1193	len1 = 1;
1194	*pbuff = 0x00;
1195	}
1196
1197	pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
1198
1199	/* set attributes */
1200	if (pidl)
1201	{
1202	LPPIDLDATA pData;
1203	pData = _ILGetDataPointer(pidl);
1204	FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
1205	pData->u.folder.dwFileSize = stffile->nFileSizeLow;
1206	pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
1207	}
1208
1209	return pidl;
1210	}
1211
1212	ODINFUNCTION1(LPITEMIDLIST,_ILCreateValue,WIN32_FIND_DATAA*, stffile)
1213	{
1214	char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1215	char * pbuff = buff;
1216	ULONG len, len1;
1217	LPITEMIDLIST pidl;
1218
1219	TRACE_(pidl)("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
1220
1221	/* prepare buffer with both names */
1222	len = strlen (stffile->cFileName) + 1;
1223	memcpy (pbuff, stffile->cFileName, len);
1224	pbuff += len;
1225
1226	if (stffile->cAlternateFileName)
1227	{
1228	len1 = strlen (stffile->cAlternateFileName)+1;
1229	memcpy (pbuff, stffile->cAlternateFileName, len1);
1230	}
1231	else
1232	{
1233	len1 = 1;
1234	*pbuff = 0x00;
1235	}
1236
1237	pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
1238
1239	/* set attributes */
1240	if (pidl)
1241	{
1242	LPPIDLDATA pData;
1243	pData = _ILGetDataPointer(pidl);
1244	FileTimeToDosDateTime(&(stffile->ftLastWriteTime),&pData->u.folder.uFileDate,&pData->u.folder.uFileTime);
1245	pData->u.folder.dwFileSize = stffile->nFileSizeLow;
1246	pData->u.folder.uFileAttribs=stffile->dwFileAttributes;
1247	}
1248
1249	return pidl;
1250	}
1251
1252	ODINFUNCTION1(LPITEMIDLIST,_ILCreateSpecial,LPCSTR,szGUID)
1253	{
1254	IID iid;
1255	CLSIDFromStringA(szGUID,&iid);
1256	return _ILCreate(PT_MYCOMP, &iid, sizeof(IID));
1257	}
1258
1259	/**************************************************************************
1260	* _ILCreate()
1261	* Creates a new PIDL
1262	* type = PT_DESKTOP \| PT_DRIVE \| PT_FOLDER \| PT_VALUE
1263	* pIn = data
1264	* uInSize = size of data (raw)
1265	*/
1266
1267	ODINFUNCTION3(LPITEMIDLIST,_ILCreate,PIDLTYPE,type,
1268	LPCVOID, pIn,
1269	UINT16, uInSize)
1270	{ LPITEMIDLIST pidlOut = NULL, pidlTemp = NULL;
1271	LPPIDLDATA pData;
1272	UINT16 uSize = 0;
1273	LPSTR pszDest;
1274
1275	switch (type)
1276	{ case PT_DESKTOP:
1277	uSize = 0;
1278	pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
1279	pidlOut->mkid.cb = uSize;
1280	TRACE_(pidl)("- create Desktop\n");
1281	break;
1282
1283	case PT_MYCOMP:
1284	uSize = 2 + 2 + sizeof(GUID);
1285	pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
1286	ZeroMemory(pidlOut, uSize + 2);
1287	pidlOut->mkid.cb = uSize;
1288	pData =_ILGetDataPointer(pidlOut);
1289	pData->type = type;
1290	memcpy(&(pData->u.mycomp.guid), pIn, uInSize);
1291	TRACE_(pidl)("- create GUID-pidl\n");
1292	break;
1293
1294	case PT_DRIVE:
1295	uSize = 2 + 23;
1296	pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
1297	ZeroMemory(pidlOut, uSize + 2);
1298	pidlOut->mkid.cb = uSize;
1299	pData =_ILGetDataPointer(pidlOut);
1300	pData->type = type;
1301	pszDest = _ILGetTextPointer(type, pData);
1302	memcpy(pszDest, pIn, uInSize);
1303	TRACE_(pidl)("- create Drive: %s\n",debugstr_a(pszDest));
1304	break;
1305
1306	case PT_FOLDER:
1307	case PT_VALUE:
1308	uSize = 2 + 12 + uInSize;
1309	pidlOut = (ITEMIDLIST*)SHAlloc(uSize + 2);
1310	ZeroMemory(pidlOut, uSize + 2);
1311	pidlOut->mkid.cb = uSize;
1312	pData =_ILGetDataPointer(pidlOut);
1313	pData->type = type;
1314	pszDest = _ILGetTextPointer(type, pData);
1315	memcpy(pszDest, pIn, uInSize);
1316	TRACE_(pidl)("- create Value: %s\n",debugstr_a(pszDest));
1317	break;
1318	}
1319
1320	pidlTemp = ILGetNext(pidlOut);
1321	if (pidlTemp)
1322	pidlTemp->mkid.cb = 0x00;
1323
1324	TRACE_(pidl)("-- (pidl=%p, size=%u)\n", pidlOut, uSize);
1325	return pidlOut;
1326	}
1327
1328	/**************************************************************************
1329	* _ILGetDrive()
1330	*
1331	* Gets the text for the drive eg. 'c:\'
1332	*
1333	* RETURNS
1334	* strlen (lpszText)
1335	*/
1336
1337	ODINFUNCTION3(DWORD,_ILGetDrive,LPCITEMIDLIST, pidl,
1338	LPSTR, pOut,
1339	UINT16, uSize)
1340	{
1341	if(_ILIsMyComputer(pidl))
1342	pidl = ILGetNext(pidl);
1343
1344	if (pidl && _ILIsDrive(pidl))
1345	return _ILSimpleGetText(pidl, pOut, uSize);
1346
1347	return 0;
1348	}
1349
1350	/**************************************************************************
1351	*
1352	* ### 2. section testing pidls ###
1353	*
1354	**************************************************************************
1355	* _ILIsDesktop()
1356	* _ILIsMyComputer()
1357	* _ILIsSpecialFolder()
1358	* _ILIsDrive()
1359	* _ILIsFolder()
1360	* _ILIsValue()
1361	* _ILIsPidlSimple()
1362	*/
1363
1364	ODINFUNCTION1(BOOL,_ILIsDesktop,LPCITEMIDLIST, pidl)
1365	{
1366	return ( !pidl \|\| (pidl && pidl->mkid.cb == 0x00) );
1367	}
1368
1369	ODINFUNCTION1(BOOL,_ILIsMyComputer,LPCITEMIDLIST, pidl)
1370	{
1371	REFIID iid = _ILGetGUIDPointer(pidl);
1372
1373	TRACE_(pidl)("(%p)\n",pidl);
1374
1375	if (iid)
1376	return IsEqualIID(iid, &CLSID_MyComputer);
1377	return FALSE;
1378	}
1379
1380	ODINFUNCTION1(BOOL,_ILIsSpecialFolder,LPCITEMIDLIST, pidl)
1381	{
1382	LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1383	TRACE_(pidl)("(%p)\n",pidl);
1384	return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type \|\| PT_SPECIAL== lpPData->type)) \|\|
1385	(pidl && pidl->mkid.cb == 0x00)
1386	));
1387	}
1388
1389	ODINFUNCTION1(BOOL,_ILIsDrive,LPCITEMIDLIST, pidl)
1390	{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1391	TRACE_(pidl)("(%p)\n",pidl);
1392	return (pidl && lpPData && (PT_DRIVE == lpPData->type \|\|
1393	PT_DRIVE1 == lpPData->type \|\|
1394	PT_DRIVE2 == lpPData->type \|\|
1395	PT_DRIVE3 == lpPData->type));
1396	}
1397
1398	ODINFUNCTION1(BOOL,_ILIsFolder,LPCITEMIDLIST, pidl)
1399	{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1400	TRACE_(pidl)("(%p)\n",pidl);
1401	return (pidl && lpPData && (PT_FOLDER == lpPData->type \|\| PT_FOLDER1 == lpPData->type));
1402	}
1403
1404	ODINFUNCTION1(BOOL,_ILIsValue,LPCITEMIDLIST, pidl)
1405	{ LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1406	TRACE_(pidl)("(%p)\n",pidl);
1407	return (pidl && lpPData && PT_VALUE == lpPData->type);
1408	}
1409
1410	/**************************************************************************
1411	* _ILIsPidlSimple
1412	*/
1413	ODINFUNCTION1(BOOL,_ILIsPidlSimple,LPCITEMIDLIST, pidl)
1414	{
1415	BOOL ret = TRUE;
1416
1417	if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1418	{
1419	WORD len = pidl->mkid.cb;
1420	LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((LPBYTE)pidl) + len );
1421	if (pidlnext->mkid.cb)
1422	ret = FALSE;
1423	}
1424
1425	TRACE_(pidl)("%s\n", ret ? "Yes" : "No");
1426	return ret;
1427	}
1428
1429	/**************************************************************************
1430	*
1431	* ### 3. section getting values from pidls ###
1432	*/
1433
1434	/**************************************************************************
1435	* _ILSimpleGetText
1436	*
1437	* gets the text for the first item in the pidl (eg. simple pidl)
1438	*
1439	* returns the lenght of the string
1440	*/
1441
1442	ODINFUNCTION3(DWORD, _ILSimpleGetText, LPCITEMIDLIST, pidl,
1443	LPSTR, szOut,
1444	UINT, uOutSize)
1445	{
1446	LPPIDLDATA pData;
1447	DWORD dwReturn=0;
1448	LPSTR szSrc;
1449	GUID const * riid;
1450	char szTemp[MAX_PATH];
1451
1452	if (!pidl) return 0;
1453
1454	if (szOut)
1455	*szOut = 0;
1456
1457	pData = _ILGetDataPointer(pidl);
1458
1459	if (_ILIsDesktop(pidl))
1460	{
1461	/* desktop */
1462	if (HCR_GetClassName(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1463	{
1464	if (szOut)
1465	lstrcpynA(szOut, szTemp, uOutSize);
1466
1467	dwReturn = strlen (szTemp);
1468	}
1469	}
1470	else if (( szSrc = _ILGetTextPointer(pData->type, pData) ))
1471	{
1472	/* filesystem */
1473	if (szOut)
1474	lstrcpynA(szOut, szSrc, MAX_PATH);
1475
1476	dwReturn = strlen(szSrc);
1477	}
1478	else if (( riid = _ILGetGUIDPointer(pidl) ))
1479	{
1480	/* special folder */
1481	if ( HCR_GetClassName(riid, szTemp, MAX_PATH) )
1482	{
1483	if (szOut)
1484	lstrcpynA(szOut, szTemp, uOutSize);
1485
1486	dwReturn = strlen (szTemp);
1487	}
1488	}
1489	else
1490	{
1491	ERR_(pidl)("-- no text\n");
1492	}
1493
1494	TRACE_(pidl)("-- (%p=%s 0x%08lx)\n",szOut,(char*)szOut,dwReturn);
1495	return dwReturn;
1496	}
1497
1498	/**************************************************************************
1499	*
1500	* ### 4. getting pointers to parts of pidls ###
1501	*
1502	**************************************************************************
1503	* _ILGetDataPointer()
1504	*/
1505
1506	ODINFUNCTION1(LPPIDLDATA,_ILGetDataPointer,LPITEMIDLIST, pidl)
1507	{
1508	if(pidl && pidl->mkid.cb != 0x00)
1509	return (LPPIDLDATA) &(pidl->mkid.abID);
1510	return NULL;
1511	}
1512
1513	/**************************************************************************
1514	* _ILGetTextPointer()
1515	* gets a pointer to the long filename string stored in the pidl
1516	*/
1517
1518	ODINFUNCTION2(LPSTR,_ILGetTextPointer,PIDLTYPE, type,
1519	LPPIDLDATA, pidldata)
1520	{/* TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
1521
1522	if(!pidldata)
1523	{ return NULL;
1524	}
1525
1526	switch (type)
1527	{
1528	case PT_MYCOMP:
1529	case PT_SPECIAL:
1530	return NULL;
1531
1532	case PT_DRIVE:
1533	case PT_DRIVE1:
1534	case PT_DRIVE2:
1535	case PT_DRIVE3:
1536	return (LPSTR)&(pidldata->u.drive.szDriveName);
1537
1538	case PT_FOLDER:
1539	case PT_FOLDER1:
1540	case PT_VALUE:
1541	case PT_IESPECIAL:
1542	return (LPSTR)&(pidldata->u.file.szNames);
1543
1544	case PT_WORKGRP:
1545	case PT_COMP:
1546	case PT_NETWORK:
1547	case PT_SHARE:
1548	return (LPSTR)&(pidldata->u.network.szNames);
1549	}
1550	return NULL;
1551	}
1552
1553	/**************************************************************************
1554	* _ILGetSTextPointer()
1555	* gets a pointer to the short filename string stored in the pidl
1556	*/
1557
1558	ODINFUNCTION2(LPSTR,_ILGetSTextPointer,PIDLTYPE, type,
1559	LPPIDLDATA, pidldata)
1560	{/* TRACE(pidl,"(type=%x data=%p)\n", type, pidldata);*/
1561
1562	if(!pidldata)
1563	return NULL;
1564
1565	switch (type)
1566	{
1567	case PT_FOLDER:
1568	case PT_VALUE:
1569	case PT_IESPECIAL:
1570	return (LPSTR)(pidldata->u.file.szNames + strlen (pidldata->u.file.szNames) + 1);
1571
1572	case PT_WORKGRP:
1573	return (LPSTR)(pidldata->u.network.szNames + strlen (pidldata->u.network.szNames) + 1);
1574	}
1575	return NULL;
1576	}
1577
1578	/**************************************************************************
1579	* _ILGetGUIDPointer()
1580	*
1581	* returns reference to guid stored in some pidls
1582	*/
1583
1584	ODINFUNCTION1(REFIID,_ILGetGUIDPointer,LPCITEMIDLIST, pidl)
1585	{
1586	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1587
1588	if (pdata)
1589	{
1590	switch (pdata->type)
1591	{
1592	case PT_SPECIAL:
1593	case PT_MYCOMP:
1594	return (REFIID) &(pdata->u.mycomp.guid);
1595	}
1596	}
1597	return NULL;
1598	}
1599
1600	/*************************************************************************
1601	* _ILGetFileDateTime
1602	*
1603	* Given the ItemIdList, get the FileTime
1604	*
1605	* PARAMS
1606	* pidl [I] The ItemIDList
1607	* pFt [I] the resulted FILETIME of the file
1608	*
1609	* RETURNS
1610	* True if Successful
1611	*
1612	* NOTES
1613	*
1614	*/
1615
1616	ODINFUNCTION2(BOOL, _ILGetFileDateTime,LPCITEMIDLIST, pidl,
1617	FILETIME *, pFt)
1618	{
1619	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1620
1621	switch (pdata->type)
1622	{
1623	case PT_FOLDER:
1624	DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, pFt);
1625	break;
1626	case PT_VALUE:
1627	DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
1628	break;
1629	default:
1630	return FALSE;
1631	}
1632	return TRUE;
1633	}
1634
1635
1636	ODINFUNCTION3(BOOL, _ILGetFileDate, LPCITEMIDLIST, pidl,
1637	LPSTR, pOut,
1638	UINT, uOutSize)
1639	{
1640	FILETIME ft;
1641	FILETIME lft;
1642	SYSTEMTIME time;
1643	char strTime[16];
1644	UINT nTempSize=16;
1645
1646	if (! _ILGetFileDateTime( pidl, &ft )) return FALSE;
1647
1648	FileTimeToLocalFileTime(&ft, &lft);
1649	FileTimeToSystemTime (&lft, &time);
1650
1651	if(GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize) > 0)
1652	{
1653	if(GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, strTime, nTempSize) > 0)
1654	{
1655	strcat(pOut," ");
1656	strcat(pOut, strTime);
1657	return TRUE;
1658	}
1659	}
1660	return FALSE;
1661	}
1662
1663	/*************************************************************************
1664	* _ILGetFileSize
1665	*
1666	* Given the ItemIdList, get the FileSize
1667	*
1668	* PARAMS
1669	* pidl [I] The ItemIDList
1670	* pOut [I] The buffer to save the result
1671	* uOutsize [I] The size of the buffer
1672	*
1673	* RETURNS
1674	* The FileSize
1675	*
1676	* NOTES
1677	* pOut can be null when no string is needed
1678	*
1679	*/
1680
1681	ODINFUNCTION3(BOOL,_ILGetFileSize,LPCITEMIDLIST, pidl,
1682	LPSTR, pOut,
1683	UINT, uOutSize)
1684	{
1685	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1686	DWORD dwSize;
1687
1688	switch (pdata->type)
1689	{ case PT_VALUE:
1690	dwSize = pdata->u.file.dwFileSize;
1691	if (pOut) StrFormatByteSizeA(dwSize, pOut, uOutSize);
1692	return dwSize;
1693	}
1694	if (pOut) *pOut = 0x00;
1695	return 0;
1696	}
1697
1698	/*************************************************************************
1699	* _ILGetFileSizeKB
1700	*
1701	* Given the ItemIdList, get the FileSize in KiloByte
1702	*
1703	* PARAMS
1704	* pidl [I] The ItemIDList
1705	* pOut [I] The buffer to save the result
1706	* uOutsize [I] The size of the buffer
1707	*
1708	* RETURNS
1709	* The FileSize in KiloBytes
1710	*
1711	* NOTES
1712	* - pOut can be null when no string is needed
1713	* - Standard files in explorer or FileOpen have the file size in
1714	* Kilobyte
1715	*
1716	*/
1717	DWORD _ILGetFileSizeKB (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
1718	{
1719	LPPIDLDATA pdata =_ILGetDataPointer(pidl);
1720	DWORD dwSize;
1721	char tempSizeStr[24];
1722	char kbStr[] = "KB";
1723	int nTempSizeLen, nNumOfComma;
1724	int i,j,k;
1725
1726	switch (pdata->type)
1727	{
1728	case PT_VALUE:
1729	{
1730	if(pdata->u.file.dwFileSize >= 1024)
1731	{
1732	dwSize = pdata->u.file.dwFileSize / 1024;
1733	}
1734	else if(pdata->u.file.dwFileSize > 0)
1735	{
1736	dwSize = 1;
1737	}
1738	else
1739	{
1740	dwSize = 0;
1741	}
1742
1743	if (pOut)
1744	{
1745	sprintf(tempSizeStr,"%0ld",dwSize);
1746	nTempSizeLen = strlen(tempSizeStr);
1747	nNumOfComma = nTempSizeLen / 4;
1748	uOutSize = nNumOfComma + strlen(tempSizeStr);
1749	for(i=nTempSizeLen, j=uOutSize, k=0; j >= 0; j--, k++)
1750	{
1751	if((k %4) == 0 && k != 0)
1752	{
1753	pOut[j] = ',';
1754	k = 0;
1755	}
1756	else
1757	{
1758	pOut[j] = tempSizeStr[i--];
1759	}
1760	}
1761	strcat(pOut,kbStr);
1762	}
1763	return dwSize;
1764	}
1765	}
1766	return 0;
1767	}
1768
1769	ODINFUNCTION3(BOOL,_ILGetExtension,LPCITEMIDLIST, pidl,
1770	LPSTR, pOut,
1771	UINT, uOutSize)
1772	{
1773	char szTemp[MAX_PATH];
1774	const char * pPoint;
1775	LPITEMIDLIST pidlTemp=pidl;
1776
1777	if (!pidl) return FALSE;
1778
1779	pidlTemp = ILFindLastID(pidl);
1780
1781	if (!_ILIsValue(pidlTemp)) return FALSE;
1782	if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
1783
1784	pPoint = PathFindExtensionA(szTemp);
1785
1786	if (! *pPoint) return FALSE;
1787
1788	pPoint++;
1789	lstrcpynA(pOut, pPoint, uOutSize);
1790	TRACE_(pidl)("%s\n",pOut);
1791
1792	return TRUE;
1793	}
1794
1795	/*************************************************************************
1796	* _ILGetFileType
1797	*
1798	* Given the ItemIdList, get the file type description
1799	*
1800	* PARAMS
1801	* pidl [I] The ItemIDList (simple)
1802	* pOut [I] The buffer to save the result
1803	* uOutsize [I] The size of the buffer
1804	*
1805	* RETURNS
1806	* nothing
1807	*
1808	* NOTES
1809	* This function copies as much as possible into the buffer.
1810	*/
1811	ODINPROCEDURE3(_ILGetFileType,LPCITEMIDLIST, pidl,
1812	LPSTR, pOut,
1813	UINT, uOutSize)
1814	{
1815	if(_ILIsValue(pidl))
1816	{
1817	char sTemp[64];
1818	if(uOutSize > 0)
1819	{
1820	pOut[0] = 0;
1821	}
1822	if (_ILGetExtension (pidl, sTemp, 64))
1823	{
1824	if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
1825	&& HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
1826	{
1827	lstrcpynA (pOut, sTemp, uOutSize - 6);
1828	strcat (pOut, "-file");
1829	}
1830	}
1831	}
1832	else
1833	{
1834	lstrcpynA(pOut, "Folder", uOutSize);
1835	}
1836	}
1837
1838	/*************************************************************************
1839	* _ILGetFileAttributes
1840	*
1841	* Given the ItemIdList, get the Attrib string format
1842	*
1843	* PARAMS
1844	* pidl [I] The ItemIDList
1845	* pOut [I] The buffer to save the result
1846	* uOutsize [I] The size of the Buffer
1847	*
1848	* RETURNS
1849	* Attributes
1850	*
1851	* NOTES
1852	*
1853	*/
1854	ODINFUNCTION3(BOOL, _ILGetFileAttributes, LPCITEMIDLIST, pidl,
1855	LPSTR, pOut,
1856	UINT, uOutSize)
1857	{
1858	LPPIDLDATA pData =_ILGetDataPointer(pidl);
1859	WORD wAttrib = 0;
1860	int i;
1861
1862	switch(pData->type)
1863	{
1864	case PT_FOLDER:
1865	wAttrib = pData->u.folder.uFileAttribs;
1866	break;
1867	case PT_VALUE:
1868	wAttrib = pData->u.file.uFileAttribs;
1869	break;
1870	}
1871	if(uOutSize >= 6)
1872	{
1873	i=0;
1874	if(wAttrib & FILE_ATTRIBUTE_READONLY)
1875	{
1876	pOut[i++] = 'R';
1877	}
1878	if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
1879	{
1880	pOut[i++] = 'H';
1881	}
1882	if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
1883	{
1884	pOut[i++] = 'S';
1885	}
1886	if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
1887	{
1888	pOut[i++] = 'A';
1889	}
1890	if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
1891	{
1892	pOut[i++] = 'C';
1893	}
1894	pOut[i] = 0x00;
1895	}
1896	return wAttrib;
1897	}
1898

Note: See TracBrowser for help on using the repository browser.

Download in other formats: