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

Last change on this file since 4082 was 4082, checked in by sandervl, 25 years ago

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