shell32: Reject NULL path in IShellLink_SetPath.
[wine] / dlls / shell32 / iconcache.c
1 /*
2  *      shell icon cache (SIC)
3  *
4  * Copyright 1998, 1999 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
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <string.h>
26 #include <sys/types.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30
31 #define COBJMACROS
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "wingdi.h"
36 #include "winuser.h"
37 #include "winreg.h"
38 #include "wine/debug.h"
39
40 #include "shellapi.h"
41 #include "objbase.h"
42 #include "pidl.h"
43 #include "shell32_main.h"
44 #include "undocshell.h"
45 #include "shresdef.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(shell);
48
49 /********************** THE ICON CACHE ********************************/
50
51 #define INVALID_INDEX -1
52
53 typedef struct
54 {
55         LPWSTR sSourceFile;     /* file (not path!) containing the icon */
56         DWORD dwSourceIndex;    /* index within the file, if it is a resource ID it will be negated */
57         DWORD dwListIndex;      /* index within the iconlist */
58         DWORD dwFlags;          /* GIL_* flags */
59         DWORD dwAccessTime;
60 } SIC_ENTRY, * LPSIC_ENTRY;
61
62 static HDPA             sic_hdpa = 0;
63
64 static CRITICAL_SECTION SHELL32_SicCS;
65 static CRITICAL_SECTION_DEBUG critsect_debug =
66 {
67     0, 0, &SHELL32_SicCS,
68     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
69       0, 0, { (DWORD_PTR)(__FILE__ ": SHELL32_SicCS") }
70 };
71 static CRITICAL_SECTION SHELL32_SicCS = { &critsect_debug, -1, 0, 0, 0, 0 };
72
73 /*****************************************************************************
74  * SIC_CompareEntries
75  *
76  * NOTES
77  *  Callback for DPA_Search
78  */
79 static INT CALLBACK SIC_CompareEntries( LPVOID p1, LPVOID p2, LPARAM lparam)
80 {
81         LPSIC_ENTRY e1 = p1, e2 = p2;
82
83         TRACE("%p %p %8lx\n", p1, p2, lparam);
84
85         /* Icons in the cache are keyed by the name of the file they are
86          * loaded from, their resource index and the fact if they have a shortcut
87          * icon overlay or not. 
88          */
89         if (e1->dwSourceIndex != e2->dwSourceIndex || /* first the faster one */
90             (e1->dwFlags & GIL_FORSHORTCUT) != (e2->dwFlags & GIL_FORSHORTCUT)) 
91           return 1;
92
93         if (strcmpiW(e1->sSourceFile,e2->sSourceFile))
94           return 1;
95
96         return 0;
97 }
98
99 /* declare SIC_LoadOverlayIcon() */
100 static int SIC_LoadOverlayIcon(int icon_idx);
101
102 /*****************************************************************************
103  * SIC_OverlayShortcutImage                     [internal]
104  *
105  * NOTES
106  *  Creates a new icon as a copy of the passed-in icon, overlayed with a
107  *  shortcut image. 
108  */
109 static HICON SIC_OverlayShortcutImage(HICON SourceIcon, BOOL large)
110 {       ICONINFO SourceIconInfo, ShortcutIconInfo, TargetIconInfo;
111         HICON ShortcutIcon, TargetIcon;
112         BITMAP SourceBitmapInfo, ShortcutBitmapInfo;
113         HDC SourceDC = NULL,
114           ShortcutDC = NULL,
115           TargetDC = NULL,
116           ScreenDC = NULL;
117         HBITMAP OldSourceBitmap = NULL,
118           OldShortcutBitmap = NULL,
119           OldTargetBitmap = NULL;
120
121         static int s_imgListIdx = -1;
122
123         /* Get information about the source icon and shortcut overlay */
124         if (! GetIconInfo(SourceIcon, &SourceIconInfo)
125             || 0 == GetObjectW(SourceIconInfo.hbmColor, sizeof(BITMAP), &SourceBitmapInfo))
126         {
127           return NULL;
128         }
129
130         /* search for the shortcut icon only once */
131         if (s_imgListIdx == -1)
132             s_imgListIdx = SIC_LoadOverlayIcon(- IDI_SHELL_SHORTCUT);
133                            /* FIXME should use icon index 29 instead of the
134                               resource id, but not all icons are present yet
135                               so we can't use icon indices */
136
137         if (s_imgListIdx != -1)
138         {
139             if (large)
140                 ShortcutIcon = ImageList_GetIcon(ShellBigIconList, s_imgListIdx, ILD_TRANSPARENT);
141             else
142                 ShortcutIcon = ImageList_GetIcon(ShellSmallIconList, s_imgListIdx, ILD_TRANSPARENT);
143         } else
144             ShortcutIcon = NULL;
145
146         if (NULL == ShortcutIcon
147             || ! GetIconInfo(ShortcutIcon, &ShortcutIconInfo)
148             || 0 == GetObjectW(ShortcutIconInfo.hbmColor, sizeof(BITMAP), &ShortcutBitmapInfo))
149         {
150           return NULL;
151         }
152
153         TargetIconInfo = SourceIconInfo;
154         TargetIconInfo.hbmMask = NULL;
155         TargetIconInfo.hbmColor = NULL;
156
157         /* Setup the source, shortcut and target masks */
158         SourceDC = CreateCompatibleDC(NULL);
159         if (NULL == SourceDC) goto fail;
160         OldSourceBitmap = SelectObject(SourceDC, SourceIconInfo.hbmMask);
161         if (NULL == OldSourceBitmap) goto fail;
162
163         ShortcutDC = CreateCompatibleDC(NULL);
164         if (NULL == ShortcutDC) goto fail;
165         OldShortcutBitmap = SelectObject(ShortcutDC, ShortcutIconInfo.hbmMask);
166         if (NULL == OldShortcutBitmap) goto fail;
167
168         TargetDC = CreateCompatibleDC(NULL);
169         if (NULL == TargetDC) goto fail;
170         TargetIconInfo.hbmMask = CreateCompatibleBitmap(TargetDC, SourceBitmapInfo.bmWidth,
171                                                         SourceBitmapInfo.bmHeight);
172         if (NULL == TargetIconInfo.hbmMask) goto fail;
173         ScreenDC = GetDC(NULL);
174         if (NULL == ScreenDC) goto fail;
175         TargetIconInfo.hbmColor = CreateCompatibleBitmap(ScreenDC, SourceBitmapInfo.bmWidth,
176                                                          SourceBitmapInfo.bmHeight);
177         ReleaseDC(NULL, ScreenDC);
178         if (NULL == TargetIconInfo.hbmColor) goto fail;
179         OldTargetBitmap = SelectObject(TargetDC, TargetIconInfo.hbmMask);
180         if (NULL == OldTargetBitmap) goto fail;
181
182         /* Create the target mask by ANDing the source and shortcut masks */
183         if (! BitBlt(TargetDC, 0, 0, SourceBitmapInfo.bmWidth, SourceBitmapInfo.bmHeight,
184                      SourceDC, 0, 0, SRCCOPY) ||
185             ! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight,
186                      ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight,
187                      ShortcutDC, 0, 0, SRCAND))
188         {
189           goto fail;
190         }
191
192         /* Setup the source and target xor bitmap */
193         if (NULL == SelectObject(SourceDC, SourceIconInfo.hbmColor) ||
194             NULL == SelectObject(TargetDC, TargetIconInfo.hbmColor))
195         {
196           goto fail;
197         }
198
199         /* Copy the source xor bitmap to the target and clear out part of it by using
200            the shortcut mask */
201         if (! BitBlt(TargetDC, 0, 0, SourceBitmapInfo.bmWidth, SourceBitmapInfo.bmHeight,
202                      SourceDC, 0, 0, SRCCOPY) ||
203             ! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight,
204                      ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight,
205                      ShortcutDC, 0, 0, SRCAND))
206         {
207           goto fail;
208         }
209
210         if (NULL == SelectObject(ShortcutDC, ShortcutIconInfo.hbmColor)) goto fail;
211
212         /* Now put in the shortcut xor mask */
213         if (! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight,
214                      ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight,
215                      ShortcutDC, 0, 0, SRCINVERT))
216         {
217           goto fail;
218         }
219
220         /* Clean up, we're not goto'ing to 'fail' after this so we can be lazy and not set
221            handles to NULL */
222         SelectObject(TargetDC, OldTargetBitmap);
223         DeleteObject(TargetDC);
224         SelectObject(ShortcutDC, OldShortcutBitmap);
225         DeleteObject(ShortcutDC);
226         SelectObject(SourceDC, OldSourceBitmap);
227         DeleteObject(SourceDC);
228
229         /* Create the icon using the bitmaps prepared earlier */
230         TargetIcon = CreateIconIndirect(&TargetIconInfo);
231
232         /* CreateIconIndirect copies the bitmaps, so we can release our bitmaps now */
233         DeleteObject(TargetIconInfo.hbmColor);
234         DeleteObject(TargetIconInfo.hbmMask);
235
236         return TargetIcon;
237
238 fail:
239         /* Clean up scratch resources we created */
240         if (NULL != OldTargetBitmap) SelectObject(TargetDC, OldTargetBitmap);
241         if (NULL != TargetIconInfo.hbmColor) DeleteObject(TargetIconInfo.hbmColor);
242         if (NULL != TargetIconInfo.hbmMask) DeleteObject(TargetIconInfo.hbmMask);
243         if (NULL != TargetDC) DeleteObject(TargetDC);
244         if (NULL != OldShortcutBitmap) SelectObject(ShortcutDC, OldShortcutBitmap);
245         if (NULL != ShortcutDC) DeleteObject(ShortcutDC);
246         if (NULL != OldSourceBitmap) SelectObject(SourceDC, OldSourceBitmap);
247         if (NULL != SourceDC) DeleteObject(SourceDC);
248
249         return NULL;
250 }
251
252 /*****************************************************************************
253  * SIC_IconAppend                       [internal]
254  *
255  * NOTES
256  *  appends an icon pair to the end of the cache
257  */
258 static INT SIC_IconAppend (LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags)
259 {       LPSIC_ENTRY lpsice;
260         INT ret, index, index1;
261         WCHAR path[MAX_PATH];
262         TRACE("%s %i %p %p\n", debugstr_w(sSourceFile), dwSourceIndex, hSmallIcon ,hBigIcon);
263
264         lpsice = SHAlloc(sizeof(SIC_ENTRY));
265
266         GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
267         lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, (strlenW(path)+1)*sizeof(WCHAR) );
268         strcpyW( lpsice->sSourceFile, path );
269
270         lpsice->dwSourceIndex = dwSourceIndex;
271         lpsice->dwFlags = dwFlags;
272
273         EnterCriticalSection(&SHELL32_SicCS);
274
275         index = DPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
276         if ( INVALID_INDEX == index )
277         {
278           HeapFree(GetProcessHeap(), 0, lpsice->sSourceFile);
279           SHFree(lpsice);
280           ret = INVALID_INDEX;
281         }
282         else
283         {
284           index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
285           index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
286
287           if (index!=index1)
288           {
289             FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
290           }
291           lpsice->dwListIndex = index;
292           ret = lpsice->dwListIndex;
293         }
294
295         LeaveCriticalSection(&SHELL32_SicCS);
296         return ret;
297 }
298 /****************************************************************************
299  * SIC_LoadIcon                         [internal]
300  *
301  * NOTES
302  *  gets small/big icon by number from a file
303  */
304 static INT SIC_LoadIcon (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags)
305 {       HICON   hiconLarge=0;
306         HICON   hiconSmall=0;
307         HICON   hiconLargeShortcut;
308         HICON   hiconSmallShortcut;
309
310         PrivateExtractIconsW( sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, 0, 1, 0 );
311         PrivateExtractIconsW( sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, 0, 1, 0 );
312
313         if ( !hiconLarge ||  !hiconSmall)
314         {
315           WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex, debugstr_w(sSourceFile), hiconLarge, hiconSmall);
316           return -1;
317         }
318
319         if (0 != (dwFlags & GIL_FORSHORTCUT))
320         {
321           hiconLargeShortcut = SIC_OverlayShortcutImage(hiconLarge, TRUE);
322           hiconSmallShortcut = SIC_OverlayShortcutImage(hiconSmall, FALSE);
323           if (NULL != hiconLargeShortcut && NULL != hiconSmallShortcut)
324           {
325             hiconLarge = hiconLargeShortcut;
326             hiconSmall = hiconSmallShortcut;
327           }
328           else
329           {
330             WARN("Failed to create shortcut overlayed icons\n");
331             if (NULL != hiconLargeShortcut) DestroyIcon(hiconLargeShortcut);
332             if (NULL != hiconSmallShortcut) DestroyIcon(hiconSmallShortcut);
333             dwFlags &= ~ GIL_FORSHORTCUT;
334           }
335         }
336
337         return SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge, dwFlags);
338 }
339 /*****************************************************************************
340  * SIC_GetIconIndex                     [internal]
341  *
342  * Parameters
343  *      sSourceFile     [IN]    filename of file containing the icon
344  *      index           [IN]    index/resID (negated) in this file
345  *
346  * NOTES
347  *  look in the cache for a proper icon. if not available the icon is taken
348  *  from the file and cached
349  */
350 INT SIC_GetIconIndex (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags )
351 {
352         SIC_ENTRY sice;
353         INT ret, index = INVALID_INDEX;
354         WCHAR path[MAX_PATH];
355
356         TRACE("%s %i\n", debugstr_w(sSourceFile), dwSourceIndex);
357
358         GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
359         sice.sSourceFile = path;
360         sice.dwSourceIndex = dwSourceIndex;
361         sice.dwFlags = dwFlags;
362
363         EnterCriticalSection(&SHELL32_SicCS);
364
365         if (NULL != DPA_GetPtr (sic_hdpa, 0))
366         {
367           /* search linear from position 0*/
368           index = DPA_Search (sic_hdpa, &sice, 0, SIC_CompareEntries, 0, 0);
369         }
370
371         if ( INVALID_INDEX == index )
372         {
373           ret = SIC_LoadIcon (sSourceFile, dwSourceIndex, dwFlags);
374         }
375         else
376         {
377           TRACE("-- found\n");
378           ret = ((LPSIC_ENTRY)DPA_GetPtr(sic_hdpa, index))->dwListIndex;
379         }
380
381         LeaveCriticalSection(&SHELL32_SicCS);
382         return ret;
383 }
384 /*****************************************************************************
385  * SIC_Initialize                       [internal]
386  */
387 BOOL SIC_Initialize(void)
388 {
389         HICON           hSm, hLg;
390         int             cx_small, cy_small;
391         int             cx_large, cy_large;
392
393         cx_small = GetSystemMetrics(SM_CXSMICON);
394         cy_small = GetSystemMetrics(SM_CYSMICON);
395         cx_large = GetSystemMetrics(SM_CXICON);
396         cy_large = GetSystemMetrics(SM_CYICON);
397
398         TRACE("\n");
399
400         if (sic_hdpa)   /* already initialized?*/
401           return TRUE;
402
403         sic_hdpa = DPA_Create(16);
404
405         if (!sic_hdpa)
406         {
407           return(FALSE);
408         }
409
410         ShellSmallIconList = ImageList_Create(cx_small,cy_small,ILC_COLOR32|ILC_MASK,0,0x20);
411         ShellBigIconList = ImageList_Create(cx_large,cy_large,ILC_COLOR32|ILC_MASK,0,0x20);
412
413         ImageList_SetBkColor(ShellSmallIconList, CLR_NONE);
414         ImageList_SetBkColor(ShellBigIconList, CLR_NONE);
415
416         /* Load the document icon, which is used as the default if an icon isn't found. */
417         hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT),
418                                 IMAGE_ICON, cx_small, cy_small, LR_SHARED);
419         hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT),
420                                 IMAGE_ICON, cx_large, cy_large, LR_SHARED);
421
422         if (!hSm || !hLg) 
423         {
424           FIXME("Failed to load IDI_SHELL_DOCUMENT icon!\n");
425           return FALSE;
426         }
427
428         SIC_IconAppend (swShell32Name, IDI_SHELL_DOCUMENT-1, hSm, hLg, 0);
429         SIC_IconAppend (swShell32Name, -IDI_SHELL_DOCUMENT, hSm, hLg, 0);
430    
431         TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList);
432
433         return TRUE;
434 }
435 /*************************************************************************
436  * SIC_Destroy
437  *
438  * frees the cache
439  */
440 static INT CALLBACK sic_free( LPVOID ptr, LPVOID lparam )
441 {
442         HeapFree(GetProcessHeap(), 0, ((LPSIC_ENTRY)ptr)->sSourceFile);
443         SHFree(ptr);
444         return TRUE;
445 }
446
447 void SIC_Destroy(void)
448 {
449         TRACE("\n");
450
451         EnterCriticalSection(&SHELL32_SicCS);
452
453         if (sic_hdpa) DPA_DestroyCallback(sic_hdpa, sic_free, NULL );
454
455         sic_hdpa = NULL;
456         ImageList_Destroy(ShellSmallIconList);
457         ShellSmallIconList = 0;
458         ImageList_Destroy(ShellBigIconList);
459         ShellBigIconList = 0;
460
461         LeaveCriticalSection(&SHELL32_SicCS);
462         DeleteCriticalSection(&SHELL32_SicCS);
463 }
464
465 /*****************************************************************************
466  * SIC_LoadOverlayIcon                  [internal]
467  *
468  * Load a shell overlay icon and return its icon cache index.
469  */
470 static int SIC_LoadOverlayIcon(int icon_idx)
471 {
472         WCHAR buffer[1024], wszIdx[8];
473         HKEY hKeyShellIcons;
474         LPCWSTR iconPath;
475         int iconIdx;
476
477         static const WCHAR wszShellIcons[] = {
478             'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
479             'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
480             'E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','I','c','o','n','s',0
481         }; 
482         static const WCHAR wszNumFmt[] = {'%','d',0};
483
484         iconPath = swShell32Name;       /* default: load icon from shell32.dll */
485         iconIdx = icon_idx;
486
487         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszShellIcons, 0, KEY_READ, &hKeyShellIcons) == ERROR_SUCCESS)
488         {
489             DWORD count = sizeof(buffer);
490
491             sprintfW(wszIdx, wszNumFmt, icon_idx);
492
493             /* read icon path and index */
494             if (RegQueryValueExW(hKeyShellIcons, wszIdx, NULL, NULL, (LPBYTE)buffer, &count) == ERROR_SUCCESS)
495             {
496                 LPWSTR p = strchrW(buffer, ',');
497
498                 if (p)
499                     *p++ = 0;
500
501                 iconPath = buffer;
502                 iconIdx = atoiW(p);
503             }
504
505             RegCloseKey(hKeyShellIcons);
506         }
507
508         return SIC_LoadIcon(iconPath, iconIdx, 0);
509 }
510
511 /*************************************************************************
512  * Shell_GetImageList                   [SHELL32.71]
513  *
514  * PARAMETERS
515  *  imglist[1|2] [OUT] pointer which receives imagelist handles
516  *
517  */
518 BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList)
519 {       TRACE("(%p,%p)\n",lpBigList,lpSmallList);
520         if (lpBigList)
521         { *lpBigList = ShellBigIconList;
522         }
523         if (lpSmallList)
524         { *lpSmallList = ShellSmallIconList;
525         }
526
527         return TRUE;
528 }
529 /*************************************************************************
530  * PidlToSicIndex                       [INTERNAL]
531  *
532  * PARAMETERS
533  *      sh      [IN]    IShellFolder
534  *      pidl    [IN]
535  *      bBigIcon [IN]
536  *      uFlags  [IN]    GIL_*
537  *      pIndex  [OUT]   index within the SIC
538  *
539  */
540 BOOL PidlToSicIndex (
541         IShellFolder * sh,
542         LPCITEMIDLIST pidl,
543         BOOL bBigIcon,
544         UINT uFlags,
545         int * pIndex)
546 {
547         IExtractIconW   *ei;
548         WCHAR           szIconFile[MAX_PATH];   /* file containing the icon */
549         INT             iSourceIndex;           /* index or resID(negated) in this file */
550         BOOL            ret = FALSE;
551         UINT            dwFlags = 0;
552         int             iShortcutDefaultIndex = INVALID_INDEX;
553
554         TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
555
556         if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconW, 0, (void **)&ei)))
557         {
558           if (SUCCEEDED(IExtractIconW_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
559           {
560             *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex, uFlags);
561             ret = TRUE;
562           }
563           IExtractIconW_Release(ei);
564         }
565
566         if (INVALID_INDEX == *pIndex)   /* default icon when failed */
567         {
568           if (0 == (uFlags & GIL_FORSHORTCUT))
569           {
570             *pIndex = 0;
571           }
572           else
573           {
574             if (INVALID_INDEX == iShortcutDefaultIndex)
575             {
576               iShortcutDefaultIndex = SIC_LoadIcon(swShell32Name, 0, GIL_FORSHORTCUT);
577             }
578             *pIndex = (INVALID_INDEX != iShortcutDefaultIndex ? iShortcutDefaultIndex : 0);
579           }
580         }
581
582         return ret;
583
584 }
585
586 /*************************************************************************
587  * SHMapPIDLToSystemImageListIndex      [SHELL32.77]
588  *
589  * PARAMETERS
590  *      sh      [IN]            pointer to an instance of IShellFolder
591  *      pidl    [IN]
592  *      pIndex  [OUT][OPTIONAL] SIC index for big icon
593  *
594  */
595 int WINAPI SHMapPIDLToSystemImageListIndex(
596         IShellFolder *sh,
597         LPCITEMIDLIST pidl,
598         int *pIndex)
599 {
600         int Index;
601         UINT uGilFlags = 0;
602
603         TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
604         pdump(pidl);
605
606         if (SHELL_IsShortcut(pidl))
607             uGilFlags |= GIL_FORSHORTCUT;
608
609         if (pIndex)
610             if (!PidlToSicIndex ( sh, pidl, 1, uGilFlags, pIndex))
611                 *pIndex = -1;
612
613         if (!PidlToSicIndex ( sh, pidl, 0, uGilFlags, &Index))
614             return -1;
615
616         return Index;
617 }
618
619 /*************************************************************************
620  * SHMapIDListToImageListIndexAsync  [SHELL32.148]
621  */
622 HRESULT WINAPI SHMapIDListToImageListIndexAsync(IUnknown *pts, IShellFolder *psf,
623                                                 LPCITEMIDLIST pidl, UINT flags,
624                                                 void *pfn, void *pvData, void *pvHint,
625                                                 int *piIndex, int *piIndexSel)
626 {
627     FIXME("(%p, %p, %p, 0x%08x, %p, %p, %p, %p, %p)\n",
628             pts, psf, pidl, flags, pfn, pvData, pvHint, piIndex, piIndexSel);
629     return E_FAIL;
630 }
631
632 /*************************************************************************
633  * Shell_GetCachedImageIndex            [SHELL32.72]
634  *
635  */
636 static INT Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc)
637 {
638         INT ret, len;
639         LPWSTR szTemp;
640
641         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
642
643         len = MultiByteToWideChar( CP_ACP, 0, szPath, -1, NULL, 0 );
644         szTemp = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
645         MultiByteToWideChar( CP_ACP, 0, szPath, -1, szTemp, len );
646
647         ret = SIC_GetIconIndex( szTemp, nIndex, 0 );
648
649         HeapFree( GetProcessHeap(), 0, szTemp );
650
651         return ret;
652 }
653
654 static INT Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc)
655 {
656         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
657
658         return SIC_GetIconIndex(szPath, nIndex, 0);
659 }
660
661 INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
662 {       if( SHELL_OsIsUnicode())
663           return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc);
664         return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc);
665 }
666
667 /*************************************************************************
668  * ExtractIconExW                       [SHELL32.@]
669  * RETURNS
670  *  0 no icon found
671  *  -1 file is not valid
672  *  or number of icons extracted
673  */
674 UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
675 {
676         TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons);
677
678         return PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
679 }
680
681 /*************************************************************************
682  * ExtractIconExA                       [SHELL32.@]
683  */
684 UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
685 {
686     UINT ret = 0;
687     INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
688     LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
689
690     TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
691
692     if (lpwstrFile)
693     {
694         MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
695         ret = ExtractIconExW(lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
696         HeapFree(GetProcessHeap(), 0, lpwstrFile);
697     }
698     return ret;
699 }
700
701 /*************************************************************************
702  *                              ExtractAssociatedIconA (SHELL32.@)
703  *
704  * Return icon for given file (either from file itself or from associated
705  * executable) and patch parameters if needed.
706  */
707 HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
708 {       
709     HICON hIcon = NULL;
710     INT len = MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, NULL, 0);
711     /* Note that we need to allocate MAX_PATH, since we are supposed to fill
712      * the correct executable if there is no icon in lpIconPath directly.
713      * lpIconPath itself is supposed to be large enough, so make sure lpIconPathW
714      * is large enough too. Yes, I am puking too.
715      */
716     LPWSTR lpIconPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
717
718     TRACE("%p %s %p\n", hInst, debugstr_a(lpIconPath), lpiIcon);
719
720     if (lpIconPathW)
721     {
722         MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, lpIconPathW, len);
723         hIcon = ExtractAssociatedIconW(hInst, lpIconPathW, lpiIcon);
724         WideCharToMultiByte(CP_ACP, 0, lpIconPathW, -1, lpIconPath, MAX_PATH , NULL, NULL);
725         HeapFree(GetProcessHeap(), 0, lpIconPathW);
726     }
727     return hIcon;
728 }
729
730 /*************************************************************************
731  *                              ExtractAssociatedIconW (SHELL32.@)
732  *
733  * Return icon for given file (either from file itself or from associated
734  * executable) and patch parameters if needed.
735  */
736 HICON WINAPI ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIcon)
737 {
738     HICON hIcon = NULL;
739     WORD wDummyIcon = 0;
740
741     TRACE("%p %s %p\n", hInst, debugstr_w(lpIconPath), lpiIcon);
742
743     if(lpiIcon == NULL)
744         lpiIcon = &wDummyIcon;
745
746     hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
747
748     if( hIcon < (HICON)2 )
749     { if( hIcon == (HICON)1 ) /* no icons found in given file */
750       { WCHAR tempPath[MAX_PATH];
751         HINSTANCE uRet = FindExecutableW(lpIconPath,NULL,tempPath);
752
753         if( uRet > (HINSTANCE)32 && tempPath[0] )
754         { lstrcpyW(lpIconPath,tempPath);
755           hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
756           if( hIcon > (HICON)2 )
757             return hIcon;
758         }
759       }
760
761       if( hIcon == (HICON)1 )
762         *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
763       else
764         *lpiIcon = 6;   /* generic icon - found nothing */
765
766       if (GetModuleFileNameW(hInst, lpIconPath, MAX_PATH))
767         hIcon = LoadIconW(hInst, MAKEINTRESOURCEW(*lpiIcon));
768     }
769     return hIcon;
770 }
771
772 /*************************************************************************
773  *                              ExtractAssociatedIconExW (SHELL32.@)
774  *
775  * Return icon for given file (either from file itself or from associated
776  * executable) and patch parameters if needed.
777  */
778 HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
779 {
780   FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId);
781   return 0;
782 }
783
784 /*************************************************************************
785  *                              ExtractAssociatedIconExA (SHELL32.@)
786  *
787  * Return icon for given file (either from file itself or from associated
788  * executable) and patch parameters if needed.
789  */
790 HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
791 {
792   HICON ret;
793   INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 );
794   LPWSTR lpwstrFile = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
795
796   TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId);
797
798   MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len );
799   ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId);
800   HeapFree(GetProcessHeap(), 0, lpwstrFile);
801   return ret;
802 }
803
804
805 /****************************************************************************
806  * SHDefExtractIconW            [SHELL32.@]
807  */
808 HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags,
809                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
810 {
811         UINT ret;
812         HICON hIcons[2];
813         WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
814
815         ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR);
816         /* FIXME: deal with uFlags parameter which contains GIL_ flags */
817         if (ret == 0xFFFFFFFF)
818           return E_FAIL;
819         if (ret > 0) {
820           if (phiconLarge)
821             *phiconLarge = hIcons[0];
822           else
823             DestroyIcon(hIcons[0]);
824           if (phiconSmall)
825             *phiconSmall = hIcons[1];
826           else
827             DestroyIcon(hIcons[1]);
828           return S_OK;
829         }
830         return S_FALSE;
831 }
832
833 /****************************************************************************
834  * SHDefExtractIconA            [SHELL32.@]
835  */
836 HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags,
837                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
838 {
839   HRESULT ret;
840   INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0);
841   LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
842
843   TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
844
845   MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len);
846   ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
847   HeapFree(GetProcessHeap(), 0, lpwstrFile);
848   return ret;
849 }
850
851
852 /****************************************************************************
853  * SHGetIconOverlayIndexA    [SHELL32.@]
854  *
855  * Returns the index of the overlay icon in the system image list.
856  */
857 INT WINAPI SHGetIconOverlayIndexA(LPCSTR pszIconPath, INT iIconIndex)
858 {
859   FIXME("%s, %d\n", debugstr_a(pszIconPath), iIconIndex);
860
861   return -1;
862 }
863
864 /****************************************************************************
865  * SHGetIconOverlayIndexW    [SHELL32.@]
866  *
867  * Returns the index of the overlay icon in the system image list.
868  */
869 INT WINAPI SHGetIconOverlayIndexW(LPCWSTR pszIconPath, INT iIconIndex)
870 {
871   FIXME("%s, %d\n", debugstr_w(pszIconPath), iIconIndex);
872
873   return -1;
874 }