1 /*
2 * pidl Handling
3 *
4 * Copyright 1998 Juergen Schmied
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * NOTES
21 * a pidl == NULL means desktop and is legal
22 *
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <ctype.h>
29 #include <stdarg.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define COBJMACROS
34 #define NONAMELESSUNION
35 #define NONAMELESSSTRUCT
36
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winreg.h"
40 #include "objbase.h"
41 #include "shlguid.h"
42 #include "winerror.h"
43 #include "winnls.h"
44 #include "undocshell.h"
45 #include "shell32_main.h"
46 #include "shlwapi.h"
47
48 #include "pidl.h"
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(pidl);
52 WINE_DECLARE_DEBUG_CHANNEL(shell);
53
54 /* from comctl32.dll */
55 extern LPVOID WINAPI Alloc(INT);
56 extern BOOL WINAPI Free(LPVOID);
57
58 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl);
59 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl);
60
61 /*************************************************************************
62 * ILGetDisplayNameExA
63 *
64 * Retrieves the display name of an ItemIDList
65 *
66 * PARAMS
67 * psf [I] Shell Folder to start with, if NULL the desktop is used
68 * pidl [I] ItemIDList relative to the psf to get the display name for
69 * path [O] Filled in with the display name, assumed to be at least MAX_PATH long
70 * type [I] Type of display name to retrieve
71 * 0 = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR uses always the desktop as root
72 * 1 = SHGDN_NORMAL relative to the root folder
73 * 2 = SHGDN_INFOLDER relative to the root folder, only the last name
74 *
75 * RETURNS
76 * True if the display name could be retrieved successfully, False otherwise
77 */
78 static BOOL ILGetDisplayNameExA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPSTR path, DWORD type)
79 {
80 BOOL ret = FALSE;
81 WCHAR wPath[MAX_PATH];
82
83 TRACE("%p %p %p %d\n", psf, pidl, path, type);
84
85 if (!pidl || !path)
86 return FALSE;
87
88 ret = ILGetDisplayNameExW(psf, pidl, wPath, type);
89 WideCharToMultiByte(CP_ACP, 0, wPath, -1, path, MAX_PATH, NULL, NULL);
90 TRACE("%p %p %s\n", psf, pidl, debugstr_a(path));
91
92 return ret;
93 }
94
95 BOOL WINAPI ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
96 {
97 LPSHELLFOLDER psfParent, lsf = psf;
98 HRESULT ret = NO_ERROR;
99 LPCITEMIDLIST pidllast;
100 STRRET strret;
101 DWORD flag;
102
103 TRACE("%p %p %p %x\n", psf, pidl, path, type);
104
105 if (!pidl || !path)
106 return FALSE;
107
108 if (!lsf)
109 {
110 ret = SHGetDesktopFolder(&lsf);
111 if (FAILED(ret))
112 return FALSE;
113 }
114
115 switch (type)
116 {
117 case ILGDN_FORPARSING:
118 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
119 break;
120 case ILGDN_NORMAL:
121 flag = SHGDN_NORMAL;
122 break;
123 case ILGDN_INFOLDER:
124 flag = SHGDN_INFOLDER;
125 break;
126 default:
127 FIXME("Unknown type parameter = %x\n", type);
128 flag = SHGDN_FORPARSING | SHGDN_FORADDRESSBAR;
129 break;
130 }
131
132 if (!*(const WORD*)pidl || type == ILGDN_FORPARSING)
133 {
134 ret = IShellFolder_GetDisplayNameOf(lsf, pidl, flag, &strret);
135 if (SUCCEEDED(ret))
136 {
137 if(!StrRetToStrNW(path, MAX_PATH, &strret, pidl))
138 ret = E_FAIL;
139 }
140 }
141 else
142 {
143 ret = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psfParent, &pidllast);
144 if (SUCCEEDED(ret))
145 {
146 ret = IShellFolder_GetDisplayNameOf(psfParent, pidllast, flag, &strret);
147 if (SUCCEEDED(ret))
148 {
149 if(!StrRetToStrNW(path, MAX_PATH, &strret, pidllast))
150 ret = E_FAIL;
151 }
152 IShellFolder_Release(psfParent);
153 }
154 }
155
156 TRACE("%p %p %s\n", psf, pidl, debugstr_w(path));
157
158 if (!psf)
159 IShellFolder_Release(lsf);
160 return SUCCEEDED(ret);
161 }
162
163 /*************************************************************************
164 * ILGetDisplayNameEx [SHELL32.186]
165 */
166 BOOL WINAPI ILGetDisplayNameEx(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPVOID path, DWORD type)
167 {
168 TRACE_(shell)("%p %p %p %d\n", psf, pidl, path, type);
169
170 if (SHELL_OsIsUnicode())
171 return ILGetDisplayNameExW(psf, pidl, path, type);
172 return ILGetDisplayNameExA(psf, pidl, path, type);
173 }
174
175 /*************************************************************************
176 * ILGetDisplayName [SHELL32.15]
177 */
178 BOOL WINAPI ILGetDisplayName(LPCITEMIDLIST pidl, LPVOID path)
179 {
180 TRACE_(shell)("%p %p\n", pidl, path);
181
182 if (SHELL_OsIsUnicode())
183 return ILGetDisplayNameExW(NULL, pidl, path, ILGDN_FORPARSING);
184 return ILGetDisplayNameExA(NULL, pidl, path, ILGDN_FORPARSING);
185 }
186
187 /*************************************************************************
188 * ILFindLastID [SHELL32.16]
189 *
190 * NOTES
191 * observed: pidl=Desktop return=pidl
192 */
193 LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
194 {
195 LPCITEMIDLIST pidlLast = pidl;
196
197 TRACE("(pidl=%p)\n",pidl);
198
199 if (!pidl)
200 return NULL;
201
202 while (pidl->mkid.cb)
203 {
204 pidlLast = pidl;
205 pidl = ILGetNext(pidl);
206 }
207 return (LPITEMIDLIST)pidlLast;
208 }
209
210 /*************************************************************************
211 * ILRemoveLastID [SHELL32.17]
212 *
213 * NOTES
214 * when pidl=Desktop return=FALSE
215 */
216 BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
217 {
218 TRACE_(shell)("pidl=%p\n",pidl);
219
220 if (!pidl || !pidl->mkid.cb)
221 return 0;
222 ILFindLastID(pidl)->mkid.cb = 0;
223 return 1;
224 }
225
226 /*************************************************************************
227 * ILClone [SHELL32.18]
228 *
229 * NOTES
230 * duplicate an idlist
231 */
232 LPITEMIDLIST WINAPI ILClone (LPCITEMIDLIST pidl)
233 {
234 DWORD len;
235 LPITEMIDLIST newpidl;
236
237 if (!pidl)
238 return NULL;
239
240 len = ILGetSize(pidl);
241 newpidl = SHAlloc(len);
242 if (newpidl)
243 memcpy(newpidl,pidl,len);
244
245 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
246 pdump(pidl);
247
248 return newpidl;
249 }
250
251 /*************************************************************************
252 * ILCloneFirst [SHELL32.19]
253 *
254 * NOTES
255 * duplicates the first idlist of a complex pidl
256 */
257 LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
258 {
259 DWORD len;
260 LPITEMIDLIST pidlNew = NULL;
261
262 TRACE("pidl=%p\n", pidl);
263 pdump(pidl);
264
265 if (pidl)
266 {
267 len = pidl->mkid.cb;
268 pidlNew = SHAlloc(len+2);
269 if (pidlNew)
270 {
271 memcpy(pidlNew,pidl,len+2); /* 2 -> mind a desktop pidl */
272
273 if (len)
274 ILGetNext(pidlNew)->mkid.cb = 0x00;
275 }
276 }
277 TRACE("-- newpidl=%p\n",pidlNew);
278
279 return pidlNew;
280 }
281
282 /*************************************************************************
283 * ILLoadFromStream (SHELL32.26)
284 *
285 * NOTES
286 * the first two bytes are the len, the pidl is following then
287 */
288 HRESULT WINAPI ILLoadFromStream (IStream * pStream, LPITEMIDLIST * ppPidl)
289 {
290 WORD wLen = 0;
291 DWORD dwBytesRead;
292 HRESULT ret = E_FAIL;
293
294
295 TRACE_(shell)("%p %p\n", pStream , ppPidl);
296
297 SHFree(*ppPidl);
298 *ppPidl = NULL;
299
300 IStream_AddRef (pStream);
301
302 if (SUCCEEDED(IStream_Read(pStream, &wLen, 2, &dwBytesRead)))
303 {
304 TRACE("PIDL length is %d\n", wLen);
305 if (wLen != 0)
306 {
307 *ppPidl = SHAlloc (wLen);
308 if (SUCCEEDED(IStream_Read(pStream, *ppPidl , wLen, &dwBytesRead)))
309 {
310 TRACE("Stream read OK\n");
311 ret = S_OK;
312 }
313 else
314 {
315 WARN("reading pidl failed\n");
316 SHFree(*ppPidl);
317 *ppPidl = NULL;
318 }
319 }
320 else
321 {
322 *ppPidl = NULL;
323 ret = S_OK;
324 }
325 }
326
327 /* we are not yet fully compatible */
328 if (*ppPidl && !pcheck(*ppPidl))
329 {
330 WARN("Check failed\n");
331 SHFree(*ppPidl);
332 *ppPidl = NULL;
333 }
334
335 IStream_Release (pStream);
336 TRACE("done\n");
337 return ret;
338 }
339
340 /*************************************************************************
341 * ILSaveToStream (SHELL32.27)
342 *
343 * NOTES
344 * the first two bytes are the len, the pidl is following then
345 */
346 HRESULT WINAPI ILSaveToStream (IStream * pStream, LPCITEMIDLIST pPidl)
347 {
348 WORD wLen = 0;
349 HRESULT ret = E_FAIL;
350
351 TRACE_(shell)("%p %p\n", pStream, pPidl);
352
353 IStream_AddRef (pStream);
354
355 wLen = ILGetSize(pPidl);
356
357 if (SUCCEEDED(IStream_Write(pStream, &wLen, 2, NULL)))
358 {
359 if (SUCCEEDED(IStream_Write(pStream, pPidl, wLen, NULL)))
360 ret = S_OK;
361 }
362 IStream_Release (pStream);
363
364 return ret;
365 }
366
367 /*************************************************************************
368 * SHILCreateFromPath [SHELL32.28]
369 *
370 * Create an ItemIDList from a path
371 *
372 * PARAMS
373 * path [I]
374 * ppidl [O]
375 * attributes [I/O] requested attributes on call and actual attributes when
376 * the function returns
377 *
378 * RETURNS
379 * NO_ERROR if successful, or an OLE errer code otherwise
380 *
381 * NOTES
382 * Wrapper for IShellFolder_ParseDisplayName().
383 */
384 static HRESULT SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
385 {
386 WCHAR lpszDisplayName[MAX_PATH];
387
388 TRACE_(shell)("%s %p 0x%08x\n", path, ppidl, attributes ? *attributes : 0);
389
390 if (!MultiByteToWideChar(CP_ACP, 0, path, -1, lpszDisplayName, MAX_PATH))
391 lpszDisplayName[MAX_PATH-1] = 0;
392
393 return SHILCreateFromPathW(lpszDisplayName, ppidl, attributes);
394 }
395
396 HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST * ppidl, DWORD * attributes)
397 {
398 LPSHELLFOLDER sf;
399 DWORD pchEaten;
400 HRESULT ret = E_FAIL;
401
402 TRACE_(shell)("%s %p 0x%08x\n", debugstr_w(path), ppidl, attributes ? *attributes : 0);
403
404 if (SUCCEEDED (SHGetDesktopFolder(&sf)))
405 {
406 ret = IShellFolder_ParseDisplayName(sf, 0, NULL, (LPWSTR)path, &pchEaten, ppidl, attributes);
407 IShellFolder_Release(sf);
408 }
409 return ret;
410 }
411
412 HRESULT WINAPI SHILCreateFromPathAW (LPCVOID path, LPITEMIDLIST * ppidl, DWORD * attributes)
413 {
414 if ( SHELL_OsIsUnicode())
415 return SHILCreateFromPathW (path, ppidl, attributes);
416 return SHILCreateFromPathA (path, ppidl, attributes);
417 }
418
419 /*************************************************************************
420 * SHCloneSpecialIDList [SHELL32.89]
421 *
422 * Create an ItemIDList to one of the special folders.
423
424 * PARAMS
425 * hwndOwner [in]
426 * nFolder [in] CSIDL_xxxxx
427 * fCreate [in] Create folder if it does not exist
428 *
429 * RETURNS
430 * Success: The newly created pidl
431 * Failure: NULL, if inputs are invalid.
432 *
433 * NOTES
434 * exported by ordinal.
435 * Caller is responsible for deallocating the returned ItemIDList with the
436 * shells IMalloc interface, aka ILFree.
437 */
438 LPITEMIDLIST WINAPI SHCloneSpecialIDList(HWND hwndOwner, DWORD nFolder, BOOL fCreate)
439 {
440 LPITEMIDLIST ppidl;
441 TRACE_(shell)("(hwnd=%p,csidl=0x%x,%s).\n", hwndOwner, nFolder, fCreate ? "T" : "F");
442
443 if (fCreate)
444 nFolder |= CSIDL_FLAG_CREATE;
445
446 SHGetSpecialFolderLocation(hwndOwner, nFolder, &ppidl);
447 return ppidl;
448 }
449
450 /*************************************************************************
451 * ILGlobalClone [SHELL32.20]
452 *
453 * Clones an ItemIDList using Alloc.
454 *
455 * PARAMS
456 * pidl [I] ItemIDList to clone
457 *
458 * RETURNS
459 * Newly allocated ItemIDList.
460 *
461 * NOTES
462 * exported by ordinal.
463 */
464 LPITEMIDLIST WINAPI ILGlobalClone(LPCITEMIDLIST pidl)
465 {
466 DWORD len;
467 LPITEMIDLIST newpidl;
468
469 if (!pidl)
470 return NULL;
471
472 len = ILGetSize(pidl);
473 newpidl = Alloc(len);
474 if (newpidl)
475 memcpy(newpidl,pidl,len);
476
477 TRACE("pidl=%p newpidl=%p\n",pidl, newpidl);
478 pdump(pidl);
479
480 return newpidl;
481 }
482
483 /*************************************************************************
484 * ILIsEqual [SHELL32.21]
485 *
486 */
487 BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
488 {
489 char szData1[MAX_PATH];
490 char szData2[MAX_PATH];
491
492 LPCITEMIDLIST pidltemp1 = pidl1;
493 LPCITEMIDLIST pidltemp2 = pidl2;
494
495 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
496
497 /*
498 * Explorer reads from registry directly (StreamMRU),
499 * so we can only check here
500 */
501 if (!pcheck(pidl1) || !pcheck (pidl2))
502 return FALSE;
503
504 pdump (pidl1);
505 pdump (pidl2);
506
507 if (!pidl1 || !pidl2)
508 return FALSE;
509
510 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
511 {
512 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
513 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
514
515 if (strcasecmp( szData1, szData2 ))
516 return FALSE;
517
518 pidltemp1 = ILGetNext(pidltemp1);
519 pidltemp2 = ILGetNext(pidltemp2);
520 }
521
522 if (!pidltemp1->mkid.cb && !pidltemp2->mkid.cb)
523 return TRUE;
524
525 return FALSE;
526 }
527
528 /*************************************************************************
529 * ILIsParent [SHELL32.23]
530 *
531 * Verifies that pidlParent is indeed the (immediate) parent of pidlChild.
532 *
533 * PARAMS
534 * pidlParent [I]
535 * pidlChild [I]
536 * bImmediate [I] only return true if the parent is the direct parent
537 * of the child
538 *
539 * RETURNS
540 * True if the parent ItemIDlist is a complete part of the child ItemIdList,
541 * False otherwise.
542 *
543 * NOTES
544 * parent = a/b, child = a/b/c -> true, c is in folder a/b
545 * child = a/b/c/d -> false if bImmediate is true, d is not in folder a/b
546 * child = a/b/c/d -> true if bImmediate is false, d is in a subfolder of a/b
547 */
548 BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
549 {
550 char szData1[MAX_PATH];
551 char szData2[MAX_PATH];
552 LPCITEMIDLIST pParent = pidlParent;
553 LPCITEMIDLIST pChild = pidlChild;
554
555 TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
556
557 if (!pParent || !pChild)
558 return FALSE;
559
560 while (pParent->mkid.cb && pChild->mkid.cb)
561 {
562 _ILSimpleGetText(pParent, szData1, MAX_PATH);
563 _ILSimpleGetText(pChild, szData2, MAX_PATH);
564
565 if (strcasecmp( szData1, szData2 ))
566 return FALSE;
567
568 pParent = ILGetNext(pParent);
569 pChild = ILGetNext(pChild);
570 }
571
572 /* child shorter or has equal length to parent */
573 if (pParent->mkid.cb || !pChild->mkid.cb)
574 return FALSE;
575
576 /* not immediate descent */
577 if ( ILGetNext(pChild)->mkid.cb && bImmediate)
578 return FALSE;
579
580 return TRUE;
581 }
582
583 /*************************************************************************
584 * ILFindChild [SHELL32.24]
585 *
586 * Compares elements from pidl1 and pidl2.
587 *
588 * PARAMS
589 * pidl1 [I]
590 * pidl2 [I]
591 *
592 * RETURNS
593 * pidl1 is desktop pidl2
594 * pidl1 shorter pidl2 pointer to first different element of pidl2
595 * if there was at least one equal element
596 * pidl2 shorter pidl1 0
597 * pidl2 equal pidl1 pointer to last 0x00-element of pidl2
598 *
599 * NOTES
600 * exported by ordinal.
601 */
602 LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
603 {
604 char szData1[MAX_PATH];
605 char szData2[MAX_PATH];
606
607 LPCITEMIDLIST pidltemp1 = pidl1;
608 LPCITEMIDLIST pidltemp2 = pidl2;
609 LPCITEMIDLIST ret=NULL;
610
611 TRACE("pidl1=%p pidl2=%p\n",pidl1, pidl2);
612
613 /* explorer reads from registry directly (StreamMRU),
614 so we can only check here */
615 if ((!pcheck (pidl1)) || (!pcheck (pidl2)))
616 return FALSE;
617
618 pdump (pidl1);
619 pdump (pidl2);
620
621 if (_ILIsDesktop(pidl1))
622 {
623 ret = pidl2;
624 }
625 else
626 {
627 while (pidltemp1->mkid.cb && pidltemp2->mkid.cb)
628 {
629 _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
630 _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
631
632 if (strcasecmp(szData1,szData2))
633 break;
634
635 pidltemp1 = ILGetNext(pidltemp1);
636 pidltemp2 = ILGetNext(pidltemp2);
637 ret = pidltemp2;
638 }
639
640 if (pidltemp1->mkid.cb)
641 ret = NULL; /* elements of pidl1 left*/
642 }
643 TRACE_(shell)("--- %p\n", ret);
644 return (LPITEMIDLIST)ret; /* pidl 1 is shorter */
645 }
646
647 /*************************************************************************
648 * ILCombine [SHELL32.25]
649 *
650 * Concatenates two complex ItemIDLists.
651 *
652 * PARAMS
653 * pidl1 [I] first complex ItemIDLists
654 * pidl2 [I] complex ItemIDLists to append
655 *
656 * RETURNS
657 * if both pidl's == NULL NULL
658 * if pidl1 == NULL cloned pidl2
659 * if pidl2 == NULL cloned pidl1
660 * otherwise new pidl with pidl2 appended to pidl1
661 *
662 * NOTES
663 * exported by ordinal.
664 * Does not destroy the passed in ItemIDLists!
665 */
666 LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
667 {
668 DWORD len1,len2;
669 LPITEMIDLIST pidlNew;
670
671 TRACE("pidl=%p pidl=%p\n",pidl1,pidl2);
672
673 if (!pidl1 && !pidl2) return NULL;
674
675 pdump (pidl1);
676 pdump (pidl2);
677
678 if (!pidl1)
679 {
680 pidlNew = ILClone(pidl2);
681 return pidlNew;
682 }
683
684 if (!pidl2)
685 {
686 pidlNew = ILClone(pidl1);
687 return pidlNew;
688 }
689
690 len1 = ILGetSize(pidl1)-2;
691 len2 = ILGetSize(pidl2);
692 pidlNew = SHAlloc(len1+len2);
693
694 if (pidlNew)
695 {
696 memcpy(pidlNew,pidl1,len1);
697 memcpy(((BYTE *)pidlNew)+len1,pidl2,len2);
698 }
699
700 /* TRACE(pidl,"--new pidl=%p\n",pidlNew);*/
701 return pidlNew;
702 }
703
704 /*************************************************************************
705 * SHGetRealIDL [SHELL32.98]
706 *
707 * NOTES
708 */
709 HRESULT WINAPI SHGetRealIDL(LPSHELLFOLDER lpsf, LPCITEMIDLIST pidlSimple, LPITEMIDLIST *pidlReal)
710 {
711 IDataObject* pDataObj;
712 HRESULT hr;
713
714 hr = IShellFolder_GetUIObjectOf(lpsf, 0, 1, &pidlSimple,
715 &IID_IDataObject, 0, (LPVOID*)&pDataObj);
716 if (SUCCEEDED(hr))
717 {
718 STGMEDIUM medium;
719 FORMATETC fmt;
720
721 fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
722 fmt.ptd = NULL;
723 fmt.dwAspect = DVASPECT_CONTENT;
724 fmt.lindex = -1;
725 fmt.tymed = TYMED_HGLOBAL;
726
727 hr = IDataObject_GetData(pDataObj, &fmt, &medium);
728
729 IDataObject_Release(pDataObj);
730
731 if (SUCCEEDED(hr))
732 {
733 /*assert(pida->cidl==1);*/
734 LPIDA pida = GlobalLock(medium.u.hGlobal);
735
736 LPCITEMIDLIST pidl_folder = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]);
737 LPCITEMIDLIST pidl_child = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1]);
738
739 *pidlReal = ILCombine(pidl_folder, pidl_child);
740
741 if (!*pidlReal)
742 hr = E_OUTOFMEMORY;
743
744 GlobalUnlock(medium.u.hGlobal);
745 GlobalFree(medium.u.hGlobal);
746 }
747 }
748
749 return hr;
750 }
751
752 /*************************************************************************
753 * SHLogILFromFSIL [SHELL32.95]
754 *
755 * NOTES
756 * pild = CSIDL_DESKTOP ret = 0
757 * pild = CSIDL_DRIVES ret = 0
758 */
759 LPITEMIDLIST WINAPI SHLogILFromFSIL(LPITEMIDLIST pidl)
760 {
761 FIXME("(pidl=%p)\n",pidl);
762
763 pdump(pidl);
764
765 return 0;
766 }
767
768 /*************************************************************************
769 * ILGetSize [SHELL32.152]
770 *
771 * Gets the byte size of an ItemIDList including zero terminator
772 *
773 * PARAMS
774 * pidl [I] ItemIDList
775 *
776 * RETURNS
777 * size of pidl in bytes
778 *
779 * NOTES
780 * exported by ordinal
781 */
782 UINT WINAPI ILGetSize(LPCITEMIDLIST pidl)
783 {
784 LPCSHITEMID si = &(pidl->mkid);
785 UINT len=0;
786
787 if (pidl)
788 {
789 while (si->cb)
790 {
791 len += si->cb;
792 si = (LPCSHITEMID)(((const BYTE*)si)+si->cb);
793 }
794 len += 2;
795 }
796 TRACE("pidl=%p size=%u\n",pidl, len);
797 return len;
798 }
799
800 /*************************************************************************
801 * ILGetNext [SHELL32.153]
802 *
803 * Gets the next ItemID of an ItemIDList
804 *
805 * PARAMS
806 * pidl [I] ItemIDList
807 *
808 * RETURNS
809 * null -> null
810 * desktop -> null
811 * simple pidl -> pointer to 0x0000 element
812 *
813 * NOTES
814 * exported by ordinal.
815 */
816 LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
817 {
818 WORD len;
819
820 TRACE("%p\n", pidl);
821
822 if (pidl)
823 {
824 len = pidl->mkid.cb;
825 if (len)
826 {
827 pidl = (LPCITEMIDLIST) (((const BYTE*)pidl)+len);
828 TRACE("-- %p\n", pidl);
829 return (LPITEMIDLIST)pidl;
830 }
831 }
832 return NULL;
833 }
834
835 /*************************************************************************
836 * ILAppend [SHELL32.154]
837 *
838 * Adds the single ItemID item to the ItemIDList indicated by pidl.
839 * If bEnd is FALSE, inserts the item in the front of the list,
840 * otherwise it adds the item to the end. (???)
841 *
842 * PARAMS
843 * pidl [I] ItemIDList to extend
844 * item [I] ItemID to prepend/append
845 * bEnd [I] Indicates if the item should be appended
846 *
847 * NOTES
848 * Destroys the passed in idlist! (???)
849 */
850 LPITEMIDLIST WINAPI ILAppend(LPITEMIDLIST pidl, LPCITEMIDLIST item, BOOL bEnd)
851 {
852 LPITEMIDLIST idlRet;
853
854 WARN("(pidl=%p,pidl=%p,%08u)semi-stub\n",pidl,item,bEnd);
855
856 pdump (pidl);
857 pdump (item);
858
859 if (_ILIsDesktop(pidl))
860 {
861 idlRet = ILClone(item);
862 SHFree (pidl);
863 return idlRet;
864 }
865
866 if (bEnd)
867 idlRet = ILCombine(pidl, item);
868 else
869 idlRet = ILCombine(item, pidl);
870
871 SHFree(pidl);
872 return idlRet;
873 }
874
875 /*************************************************************************
876 * ILFree [SHELL32.155]
877 *
878 * Frees memory (if not NULL) allocated by SHMalloc allocator
879 *
880 * PARAMS
881 * pidl [I]
882 *
883 * RETURNS
884 * Nothing
885 *
886 * NOTES
887 * exported by ordinal
888 */
889 void WINAPI ILFree(LPITEMIDLIST pidl)
890 {
891 TRACE("(pidl=%p)\n",pidl);
892 SHFree(pidl);
893 }
894
895 /*************************************************************************
896 * ILGlobalFree [SHELL32.156]
897 *
898 * Frees memory (if not NULL) allocated by Alloc allocator
899 *
900 * PARAMS
901 * pidl [I]
902 *
903 * RETURNS
904 * Nothing
905 *
906 * NOTES
907 * exported by ordinal.
908 */
909 void WINAPI ILGlobalFree( LPITEMIDLIST pidl)
910 {
911 TRACE("%p\n", pidl);
912
913 Free(pidl);
914 }
915
916 /*************************************************************************
917 * ILCreateFromPathA [SHELL32.189]
918 *
919 * Creates a complex ItemIDList from a path and returns it.
920 *
921 * PARAMS
922 * path [I]
923 *
924 * RETURNS
925 * the newly created complex ItemIDList or NULL if failed
926 *
927 * NOTES
928 * exported by ordinal.
929 */
930 LPITEMIDLIST WINAPI ILCreateFromPathA (LPCSTR path)
931 {
932 LPITEMIDLIST pidlnew = NULL;
933
934 TRACE_(shell)("%s\n", debugstr_a(path));
935
936 if (SUCCEEDED(SHILCreateFromPathA(path, &pidlnew, NULL)))
937 return pidlnew;
938 return NULL;
939 }
940
941 /*************************************************************************
942 * ILCreateFromPathW [SHELL32.190]
943 *
944 * See ILCreateFromPathA.
945 */
946 LPITEMIDLIST WINAPI ILCreateFromPathW (LPCWSTR path)
947 {
948 LPITEMIDLIST pidlnew = NULL;
949
950 TRACE_(shell)("%s\n", debugstr_w(path));
951
952 if (SUCCEEDED(SHILCreateFromPathW(path, &pidlnew, NULL)))
953 return pidlnew;
954 return NULL;
955 }
956
957 /*************************************************************************
958 * ILCreateFromPath [SHELL32.157]
959 */
960 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
961 {
962 if ( SHELL_OsIsUnicode())
963 return ILCreateFromPathW (path);
964 return ILCreateFromPathA (path);
965 }
966
967 /*************************************************************************
968 * _ILParsePathW [internal]
969 *
970 * Creates an ItemIDList from a path and returns it.
971 *
972 * PARAMS
973 * path [I] path to parse and convert into an ItemIDList
974 * lpFindFile [I] pointer to buffer to initialize the FileSystem
975 * Bind Data object with
976 * bBindCtx [I] indicates to create a BindContext and assign a
977 * FileSystem Bind Data object
978 * ppidl [O] the newly create ItemIDList
979 * prgfInOut [I/O] requested attributes on input and actual
980 * attributes on return
981 *
982 * RETURNS
983 * NO_ERROR on success or an OLE error code
984 *
985 * NOTES
986 * If either lpFindFile is non-NULL or bBindCtx is TRUE, this function
987 * creates a BindContext object and assigns a FileSystem Bind Data object
988 * to it, passing the BindContext to IShellFolder_ParseDisplayName. Each
989 * IShellFolder uses that FileSystem Bind Data object of the BindContext
990 * to pass data about the current path element to the next object. This
991 * is used to avoid having to verify the current path element on disk, so
992 * that creating an ItemIDList from a nonexistent path still can work.
993 */
994 static HRESULT _ILParsePathW(LPCWSTR path, LPWIN32_FIND_DATAW lpFindFile,
995 BOOL bBindCtx, LPITEMIDLIST *ppidl, LPDWORD prgfInOut)
996 {
997 LPSHELLFOLDER pSF = NULL;
998 LPBC pBC = NULL;
999 HRESULT ret;
1000
1001 TRACE("%s %p %d (%p)->%p (%p)->0x%x\n", debugstr_w(path), lpFindFile, bBindCtx,
1002 ppidl, ppidl ? *ppidl : NULL,
1003 prgfInOut, prgfInOut ? *prgfInOut : 0);
1004
1005 ret = SHGetDesktopFolder(&pSF);
1006 if (FAILED(ret))
1007 return ret;
1008
1009 if (lpFindFile || bBindCtx)
1010 ret = IFileSystemBindData_Constructor(lpFindFile, &pBC);
1011
1012 if (SUCCEEDED(ret))
1013 {
1014 ret = IShellFolder_ParseDisplayName(pSF, 0, pBC, (LPOLESTR)path, NULL, ppidl, prgfInOut);
1015 }
1016
1017 if (pBC)
1018 {
1019 IBindCtx_Release(pBC);
1020 pBC = NULL;
1021 }
1022
1023 IShellFolder_Release(pSF);
1024
1025 if (FAILED(ret) && ppidl)
1026 *ppidl = NULL;
1027
1028 TRACE("%s %p 0x%x\n", debugstr_w(path), ppidl ? *ppidl : NULL, prgfInOut ? *prgfInOut : 0);
1029
1030 return ret;
1031 }
1032
1033 /*************************************************************************
1034 * SHSimpleIDListFromPath [SHELL32.162]
1035 *
1036 * Creates a simple ItemIDList from a path and returns it. This function
1037 * does not fail on nonexistent paths.
1038 *
1039 * PARAMS
1040 * path [I] path to parse and convert into an ItemIDList
1041 *
1042 * RETURNS
1043 * the newly created simple ItemIDList
1044 *
1045 * NOTES
1046 * Simple in the name does not mean a relative ItemIDList but rather a
1047 * fully qualified list, where only the file name is filled in and the
1048 * directory flag for those ItemID elements this is known about, eg.
1049 * it is not the last element in the ItemIDList or the actual directory
1050 * exists on disk.
1051 * exported by ordinal.
1052 */
1053 LPITEMIDLIST WINAPI SHSimpleIDListFromPathA(LPCSTR lpszPath)
1054 {
1055 LPITEMIDLIST pidl = NULL;
1056 LPWSTR wPath = NULL;
1057 int len;
1058
1059 TRACE("%s\n", debugstr_a(lpszPath));
1060
1061 if (lpszPath)
1062 {
1063 len = MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, NULL, 0);
1064 wPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1065 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, wPath, len);
1066 }
1067
1068 _ILParsePathW(wPath, NULL, TRUE, &pidl, NULL);
1069
1070 HeapFree(GetProcessHeap(), 0, wPath);
1071 TRACE("%s %p\n", debugstr_a(lpszPath), pidl);
1072 return pidl;
1073 }
1074
1075 LPITEMIDLIST WINAPI SHSimpleIDListFromPathW(LPCWSTR lpszPath)
1076 {
1077 LPITEMIDLIST pidl = NULL;
1078
1079 TRACE("%s\n", debugstr_w(lpszPath));
1080
1081 _ILParsePathW(lpszPath, NULL, TRUE, &pidl, NULL);
1082 TRACE("%s %p\n", debugstr_w(lpszPath), pidl);
1083 return pidl;
1084 }
1085
1086 LPITEMIDLIST WINAPI SHSimpleIDListFromPathAW(LPCVOID lpszPath)
1087 {
1088 if ( SHELL_OsIsUnicode())
1089 return SHSimpleIDListFromPathW (lpszPath);
1090 return SHSimpleIDListFromPathA (lpszPath);
1091 }
1092
1093 /*************************************************************************
1094 * SHGetDataFromIDListA [SHELL32.247]
1095 *
1096 * NOTES
1097 * the pidl can be a simple one. since we can't get the path out of the pidl
1098 * we have to take all data from the pidl
1099 */
1100 HRESULT WINAPI SHGetDataFromIDListA(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1101 int nFormat, LPVOID dest, int len)
1102 {
1103 LPSTR filename, shortname;
1104 WIN32_FIND_DATAA * pfd;
1105
1106 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1107
1108 pdump(pidl);
1109 if (!psf || !dest)
1110 return E_INVALIDARG;
1111
1112 switch (nFormat)
1113 {
1114 case SHGDFIL_FINDDATA:
1115 pfd = dest;
1116
1117 if (_ILIsDrive(pidl) || _ILIsSpecialFolder(pidl))
1118 return E_INVALIDARG;
1119
1120 if (len < sizeof(WIN32_FIND_DATAA))
1121 return E_INVALIDARG;
1122
1123 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1124 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1125 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1126 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1127
1128 filename = _ILGetTextPointer(pidl);
1129 shortname = _ILGetSTextPointer(pidl);
1130
1131 if (filename)
1132 lstrcpynA(pfd->cFileName, filename, sizeof(pfd->cFileName));
1133 else
1134 pfd->cFileName[0] = '\0';
1135
1136 if (shortname)
1137 lstrcpynA(pfd->cAlternateFileName, shortname, sizeof(pfd->cAlternateFileName));
1138 else
1139 pfd->cAlternateFileName[0] = '\0';
1140 return NOERROR;
1141
1142 case SHGDFIL_NETRESOURCE:
1143 case SHGDFIL_DESCRIPTIONID:
1144 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1145 break;
1146
1147 default:
1148 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1149 }
1150
1151 return E_INVALIDARG;
1152 }
1153
1154 /*************************************************************************
1155 * SHGetDataFromIDListW [SHELL32.248]
1156 *
1157 */
1158 HRESULT WINAPI SHGetDataFromIDListW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl,
1159 int nFormat, LPVOID dest, int len)
1160 {
1161 LPSTR filename, shortname;
1162 WIN32_FIND_DATAW * pfd = dest;
1163
1164 TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
1165
1166 pdump(pidl);
1167
1168 if (!psf || !dest)
1169 return E_INVALIDARG;
1170
1171 switch (nFormat)
1172 {
1173 case SHGDFIL_FINDDATA:
1174 pfd = dest;
1175
1176 if (_ILIsDrive(pidl))
1177 return E_INVALIDARG;
1178
1179 if (len < sizeof(WIN32_FIND_DATAW))
1180 return E_INVALIDARG;
1181
1182 ZeroMemory(pfd, sizeof (WIN32_FIND_DATAA));
1183 _ILGetFileDateTime( pidl, &(pfd->ftLastWriteTime));
1184 pfd->dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
1185 pfd->nFileSizeLow = _ILGetFileSize ( pidl, NULL, 0);
1186
1187 filename = _ILGetTextPointer(pidl);
1188 shortname = _ILGetSTextPointer(pidl);
1189
1190 if (!filename)
1191 pfd->cFileName[0] = '\0';
1192 else if (!MultiByteToWideChar(CP_ACP, 0, filename, -1, pfd->cFileName, MAX_PATH))
1193 pfd->cFileName[MAX_PATH-1] = 0;
1194
1195 if (!shortname)
1196 pfd->cAlternateFileName[0] = '\0';
1197 else if (!MultiByteToWideChar(CP_ACP, 0, shortname, -1, pfd->cAlternateFileName, 14))
1198 pfd->cAlternateFileName[13] = 0;
1199 return NOERROR;
1200
1201 case SHGDFIL_NETRESOURCE:
1202 case SHGDFIL_DESCRIPTIONID:
1203 FIXME_(shell)("SHGDFIL %i stub\n", nFormat);
1204 break;
1205
1206 default:
1207 ERR_(shell)("Unknown SHGDFIL %i, please report\n", nFormat);
1208 }
1209
1210 return E_INVALIDARG;
1211 }
1212
1213 /*************************************************************************
1214 * SHGetPathFromIDListA [SHELL32.@][NT 4.0: SHELL32.220]
1215 *
1216 * PARAMETERS
1217 * pidl, [IN] pidl
1218 * pszPath [OUT] path
1219 *
1220 * RETURNS
1221 * path from a passed PIDL.
1222 *
1223 * NOTES
1224 * NULL returns FALSE
1225 * desktop pidl gives path to desktop directory back
1226 * special pidls returning FALSE
1227 */
1228 BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
1229 {
1230 WCHAR wszPath[MAX_PATH];
1231 BOOL bSuccess;
1232
1233 bSuccess = SHGetPathFromIDListW(pidl, wszPath);
1234 WideCharToMultiByte(CP_ACP, 0, wszPath, -1, pszPath, MAX_PATH, NULL, NULL);
1235
1236 return bSuccess;
1237 }
1238
1239 /*************************************************************************
1240 * SHGetPathFromIDListW [SHELL32.@]
1241 *
1242 * See SHGetPathFromIDListA.
1243 */
1244 BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
1245 {
1246 HRESULT hr;
1247 LPCITEMIDLIST pidlLast;
1248 LPSHELLFOLDER psfFolder;
1249 DWORD dwAttributes;
1250 STRRET strret;
1251
1252 TRACE_(shell)("(pidl=%p,%p)\n", pidl, pszPath);
1253 pdump(pidl);
1254
1255 *pszPath = '\0';
1256 if (!pidl)
1257 return FALSE;
1258
1259 hr = SHBindToParent(pidl, &IID_IShellFolder, (VOID**)&psfFolder, &pidlLast);
1260 if (FAILED(hr)) return FALSE;
1261
1262 dwAttributes = SFGAO_FILESYSTEM;
1263 hr = IShellFolder_GetAttributesOf(psfFolder, 1, &pidlLast, &dwAttributes);
1264 if (FAILED(hr) || !(dwAttributes & SFGAO_FILESYSTEM)) {
1265 IShellFolder_Release(psfFolder);
1266 return FALSE;
1267 }
1268
1269 hr = IShellFolder_GetDisplayNameOf(psfFolder, pidlLast, SHGDN_FORPARSING, &strret);
1270 IShellFolder_Release(psfFolder);
1271 if (FAILED(hr)) return FALSE;
1272
1273 hr = StrRetToBufW(&strret, pidlLast, pszPath, MAX_PATH);
1274
1275 TRACE_(shell)("-- %s, 0x%08x\n",debugstr_w(pszPath), hr);
1276 return SUCCEEDED(hr);
1277 }
1278
1279 /*************************************************************************
1280 * SHBindToParent [shell version 5.0]
1281 */
1282 HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
1283 {
1284 IShellFolder * psfDesktop;
1285 HRESULT hr=E_FAIL;
1286
1287 TRACE_(shell)("pidl=%p\n", pidl);
1288 pdump(pidl);
1289
1290 if (!pidl || !ppv)
1291 return E_INVALIDARG;
1292
1293 *ppv = NULL;
1294 if (ppidlLast)
1295 *ppidlLast = NULL;
1296
1297 hr = SHGetDesktopFolder(&psfDesktop);
1298 if (FAILED(hr))
1299 return hr;
1300
1301 if (_ILIsPidlSimple(pidl))
1302 {
1303 /* we are on desktop level */
1304 hr = IShellFolder_QueryInterface(psfDesktop, riid, ppv);
1305 }
1306 else
1307 {
1308 LPITEMIDLIST pidlParent = ILClone(pidl);
1309 ILRemoveLastID(pidlParent);
1310 hr = IShellFolder_BindToObject(psfDesktop, pidlParent, NULL, riid, ppv);
1311 SHFree (pidlParent);
1312 }
1313
1314 IShellFolder_Release(psfDesktop);
1315
1316 if (SUCCEEDED(hr) && ppidlLast)
1317 *ppidlLast = ILFindLastID(pidl);
1318
1319 TRACE_(shell)("-- psf=%p pidl=%p ret=0x%08x\n", *ppv, (ppidlLast)?*ppidlLast:NULL, hr);
1320 return hr;
1321 }
1322
1323 /*************************************************************************
1324 * SHParseDisplayName [SHELL32.@]
1325 */
1326 HRESULT WINAPI SHParseDisplayName(LPCWSTR name, IBindCtx *bindctx, LPITEMIDLIST *pidlist,
1327 SFGAOF attr_in, SFGAOF *attr_out)
1328 {
1329 FIXME("%s %p %p %d %p stub!\n", debugstr_w(name), bindctx, pidlist, attr_in, attr_out);
1330 if(pidlist) *pidlist = NULL;
1331 return E_NOTIMPL;
1332 }
1333
1334 /**************************************************************************
1335 *
1336 * internal functions
1337 *
1338 * ### 1. section creating pidls ###
1339 *
1340 *************************************************************************
1341 */
1342
1343 /* Basic PIDL constructor. Allocates size + 5 bytes, where:
1344 * - two bytes are SHITEMID.cb
1345 * - one byte is PIDLDATA.type
1346 * - two bytes are the NULL PIDL terminator
1347 * Sets type of the returned PIDL to type.
1348 */
1349 static LPITEMIDLIST _ILAlloc(PIDLTYPE type, unsigned int size)
1350 {
1351 LPITEMIDLIST pidlOut = NULL;
1352
1353 pidlOut = SHAlloc(size + 5);
1354 if(pidlOut)
1355 {
1356 LPPIDLDATA pData;
1357 LPITEMIDLIST pidlNext;
1358
1359 ZeroMemory(pidlOut, size + 5);
1360 pidlOut->mkid.cb = size + 3;
1361
1362 pData = _ILGetDataPointer(pidlOut);
1363 if (pData)
1364 pData->type = type;
1365
1366 pidlNext = ILGetNext(pidlOut);
1367 if (pidlNext)
1368 pidlNext->mkid.cb = 0x00;
1369 TRACE("-- (pidl=%p, size=%u)\n", pidlOut, size);
1370 }
1371
1372 return pidlOut;
1373 }
1374
1375 LPITEMIDLIST _ILCreateDesktop(void)
1376 {
1377 LPITEMIDLIST ret;
1378
1379 TRACE("()\n");
1380 ret = SHAlloc(2);
1381 if (ret)
1382 ret->mkid.cb = 0;
1383 return ret;
1384 }
1385
1386 LPITEMIDLIST _ILCreateMyComputer(void)
1387 {
1388 TRACE("()\n");
1389 return _ILCreateGuid(PT_GUID, &CLSID_MyComputer);
1390 }
1391
1392 LPITEMIDLIST _ILCreateMyDocuments(void)
1393 {
1394 TRACE("()\n");
1395 return _ILCreateGuid(PT_GUID, &CLSID_MyDocuments);
1396 }
1397
1398 LPITEMIDLIST _ILCreateIExplore(void)
1399 {
1400 TRACE("()\n");
1401 return _ILCreateGuid(PT_GUID, &CLSID_Internet);
1402 }
1403
1404 LPITEMIDLIST _ILCreateControlPanel(void)
1405 {
1406 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1407
1408 TRACE("()\n");
1409 if (parent)
1410 {
1411 LPITEMIDLIST cpl = _ILCreateGuid(PT_SHELLEXT, &CLSID_ControlPanel);
1412
1413 if (cpl)
1414 {
1415 ret = ILCombine(parent, cpl);
1416 SHFree(cpl);
1417 }
1418 SHFree(parent);
1419 }
1420 return ret;
1421 }
1422
1423 LPITEMIDLIST _ILCreatePrinters(void)
1424 {
1425 LPITEMIDLIST parent = _ILCreateGuid(PT_GUID, &CLSID_MyComputer), ret = NULL;
1426
1427 TRACE("()\n");
1428 if (parent)
1429 {
1430 LPITEMIDLIST printers = _ILCreateGuid(PT_YAGUID, &CLSID_Printers);
1431
1432 if (printers)
1433 {
1434 ret = ILCombine(parent, printers);
1435 SHFree(printers);
1436 }
1437 SHFree(parent);
1438 }
1439 return ret;
1440 }
1441
1442 LPITEMIDLIST _ILCreateNetwork(void)
1443 {
1444 TRACE("()\n");
1445 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1446 }
1447
1448 LPITEMIDLIST _ILCreateBitBucket(void)
1449 {
1450 TRACE("()\n");
1451 return _ILCreateGuid(PT_GUID, &CLSID_RecycleBin);
1452 }
1453
1454 LPITEMIDLIST _ILCreateNetHood(void)
1455 {
1456 TRACE("()\n");
1457 return _ILCreateGuid(PT_GUID, &CLSID_NetworkPlaces);
1458 }
1459
1460 LPITEMIDLIST _ILCreateGuid(PIDLTYPE type, REFIID guid)
1461 {
1462 LPITEMIDLIST pidlOut;
1463
1464 if (type == PT_SHELLEXT || type == PT_GUID || type == PT_YAGUID)
1465 {
1466 pidlOut = _ILAlloc(type, sizeof(GUIDStruct));
1467 if (pidlOut)
1468 {
1469 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1470
1471 pData->u.guid.guid = *guid;
1472 TRACE("-- create GUID-pidl %s\n",
1473 debugstr_guid(&(pData->u.guid.guid)));
1474 }
1475 }
1476 else
1477 {
1478 WARN("%d: invalid type for GUID\n", type);
1479 pidlOut = NULL;
1480 }
1481 return pidlOut;
1482 }
1483
1484 LPITEMIDLIST _ILCreateGuidFromStrA(LPCSTR szGUID)
1485 {
1486 IID iid;
1487
1488 if (FAILED(SHCLSIDFromStringA(szGUID, &iid)))
1489 {
1490 ERR("%s is not a GUID\n", szGUID);
1491 return NULL;
1492 }
1493 return _ILCreateGuid(PT_GUID, &iid);
1494 }
1495
1496 LPITEMIDLIST _ILCreateGuidFromStrW(LPCWSTR szGUID)
1497 {
1498 IID iid;
1499
1500 if (FAILED(SHCLSIDFromStringW(szGUID, &iid)))
1501 {
1502 ERR("%s is not a GUID\n", debugstr_w(szGUID));
1503 return NULL;
1504 }
1505 return _ILCreateGuid(PT_GUID, &iid);
1506 }
1507
1508 LPITEMIDLIST _ILCreateFromFindDataW( const WIN32_FIND_DATAW *wfd )
1509 {
1510 char buff[MAX_PATH + 14 +1]; /* see WIN32_FIND_DATA */
1511 DWORD len, len1, wlen, alen;
1512 LPITEMIDLIST pidl;
1513 PIDLTYPE type;
1514
1515 if (!wfd)
1516 return NULL;
1517
1518 TRACE("(%s, %s)\n",debugstr_w(wfd->cAlternateFileName), debugstr_w(wfd->cFileName));
1519
1520 /* prepare buffer with both names */
1521 len = WideCharToMultiByte(CP_ACP,0,wfd->cFileName,-1,buff,MAX_PATH,NULL,NULL);
1522 len1 = WideCharToMultiByte(CP_ACP,0,wfd->cAlternateFileName,-1, buff+len, sizeof(buff)-len, NULL, NULL);
1523 alen = len + len1;
1524
1525 type = (wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
1526
1527 wlen = lstrlenW(wfd->cFileName) + 1;
1528 pidl = _ILAlloc(type, FIELD_OFFSET(FileStruct, szNames[alen + (alen & 1)]) +
1529 FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD));
1530 if (pidl)
1531 {
1532 LPPIDLDATA pData = _ILGetDataPointer(pidl);
1533 FileStruct *fs = &pData->u.file;
1534 FileStructW *fsw;
1535 WORD *pOffsetW;
1536
1537 FileTimeToDosDateTime( &wfd->ftLastWriteTime, &fs->uFileDate, &fs->uFileTime);
1538 fs->dwFileSize = wfd->nFileSizeLow;
1539 fs->uFileAttribs = wfd->dwFileAttributes;
1540 memcpy(fs->szNames, buff, alen);
1541
1542 fsw = (FileStructW*)(pData->u.file.szNames + alen + (alen & 0x1));
1543 fsw->cbLen = FIELD_OFFSET(FileStructW, wszName[wlen]) + sizeof(WORD);
1544 FileTimeToDosDateTime( &wfd->ftCreationTime, &fsw->uCreationDate, &fsw->uCreationTime);
1545 FileTimeToDosDateTime( &wfd->ftLastAccessTime, &fsw->uLastAccessDate, &fsw->uLastAccessTime);
1546 memcpy(fsw->wszName, wfd->cFileName, wlen * sizeof(WCHAR));
1547
1548 pOffsetW = (WORD*)((LPBYTE)pidl + pidl->mkid.cb - sizeof(WORD));
1549 *pOffsetW = (LPBYTE)fsw - (LPBYTE)pidl;
1550 TRACE("-- Set Value: %s\n",debugstr_w(fsw->wszName));
1551 }
1552 return pidl;
1553
1554 }
1555
1556 HRESULT _ILCreateFromPathW(LPCWSTR szPath, LPITEMIDLIST* ppidl)
1557 {
1558 HANDLE hFile;
1559 WIN32_FIND_DATAW stffile;
1560
1561 if (!ppidl)
1562 return E_INVALIDARG;
1563
1564 hFile = FindFirstFileW(szPath, &stffile);
1565 if (hFile == INVALID_HANDLE_VALUE)
1566 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1567
1568 FindClose(hFile);
1569
1570 *ppidl = _ILCreateFromFindDataW(&stffile);
1571
1572 return *ppidl ? S_OK : E_OUTOFMEMORY;
1573 }
1574
1575 LPITEMIDLIST _ILCreateDrive(LPCWSTR lpszNew)
1576 {
1577 LPITEMIDLIST pidlOut;
1578
1579 TRACE("(%s)\n",debugstr_w(lpszNew));
1580
1581 pidlOut = _ILAlloc(PT_DRIVE, sizeof(DriveStruct));
1582 if (pidlOut)
1583 {
1584 LPSTR pszDest;
1585
1586 pszDest = _ILGetTextPointer(pidlOut);
1587 if (pszDest)
1588 {
1589 strcpy(pszDest, "x:\\");
1590 pszDest[0]=toupperW(lpszNew[0]);
1591 TRACE("-- create Drive: %s\n", debugstr_a(pszDest));
1592 }
1593 }
1594 return pidlOut;
1595 }
1596
1597 LPITEMIDLIST _ILCreateEntireNetwork(void)
1598 {
1599 LPITEMIDLIST pidlOut;
1600
1601 TRACE("\n");
1602
1603 pidlOut = _ILAlloc(PT_NETWORK, FIELD_OFFSET(PIDLDATA, u.network.szNames[sizeof("Entire Network")]));
1604 if (pidlOut)
1605 {
1606 LPPIDLDATA pData = _ILGetDataPointer(pidlOut);
1607
1608 pData->u.network.dummy = 0;
1609 strcpy(pData->u.network.szNames, "Entire Network");
1610 }
1611 return pidlOut;
1612 }
1613
1614 /**************************************************************************
1615 * _ILGetDrive()
1616 *
1617 * Gets the text for the drive eg. 'c:\'
1618 *
1619 * RETURNS
1620 * strlen (lpszText)
1621 */
1622 DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
1623 {
1624 TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
1625
1626 if(_ILIsMyComputer(pidl))
1627 pidl = ILGetNext(pidl);
1628
1629 if (pidl && _ILIsDrive(pidl))
1630 return _ILSimpleGetText(pidl, pOut, uSize);
1631
1632 return 0;
1633 }
1634
1635 /**************************************************************************
1636 *
1637 * ### 2. section testing pidls ###
1638 *
1639 **************************************************************************
1640 * _ILIsUnicode()
1641 * _ILIsDesktop()
1642 * _ILIsMyComputer()
1643 * _ILIsSpecialFolder()
1644 * _ILIsDrive()
1645 * _ILIsFolder()
1646 * _ILIsValue()
1647 * _ILIsPidlSimple()
1648 */
1649 BOOL _ILIsUnicode(LPCITEMIDLIST pidl)
1650 {
1651 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1652
1653 TRACE("(%p)\n",pidl);
1654
1655 return (pidl && lpPData && PT_VALUEW == lpPData->type);
1656 }
1657
1658 BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
1659 {
1660 TRACE("(%p)\n",pidl);
1661
1662 return pidl && pidl->mkid.cb ? 0 : 1;
1663 }
1664
1665 BOOL _ILIsMyComputer(LPCITEMIDLIST pidl)
1666 {
1667 REFIID iid = _ILGetGUIDPointer(pidl);
1668
1669 TRACE("(%p)\n",pidl);
1670
1671 if (iid)
1672 return IsEqualIID(iid, &CLSID_MyComputer);
1673 return FALSE;
1674 }
1675
1676 BOOL _ILIsSpecialFolder (LPCITEMIDLIST pidl)
1677 {
1678 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1679
1680 TRACE("(%p)\n",pidl);
1681
1682 return (pidl && ( (lpPData && (PT_GUID== lpPData->type || PT_SHELLEXT== lpPData->type || PT_YAGUID == lpPData->type)) ||
1683 (pidl && pidl->mkid.cb == 0x00)
1684 ));
1685 }
1686
1687 BOOL _ILIsDrive(LPCITEMIDLIST pidl)
1688 {
1689 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1690
1691 TRACE("(%p)\n",pidl);
1692
1693 return (pidl && lpPData && (PT_DRIVE == lpPData->type ||
1694 PT_DRIVE1 == lpPData->type ||
1695 PT_DRIVE2 == lpPData->type ||
1696 PT_DRIVE3 == lpPData->type));
1697 }
1698
1699 BOOL _ILIsFolder(LPCITEMIDLIST pidl)
1700 {
1701 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1702
1703 TRACE("(%p)\n",pidl);
1704
1705 return (pidl && lpPData && (PT_FOLDER == lpPData->type || PT_FOLDER1 == lpPData->type));
1706 }
1707
1708 BOOL _ILIsValue(LPCITEMIDLIST pidl)
1709 {
1710 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1711
1712 TRACE("(%p)\n",pidl);
1713
1714 return (pidl && lpPData && PT_VALUE == lpPData->type);
1715 }
1716
1717 BOOL _ILIsCPanelStruct(LPCITEMIDLIST pidl)
1718 {
1719 LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
1720
1721 TRACE("(%p)\n",pidl);
1722
1723 return (pidl && lpPData && (lpPData->type == 0));
1724 }
1725
1726 /**************************************************************************
1727 * _ILIsPidlSimple
1728 */
1729 BOOL _ILIsPidlSimple(LPCITEMIDLIST pidl)
1730 {
1731 BOOL ret = TRUE;
1732
1733 if(! _ILIsDesktop(pidl)) /* pidl=NULL or mkid.cb=0 */
1734 {
1735 WORD len = pidl->mkid.cb;
1736 LPCITEMIDLIST pidlnext = (LPCITEMIDLIST) (((const BYTE*)pidl) + len );
1737
1738 if (pidlnext->mkid.cb)
1739 ret = FALSE;
1740 }
1741
1742 TRACE("%s\n", ret ? "Yes" : "No");
1743 return ret;
1744 }
1745
1746 /**************************************************************************
1747 *
1748 * ### 3. section getting values from pidls ###
1749 */
1750
1751 /**************************************************************************
1752 * _ILSimpleGetText
1753 *
1754 * gets the text for the first item in the pidl (eg. simple pidl)
1755 *
1756 * returns the length of the string
1757 */
1758 DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
1759 {
1760 DWORD dwReturn=0;
1761 LPSTR szSrc;
1762 LPWSTR szSrcW;
1763 GUID const * riid;
1764 char szTemp[MAX_PATH];
1765
1766 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1767
1768 if (!pidl)
1769 return 0;
1770
1771 if (szOut)
1772 *szOut = 0;
1773
1774 if (_ILIsDesktop(pidl))
1775 {
1776 /* desktop */
1777 if (HCR_GetClassNameA(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1778 {
1779 if (szOut)
1780 lstrcpynA(szOut, szTemp, uOutSize);
1781
1782 dwReturn = strlen (szTemp);
1783 }
1784 }
1785 else if (( szSrc = _ILGetTextPointer(pidl) ))
1786 {
1787 /* filesystem */
1788 if (szOut)
1789 lstrcpynA(szOut, szSrc, uOutSize);
1790
1791 dwReturn = strlen(szSrc);
1792 }
1793 else if (( szSrcW = _ILGetTextPointerW(pidl) ))
1794 {
1795 /* unicode filesystem */
1796 WideCharToMultiByte(CP_ACP,0,szSrcW, -1, szTemp, MAX_PATH, NULL, NULL);
1797
1798 if (szOut)
1799 lstrcpynA(szOut, szTemp, uOutSize);
1800
1801 dwReturn = strlen (szTemp);
1802 }
1803 else if (( riid = _ILGetGUIDPointer(pidl) ))
1804 {
1805 /* special folder */
1806 if ( HCR_GetClassNameA(riid, szTemp, MAX_PATH) )
1807 {
1808 if (szOut)
1809 lstrcpynA(szOut, szTemp, uOutSize);
1810
1811 dwReturn = strlen (szTemp);
1812 }
1813 }
1814 else
1815 {
1816 ERR("-- no text\n");
1817 }
1818
1819 TRACE("-- (%p=%s 0x%08x)\n",szOut,debugstr_a(szOut),dwReturn);
1820 return dwReturn;
1821 }
1822
1823 /**************************************************************************
1824 * _ILSimpleGetTextW
1825 *
1826 * gets the text for the first item in the pidl (eg. simple pidl)
1827 *
1828 * returns the length of the string
1829 */
1830 DWORD _ILSimpleGetTextW (LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
1831 {
1832 DWORD dwReturn;
1833 FileStructW *pFileStructW = _ILGetFileStructW(pidl);
1834
1835 TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
1836
1837 if (pFileStructW) {
1838 lstrcpynW(szOut, pFileStructW->wszName, uOutSize);
1839 dwReturn = lstrlenW(pFileStructW->wszName);
1840 } else {
1841 GUID const * riid;
1842 WCHAR szTemp[MAX_PATH];
1843 LPSTR szSrc;
1844 LPWSTR szSrcW;
1845 dwReturn=0;
1846
1847 if (!pidl)
1848 return 0;
1849
1850 if (szOut)
1851 *szOut = 0;
1852
1853 if (_ILIsDesktop(pidl))
1854 {
1855 /* desktop */
1856 if (HCR_GetClassNameW(&CLSID_ShellDesktop, szTemp, MAX_PATH))
1857 {
1858 if (szOut)
1859 lstrcpynW(szOut, szTemp, uOutSize);
1860
1861 dwReturn = lstrlenW (szTemp);
1862 }
1863 }
1864 else if (( szSrcW = _ILGetTextPointerW(pidl) ))
1865 {
1866 /* unicode filesystem */
1867 if (szOut)
1868 lstrcpynW(szOut, szSrcW, uOutSize);
1869
1870 dwReturn = lstrlenW(szSrcW);
1871 }
1872 else if (( szSrc = _ILGetTextPointer(pidl) ))
1873 {
1874 /* filesystem */
1875 MultiByteToWideChar(CP_ACP, 0, szSrc, -1, szTemp, MAX_PATH);
1876
1877 if (szOut)
1878 lstrcpynW(szOut, szTemp, uOutSize);
1879
1880 dwReturn = lstrlenW (szTemp);
1881 }
1882 else if (( riid = _ILGetGUIDPointer(pidl) ))
1883 {
1884 /* special folder */
1885 if ( HCR_GetClassNameW(riid, szTemp, MAX_PATH) )
1886 {
1887 if (szOut)
1888 lstrcpynW(szOut, szTemp, uOutSize);
1889
1890 dwReturn = lstrlenW (szTemp);
1891 }
1892 }
1893 else
1894 {
1895 ERR("-- no text\n");
1896 }
1897 }
1898
1899 TRACE("-- (%p=%s 0x%08x)\n",szOut,debugstr_w(szOut),dwReturn);
1900 return dwReturn;
1901 }
1902
1903 /**************************************************************************
1904 *
1905 * ### 4. getting pointers to parts of pidls ###
1906 *
1907 **************************************************************************
1908 * _ILGetDataPointer()
1909 */
1910 LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
1911 {
1912 if(pidl && pidl->mkid.cb != 0x00)
1913 return (LPPIDLDATA)pidl->mkid.abID;
1914 return NULL;
1915 }
1916
1917 /**************************************************************************
1918 * _ILGetTextPointerW()
1919 * gets a pointer to the unicode long filename string stored in the pidl
1920 */
1921 static LPWSTR _ILGetTextPointerW(LPCITEMIDLIST pidl)
1922 {
1923 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
1924
1925 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1926
1927 if (!pdata)
1928 return NULL;
1929
1930 switch (pdata->type)
1931 {
1932 case PT_GUID:
1933 case PT_SHELLEXT:
1934 case PT_YAGUID:
1935 return NULL;
1936
1937 case PT_DRIVE:
1938 case PT_DRIVE1:
1939 case PT_DRIVE2:
1940 case PT_DRIVE3:
1941 /*return (LPSTR)&(pdata->u.drive.szDriveName);*/
1942 return NULL;
1943
1944 case PT_FOLDER:
1945 case PT_FOLDER1:
1946 case PT_VALUE:
1947 case PT_IESPECIAL1:
1948 case PT_IESPECIAL2:
1949 /*return (LPSTR)&(pdata->u.file.szNames);*/
1950 return NULL;
1951
1952 case PT_WORKGRP:
1953 case PT_COMP:
1954 case PT_NETWORK:
1955 case PT_NETPROVIDER:
1956 case PT_SHARE:
1957 /*return (LPSTR)&(pdata->u.network.szNames);*/
1958 return NULL;
1959
1960 case PT_VALUEW:
1961 return (LPWSTR)pdata->u.file.szNames;
1962 }
1963 return NULL;
1964 }
1965
1966
1967 /**************************************************************************
1968 * _ILGetTextPointer()
1969 * gets a pointer to the long filename string stored in the pidl
1970 */
1971 LPSTR _ILGetTextPointer(LPCITEMIDLIST pidl)
1972 {
1973 /* TRACE(pidl,"(pidl%p)\n", pidl);*/
1974
1975 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
1976
1977 if (!pdata)
1978 return NULL;
1979
1980 switch (pdata->type)
1981 {
1982 case PT_GUID:
1983 case PT_SHELLEXT:
1984 case PT_YAGUID:
1985 return NULL;
1986
1987 case PT_DRIVE:
1988 case PT_DRIVE1:
1989 case PT_DRIVE2:
1990 case PT_DRIVE3:
1991 return pdata->u.drive.szDriveName;
1992
1993 case PT_FOLDER:
1994 case PT_FOLDER1:
1995 case PT_VALUE:
1996 case PT_IESPECIAL1:
1997 case PT_IESPECIAL2:
1998 return pdata->u.file.szNames;
1999
2000 case PT_WORKGRP:
2001 case PT_COMP:
2002 case PT_NETWORK:
2003 case PT_NETPROVIDER:
2004 case PT_SHARE:
2005 return pdata->u.network.szNames;
2006 }
2007 return NULL;
2008 }
2009
2010 /**************************************************************************
2011 * _ILGetSTextPointer()
2012 * gets a pointer to the short filename string stored in the pidl
2013 */
2014 static LPSTR _ILGetSTextPointer(LPCITEMIDLIST pidl)
2015 {
2016 /* TRACE(pidl,"(pidl%p)\n", pidl); */
2017
2018 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2019
2020 if (!pdata)
2021 return NULL;
2022
2023 switch (pdata->type)
2024 {
2025 case PT_FOLDER:
2026 case PT_VALUE:
2027 case PT_IESPECIAL1:
2028 case PT_IESPECIAL2:
2029 return pdata->u.file.szNames + strlen (pdata->u.file.szNames) + 1;
2030
2031 case PT_WORKGRP:
2032 return pdata->u.network.szNames + strlen (pdata->u.network.szNames) + 1;
2033 }
2034 return NULL;
2035 }
2036
2037 /**************************************************************************
2038 * _ILGetGUIDPointer()
2039 *
2040 * returns reference to guid stored in some pidls
2041 */
2042 IID* _ILGetGUIDPointer(LPCITEMIDLIST pidl)
2043 {
2044 LPPIDLDATA pdata =_ILGetDataPointer(pidl);
2045
2046 TRACE("%p\n", pidl);
2047
2048 if (!pdata)
2049 return NULL;
2050
2051 TRACE("pdata->type 0x%04x\n", pdata->type);
2052 switch (pdata->type)
2053 {
2054 case PT_SHELLEXT:
2055 case PT_GUID:
2056 case PT_YAGUID:
2057 return &(pdata->u.guid.guid);
2058
2059 default:
2060 TRACE("Unknown pidl type 0x%04x\n", pdata->type);
2061 break;
2062 }
2063 return NULL;
2064 }
2065
2066 /******************************************************************************
2067 * _ILGetFileStructW [Internal]
2068 *
2069 * Get pointer the a SHITEMID's FileStructW field if present
2070 *
2071 * PARAMS
2072 * pidl [I] The SHITEMID
2073 *
2074 * RETURNS
2075 * Success: Pointer to pidl's FileStructW field.
2076 * Failure: NULL
2077 */
2078 FileStructW* _ILGetFileStructW(LPCITEMIDLIST pidl) {
2079 FileStructW *pFileStructW;
2080 WORD cbOffset;
2081
2082 if (!(_ILIsValue(pidl) || _ILIsFolder(pidl)))
2083 return NULL;
2084
2085 cbOffset = *(const WORD *)((const BYTE *)pidl + pidl->mkid.cb - sizeof(WORD));
2086 pFileStructW = (FileStructW*)((LPBYTE)pidl + cbOffset);
2087
2088 /* Currently I don't see a fool prove way to figure out if a pidl is for sure of WinXP
2089 * style with a FileStructW member. If we switch all our shellfolder-implementations to
2090 * the new format, this won't be a problem. For now, we do as many sanity checks as possible. */
2091 if (cbOffset & 0x1 || /* FileStructW member is word aligned in the pidl */
2092 /* FileStructW is positioned after FileStruct */
2093 cbOffset < sizeof(pidl->mkid.cb) + sizeof(PIDLTYPE) + sizeof(FileStruct) ||
2094 /* There has to be enough space at cbOffset in the pidl to hold FileStructW and cbOffset */
2095 cbOffset > pidl->mkid.cb - sizeof(cbOffset) - sizeof(FileStructW) ||
2096 pidl->mkid.cb != cbOffset + pFileStructW->cbLen)
2097 {
2098 WARN("Invalid pidl format (cbOffset = %d)!\n", cbOffset);
2099 return NULL;
2100 }
2101
2102 return pFileStructW;
2103 }
2104
2105 /*************************************************************************
2106 * _ILGetFileDateTime
2107 *
2108 * Given the ItemIdList, get the FileTime
2109 *
2110 * PARAMS
2111 * pidl [I] The ItemIDList
2112 * pFt [I] the resulted FILETIME of the file
2113 *
2114 * RETURNS
2115 * True if Successful
2116 *
2117 * NOTES
2118 *
2119 */
2120 BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
2121 {
2122 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2123
2124 if (!pdata)
2125 return FALSE;
2126
2127 switch (pdata->type)
2128 {
2129 case PT_FOLDER:
2130 case PT_VALUE:
2131 DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
2132 break;
2133 default:
2134 return FALSE;
2135 }
2136 return TRUE;
2137 }
2138
2139 BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2140 {
2141 FILETIME ft,lft;
2142 SYSTEMTIME time;
2143 BOOL ret;
2144
2145 if (_ILGetFileDateTime( pidl, &ft ))
2146 {
2147 FileTimeToLocalFileTime(&ft, &lft);
2148 FileTimeToSystemTime (&lft, &time);
2149
2150 ret = GetDateFormatA(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&time, NULL, pOut, uOutSize);
2151 if (ret)
2152 {
2153 /* Append space + time without seconds */
2154 pOut[ret-1] = ' ';
2155 GetTimeFormatA(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &pOut[ret], uOutSize - ret);
2156 }
2157 }
2158 else
2159 {
2160 pOut[0] = '\0';
2161 ret = FALSE;
2162 }
2163 return ret;
2164 }
2165
2166 /*************************************************************************
2167 * _ILGetFileSize
2168 *
2169 * Given the ItemIdList, get the FileSize
2170 *
2171 * PARAMS
2172 * pidl [I] The ItemIDList
2173 * pOut [I] The buffer to save the result
2174 * uOutsize [I] The size of the buffer
2175 *
2176 * RETURNS
2177 * The FileSize
2178 *
2179 * NOTES
2180 * pOut can be null when no string is needed
2181 *
2182 */
2183 DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2184 {
2185 LPPIDLDATA pdata = _ILGetDataPointer(pidl);
2186 DWORD dwSize;
2187
2188 if (!pdata)
2189 return 0;
2190
2191 switch (pdata->type)
2192 {
2193 case PT_VALUE:
2194 dwSize = pdata->u.file.dwFileSize;
2195 if (pOut)
2196 StrFormatKBSizeA(dwSize, pOut, uOutSize);
2197 return dwSize;
2198 }
2199 if (pOut)
2200 *pOut = 0x00;
2201 return 0;
2202 }
2203
2204 BOOL _ILGetExtension (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2205 {
2206 char szTemp[MAX_PATH];
2207 const char * pPoint;
2208 LPCITEMIDLIST pidlTemp=pidl;
2209
2210 TRACE("pidl=%p\n",pidl);
2211
2212 if (!pidl)
2213 return FALSE;
2214
2215 pidlTemp = ILFindLastID(pidl);
2216
2217 if (!_ILIsValue(pidlTemp))
2218 return FALSE;
2219 if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH))
2220 return FALSE;
2221
2222 pPoint = PathFindExtensionA(szTemp);
2223
2224 if (!*pPoint)
2225 return FALSE;
2226
2227 pPoint++;
2228 lstrcpynA(pOut, pPoint, uOutSize);
2229 TRACE("%s\n",pOut);
2230
2231 return TRUE;
2232 }
2233
2234 /*************************************************************************
2235 * _ILGetFileType
2236 *
2237 * Given the ItemIdList, get the file type description
2238 *
2239 * PARAMS
2240 * pidl [I] The ItemIDList (simple)
2241 * pOut [I] The buffer to save the result
2242 * uOutsize [I] The size of the buffer
2243 *
2244 * RETURNS
2245 * nothing
2246 *
2247 * NOTES
2248 * This function copies as much as possible into the buffer.
2249 */
2250 void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2251 {
2252 if(_ILIsValue(pidl))
2253 {
2254 char sTemp[64];
2255
2256 if(uOutSize > 0)
2257 pOut[0] = 0;
2258 if (_ILGetExtension (pidl, sTemp, 64))
2259 {
2260 if (!( HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE)
2261 && HCR_MapTypeToValueA(sTemp, pOut, uOutSize, FALSE )))
2262 {
2263 lstrcpynA (pOut, sTemp, uOutSize - 6);
2264 strcat (pOut, "-file");
2265 }
2266 }
2267 }
2268 else
2269 lstrcpynA(pOut, "Folder", uOutSize);
2270 }
2271
2272 /*************************************************************************
2273 * _ILGetFileAttributes
2274 *
2275 * Given the ItemIdList, get the Attrib string format
2276 *
2277 * PARAMS
2278 * pidl [I] The ItemIDList
2279 * pOut [I] The buffer to save the result
2280 * uOutsize [I] The size of the Buffer
2281 *
2282 * RETURNS
2283 * Attributes
2284 *
2285 * FIXME
2286 * return value 0 in case of error is a valid return value
2287 *
2288 */
2289 DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
2290 {
2291 LPPIDLDATA pData = _ILGetDataPointer(pidl);
2292 WORD wAttrib = 0;
2293 int i;
2294
2295 if (!pData)
2296 return 0;
2297
2298 switch(pData->type)
2299 {
2300 case PT_FOLDER:
2301 case PT_VALUE:
2302 wAttrib = pData->u.file.uFileAttribs;
2303 break;
2304 }
2305
2306 if(uOutSize >= 6)
2307 {
2308 i=0;
2309 if(wAttrib & FILE_ATTRIBUTE_READONLY)
2310 pOut[i++] = 'R';
2311 if(wAttrib & FILE_ATTRIBUTE_HIDDEN)
2312 pOut[i++] = 'H';
2313 if(wAttrib & FILE_ATTRIBUTE_SYSTEM)
2314 pOut[i++] = 'S';
2315 if(wAttrib & FILE_ATTRIBUTE_ARCHIVE)
2316 pOut[i++] = 'A';
2317 if(wAttrib & FILE_ATTRIBUTE_COMPRESSED)
2318 pOut[i++] = 'C';
2319 pOut[i] = 0x00;
2320 }
2321 return wAttrib;
2322 }
2323
2324 /*************************************************************************
2325 * ILFreeaPidl
2326 *
2327 * free a aPidl struct
2328 */
2329 void _ILFreeaPidl(LPITEMIDLIST * apidl, UINT cidl)
2330 {
2331 UINT i;
2332
2333 if (apidl)
2334 {
2335 for (i = 0; i < cidl; i++)
2336 SHFree(apidl[i]);
2337 SHFree(apidl);
2338 }
2339 }
2340
2341 /*************************************************************************
2342 * ILCopyaPidl
2343 *
2344 * copies an aPidl struct
2345 */
2346 LPITEMIDLIST* _ILCopyaPidl(const LPCITEMIDLIST * apidlsrc, UINT cidl)
2347 {
2348 UINT i;
2349 LPITEMIDLIST *apidldest;
2350
2351 apidldest = SHAlloc(cidl * sizeof(LPITEMIDLIST));
2352 if (!apidlsrc)
2353 return NULL;
2354
2355 for (i = 0; i < cidl; i++)
2356 apidldest[i] = ILClone(apidlsrc[i]);
2357
2358 return apidldest;
2359 }
2360
2361 /*************************************************************************
2362 * _ILCopyCidaToaPidl
2363 *
2364 * creates aPidl from CIDA
2365 */
2366 LPITEMIDLIST* _ILCopyCidaToaPidl(LPITEMIDLIST* pidl, const CIDA * cida)
2367 {
2368 UINT i;
2369 LPITEMIDLIST *dst;
2370
2371 dst = SHAlloc(cida->cidl * sizeof(LPITEMIDLIST));
2372 if (!dst)
2373 return NULL;
2374
2375 if (pidl)
2376 *pidl = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[0]]));
2377
2378 for (i = 0; i < cida->cidl; i++)
2379 dst[i] = ILClone((LPCITEMIDLIST)(&((const BYTE*)cida)[cida->aoffset[i + 1]]));
2380
2381 return dst;
2382 }
2383
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.