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