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

Last change on this file since 2004 was 1553, checked in by phaller, 26 years ago

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