2 * shell icon cache (SIC)
4 * Copyright 1998, 1999 Juergen Schmied
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.
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.
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
22 #include "wine/port.h"
26 #include <sys/types.h>
38 #include "wine/debug.h"
43 #include "shell32_main.h"
44 #include "undocshell.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
49 /********************** THE ICON CACHE ********************************/
51 #define INVALID_INDEX -1
55 LPWSTR sSourceFile
; /* file (not path!) containing the icon */
56 DWORD dwSourceIndex
; /* index within the file, if it is a resoure ID it will be negated */
57 DWORD dwListIndex
; /* index within the iconlist */
58 DWORD dwFlags
; /* GIL_* flags */
60 } SIC_ENTRY
, * LPSIC_ENTRY
;
62 static HDPA sic_hdpa
= 0;
64 static CRITICAL_SECTION SHELL32_SicCS
;
65 static CRITICAL_SECTION_DEBUG critsect_debug
=
68 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
69 0, 0, { (DWORD_PTR
)(__FILE__
": SHELL32_SicCS") }
71 static CRITICAL_SECTION SHELL32_SicCS
= { &critsect_debug
, -1, 0, 0, 0, 0 };
73 /*****************************************************************************
77 * Callback for DPA_Search
79 static INT CALLBACK
SIC_CompareEntries( LPVOID p1
, LPVOID p2
, LPARAM lparam
)
80 { LPSIC_ENTRY e1
= (LPSIC_ENTRY
)p1
, e2
= (LPSIC_ENTRY
)p2
;
82 TRACE("%p %p %8lx\n", p1
, p2
, lparam
);
84 /* Icons in the cache are keyed by the name of the file they are
85 * loaded from, their resource index and the fact if they have a shortcut
86 * icon overlay or not.
88 if (e1
->dwSourceIndex
!= e2
->dwSourceIndex
|| /* first the faster one */
89 (e1
->dwFlags
& GIL_FORSHORTCUT
) != (e2
->dwFlags
& GIL_FORSHORTCUT
))
92 if (strcmpiW(e1
->sSourceFile
,e2
->sSourceFile
))
98 /* declare SIC_LoadOverlayIcon() */
99 static int SIC_LoadOverlayIcon(int icon_idx
);
101 /*****************************************************************************
102 * SIC_OverlayShortcutImage [internal]
105 * Creates a new icon as a copy of the passed-in icon, overlayed with a
108 static HICON
SIC_OverlayShortcutImage(HICON SourceIcon
, BOOL large
)
109 { ICONINFO SourceIconInfo
, ShortcutIconInfo
, TargetIconInfo
;
110 HICON ShortcutIcon
, TargetIcon
;
111 BITMAP SourceBitmapInfo
, ShortcutBitmapInfo
;
116 HBITMAP OldSourceBitmap
= NULL
,
117 OldShortcutBitmap
= NULL
,
118 OldTargetBitmap
= NULL
;
120 static int s_imgListIdx
= -1;
122 /* Get information about the source icon and shortcut overlay */
123 if (! GetIconInfo(SourceIcon
, &SourceIconInfo
)
124 || 0 == GetObjectW(SourceIconInfo
.hbmColor
, sizeof(BITMAP
), &SourceBitmapInfo
))
129 /* search for the shortcut icon only once */
130 if (s_imgListIdx
== -1)
131 s_imgListIdx
= SIC_LoadOverlayIcon(- IDI_SHELL_SHORTCUT
);
132 /* FIXME should use icon index 29 instead of the
133 resource id, but not all icons are present yet
134 so we can't use icon indices */
136 if (s_imgListIdx
!= -1)
139 ShortcutIcon
= ImageList_GetIcon(ShellBigIconList
, s_imgListIdx
, ILD_TRANSPARENT
);
141 ShortcutIcon
= ImageList_GetIcon(ShellSmallIconList
, s_imgListIdx
, ILD_TRANSPARENT
);
145 if (NULL
== ShortcutIcon
146 || ! GetIconInfo(ShortcutIcon
, &ShortcutIconInfo
)
147 || 0 == GetObjectW(ShortcutIconInfo
.hbmColor
, sizeof(BITMAP
), &ShortcutBitmapInfo
))
152 TargetIconInfo
= SourceIconInfo
;
153 TargetIconInfo
.hbmMask
= NULL
;
154 TargetIconInfo
.hbmColor
= NULL
;
156 /* Setup the source, shortcut and target masks */
157 SourceDC
= CreateCompatibleDC(NULL
);
158 if (NULL
== SourceDC
) goto fail
;
159 OldSourceBitmap
= SelectObject(SourceDC
, SourceIconInfo
.hbmMask
);
160 if (NULL
== OldSourceBitmap
) goto fail
;
162 ShortcutDC
= CreateCompatibleDC(NULL
);
163 if (NULL
== ShortcutDC
) goto fail
;
164 OldShortcutBitmap
= SelectObject(ShortcutDC
, ShortcutIconInfo
.hbmMask
);
165 if (NULL
== OldShortcutBitmap
) goto fail
;
167 TargetDC
= CreateCompatibleDC(NULL
);
168 if (NULL
== TargetDC
) goto fail
;
169 TargetIconInfo
.hbmMask
= CreateCompatibleBitmap(TargetDC
, SourceBitmapInfo
.bmWidth
,
170 SourceBitmapInfo
.bmHeight
);
171 if (NULL
== TargetIconInfo
.hbmMask
) goto fail
;
172 ScreenDC
= GetDC(NULL
);
173 if (NULL
== ScreenDC
) goto fail
;
174 TargetIconInfo
.hbmColor
= CreateCompatibleBitmap(ScreenDC
, SourceBitmapInfo
.bmWidth
,
175 SourceBitmapInfo
.bmHeight
);
176 ReleaseDC(NULL
, ScreenDC
);
177 if (NULL
== TargetIconInfo
.hbmColor
) goto fail
;
178 OldTargetBitmap
= SelectObject(TargetDC
, TargetIconInfo
.hbmMask
);
179 if (NULL
== OldTargetBitmap
) goto fail
;
181 /* Create the target mask by ANDing the source and shortcut masks */
182 if (! BitBlt(TargetDC
, 0, 0, SourceBitmapInfo
.bmWidth
, SourceBitmapInfo
.bmHeight
,
183 SourceDC
, 0, 0, SRCCOPY
) ||
184 ! BitBlt(TargetDC
, 0, SourceBitmapInfo
.bmHeight
- ShortcutBitmapInfo
.bmHeight
,
185 ShortcutBitmapInfo
.bmWidth
, ShortcutBitmapInfo
.bmHeight
,
186 ShortcutDC
, 0, 0, SRCAND
))
191 /* Setup the source and target xor bitmap */
192 if (NULL
== SelectObject(SourceDC
, SourceIconInfo
.hbmColor
) ||
193 NULL
== SelectObject(TargetDC
, TargetIconInfo
.hbmColor
))
198 /* Copy the source xor bitmap to the target and clear out part of it by using
200 if (! BitBlt(TargetDC
, 0, 0, SourceBitmapInfo
.bmWidth
, SourceBitmapInfo
.bmHeight
,
201 SourceDC
, 0, 0, SRCCOPY
) ||
202 ! BitBlt(TargetDC
, 0, SourceBitmapInfo
.bmHeight
- ShortcutBitmapInfo
.bmHeight
,
203 ShortcutBitmapInfo
.bmWidth
, ShortcutBitmapInfo
.bmHeight
,
204 ShortcutDC
, 0, 0, SRCAND
))
209 if (NULL
== SelectObject(ShortcutDC
, ShortcutIconInfo
.hbmColor
)) goto fail
;
211 /* Now put in the shortcut xor mask */
212 if (! BitBlt(TargetDC
, 0, SourceBitmapInfo
.bmHeight
- ShortcutBitmapInfo
.bmHeight
,
213 ShortcutBitmapInfo
.bmWidth
, ShortcutBitmapInfo
.bmHeight
,
214 ShortcutDC
, 0, 0, SRCINVERT
))
219 /* Clean up, we're not goto'ing to 'fail' after this so we can be lazy and not set
221 SelectObject(TargetDC
, OldTargetBitmap
);
222 DeleteObject(TargetDC
);
223 SelectObject(ShortcutDC
, OldShortcutBitmap
);
224 DeleteObject(ShortcutDC
);
225 SelectObject(SourceDC
, OldSourceBitmap
);
226 DeleteObject(SourceDC
);
228 /* Create the icon using the bitmaps prepared earlier */
229 TargetIcon
= CreateIconIndirect(&TargetIconInfo
);
231 /* CreateIconIndirect copies the bitmaps, so we can release our bitmaps now */
232 DeleteObject(TargetIconInfo
.hbmColor
);
233 DeleteObject(TargetIconInfo
.hbmMask
);
238 /* Clean up scratch resources we created */
239 if (NULL
!= OldTargetBitmap
) SelectObject(TargetDC
, OldTargetBitmap
);
240 if (NULL
!= TargetIconInfo
.hbmColor
) DeleteObject(TargetIconInfo
.hbmColor
);
241 if (NULL
!= TargetIconInfo
.hbmMask
) DeleteObject(TargetIconInfo
.hbmMask
);
242 if (NULL
!= TargetDC
) DeleteObject(TargetDC
);
243 if (NULL
!= OldShortcutBitmap
) SelectObject(ShortcutDC
, OldShortcutBitmap
);
244 if (NULL
!= ShortcutDC
) DeleteObject(ShortcutDC
);
245 if (NULL
!= OldSourceBitmap
) SelectObject(SourceDC
, OldSourceBitmap
);
246 if (NULL
!= SourceDC
) DeleteObject(SourceDC
);
251 /*****************************************************************************
252 * SIC_IconAppend [internal]
255 * appends an icon pair to the end of the cache
257 static INT
SIC_IconAppend (LPCWSTR sSourceFile
, INT dwSourceIndex
, HICON hSmallIcon
, HICON hBigIcon
, DWORD dwFlags
)
258 { LPSIC_ENTRY lpsice
;
259 INT ret
, index
, index1
;
260 WCHAR path
[MAX_PATH
];
261 TRACE("%s %i %p %p\n", debugstr_w(sSourceFile
), dwSourceIndex
, hSmallIcon
,hBigIcon
);
263 lpsice
= (LPSIC_ENTRY
) SHAlloc (sizeof (SIC_ENTRY
));
265 GetFullPathNameW(sSourceFile
, MAX_PATH
, path
, NULL
);
266 lpsice
->sSourceFile
= HeapAlloc( GetProcessHeap(), 0, (strlenW(path
)+1)*sizeof(WCHAR
) );
267 strcpyW( lpsice
->sSourceFile
, path
);
269 lpsice
->dwSourceIndex
= dwSourceIndex
;
270 lpsice
->dwFlags
= dwFlags
;
272 EnterCriticalSection(&SHELL32_SicCS
);
274 index
= DPA_InsertPtr(sic_hdpa
, 0x7fff, lpsice
);
275 if ( INVALID_INDEX
== index
)
277 HeapFree(GetProcessHeap(), 0, lpsice
->sSourceFile
);
283 index
= ImageList_AddIcon (ShellSmallIconList
, hSmallIcon
);
284 index1
= ImageList_AddIcon (ShellBigIconList
, hBigIcon
);
288 FIXME("iconlists out of sync 0x%x 0x%x\n", index
, index1
);
290 lpsice
->dwListIndex
= index
;
291 ret
= lpsice
->dwListIndex
;
294 LeaveCriticalSection(&SHELL32_SicCS
);
297 /****************************************************************************
298 * SIC_LoadIcon [internal]
301 * gets small/big icon by number from a file
303 static INT
SIC_LoadIcon (LPCWSTR sSourceFile
, INT dwSourceIndex
, DWORD dwFlags
)
304 { HICON hiconLarge
=0;
306 HICON hiconLargeShortcut
;
307 HICON hiconSmallShortcut
;
309 #if defined(__CYGWIN__) || defined (__MINGW32__) || defined(_MSC_VER)
310 static UINT (WINAPI
*PrivateExtractIconExW
)(LPCWSTR
,int,HICON
*,HICON
*,UINT
) = NULL
;
312 if (!PrivateExtractIconExW
) {
313 HMODULE hUser32
= GetModuleHandleA("user32");
314 PrivateExtractIconExW
= (UINT(WINAPI
*)(LPCWSTR
,int,HICON
*,HICON
*,UINT
)) GetProcAddress(hUser32
, "PrivateExtractIconExW");
317 if (PrivateExtractIconExW
)
318 PrivateExtractIconExW(sSourceFile
, dwSourceIndex
, &hiconLarge
, &hiconSmall
, 1);
322 PrivateExtractIconsW(sSourceFile
, dwSourceIndex
, 32, 32, &hiconLarge
, NULL
, 1, 0);
323 PrivateExtractIconsW(sSourceFile
, dwSourceIndex
, 16, 16, &hiconSmall
, NULL
, 1, 0);
326 if ( !hiconLarge
|| !hiconSmall
)
328 WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex
, debugstr_w(sSourceFile
), hiconLarge
, hiconSmall
);
332 if (0 != (dwFlags
& GIL_FORSHORTCUT
))
334 hiconLargeShortcut
= SIC_OverlayShortcutImage(hiconLarge
, TRUE
);
335 hiconSmallShortcut
= SIC_OverlayShortcutImage(hiconSmall
, FALSE
);
336 if (NULL
!= hiconLargeShortcut
&& NULL
!= hiconSmallShortcut
)
338 hiconLarge
= hiconLargeShortcut
;
339 hiconSmall
= hiconSmallShortcut
;
343 WARN("Failed to create shortcut overlayed icons\n");
344 if (NULL
!= hiconLargeShortcut
) DestroyIcon(hiconLargeShortcut
);
345 if (NULL
!= hiconSmallShortcut
) DestroyIcon(hiconSmallShortcut
);
346 dwFlags
&= ~ GIL_FORSHORTCUT
;
350 return SIC_IconAppend (sSourceFile
, dwSourceIndex
, hiconSmall
, hiconLarge
, dwFlags
);
352 /*****************************************************************************
353 * SIC_GetIconIndex [internal]
356 * sSourceFile [IN] filename of file containing the icon
357 * index [IN] index/resID (negated) in this file
360 * look in the cache for a proper icon. if not available the icon is taken
361 * from the file and cached
363 INT
SIC_GetIconIndex (LPCWSTR sSourceFile
, INT dwSourceIndex
, DWORD dwFlags
)
366 INT ret
, index
= INVALID_INDEX
;
367 WCHAR path
[MAX_PATH
];
369 TRACE("%s %i\n", debugstr_w(sSourceFile
), dwSourceIndex
);
371 GetFullPathNameW(sSourceFile
, MAX_PATH
, path
, NULL
);
372 sice
.sSourceFile
= path
;
373 sice
.dwSourceIndex
= dwSourceIndex
;
374 sice
.dwFlags
= dwFlags
;
376 EnterCriticalSection(&SHELL32_SicCS
);
378 if (NULL
!= DPA_GetPtr (sic_hdpa
, 0))
380 /* search linear from position 0*/
381 index
= DPA_Search (sic_hdpa
, &sice
, 0, SIC_CompareEntries
, 0, 0);
384 if ( INVALID_INDEX
== index
)
386 ret
= SIC_LoadIcon (sSourceFile
, dwSourceIndex
, dwFlags
);
391 ret
= ((LPSIC_ENTRY
)DPA_GetPtr(sic_hdpa
, index
))->dwListIndex
;
394 LeaveCriticalSection(&SHELL32_SicCS
);
397 /*****************************************************************************
398 * SIC_Initialize [internal]
400 BOOL
SIC_Initialize(void)
403 int cx_small
, cy_small
;
404 int cx_large
, cy_large
;
406 cx_small
= GetSystemMetrics(SM_CXSMICON
);
407 cy_small
= GetSystemMetrics(SM_CYSMICON
);
408 cx_large
= GetSystemMetrics(SM_CXICON
);
409 cy_large
= GetSystemMetrics(SM_CYICON
);
413 if (sic_hdpa
) /* already initialized?*/
416 sic_hdpa
= DPA_Create(16);
423 ShellSmallIconList
= ImageList_Create(cx_small
,cy_small
,ILC_COLOR32
|ILC_MASK
,0,0x20);
424 ShellBigIconList
= ImageList_Create(cx_large
,cy_large
,ILC_COLOR32
|ILC_MASK
,0,0x20);
426 ImageList_SetBkColor(ShellSmallIconList
, CLR_NONE
);
427 ImageList_SetBkColor(ShellBigIconList
, CLR_NONE
);
429 /* Load the document icon, which is used as the default if an icon isn't found. */
430 hSm
= (HICON
)LoadImageA(shell32_hInstance
, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT
),
431 IMAGE_ICON
, cx_small
, cy_small
, LR_SHARED
);
432 hLg
= (HICON
)LoadImageA(shell32_hInstance
, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT
),
433 IMAGE_ICON
, cx_large
, cy_large
, LR_SHARED
);
437 FIXME("Failed to load IDI_SHELL_DOCUMENT icon!\n");
441 SIC_IconAppend (swShell32Name
, IDI_SHELL_DOCUMENT
-1, hSm
, hLg
, 0);
442 SIC_IconAppend (swShell32Name
, -IDI_SHELL_DOCUMENT
, hSm
, hLg
, 0);
444 TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList
, ShellBigIconList
);
448 /*************************************************************************
453 static INT CALLBACK
sic_free( LPVOID ptr
, LPVOID lparam
)
455 HeapFree(GetProcessHeap(), 0, ((LPSIC_ENTRY
)ptr
)->sSourceFile
);
460 void SIC_Destroy(void)
464 EnterCriticalSection(&SHELL32_SicCS
);
466 if (sic_hdpa
) DPA_DestroyCallback(sic_hdpa
, sic_free
, NULL
);
469 ImageList_Destroy(ShellSmallIconList
);
470 ShellSmallIconList
= 0;
471 ImageList_Destroy(ShellBigIconList
);
472 ShellBigIconList
= 0;
474 LeaveCriticalSection(&SHELL32_SicCS
);
475 //DeleteCriticalSection(&SHELL32_SicCS); //static
478 /*****************************************************************************
479 * SIC_LoadOverlayIcon [internal]
481 * Load a shell overlay icon and return its icon cache index.
483 static int SIC_LoadOverlayIcon(int icon_idx
)
485 WCHAR buffer
[1024], wszIdx
[8];
490 static const WCHAR wszShellIcons
[] = {
491 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
492 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
493 'E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','I','c','o','n','s',0
495 static const WCHAR wszNumFmt
[] = {'%','d',0};
497 iconPath
= swShell32Name
; /* default: load icon from shell32.dll */
500 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE
, wszShellIcons
, 0, KEY_READ
, &hKeyShellIcons
) == ERROR_SUCCESS
)
502 DWORD count
= sizeof(buffer
);
504 sprintfW(wszIdx
, wszNumFmt
, icon_idx
);
506 /* read icon path and index */
507 if (RegQueryValueExW(hKeyShellIcons
, wszIdx
, NULL
, NULL
, (LPBYTE
)buffer
, &count
) == ERROR_SUCCESS
)
509 LPWSTR p
= strchrW(buffer
, ',');
518 RegCloseKey(hKeyShellIcons
);
521 return SIC_LoadIcon(iconPath
, iconIdx
, 0);
524 /*************************************************************************
525 * Shell_GetImageList [SHELL32.71]
528 * imglist[1|2] [OUT] pointer which receives imagelist handles
531 BOOL WINAPI
Shell_GetImageList(HIMAGELIST
* lpBigList
, HIMAGELIST
* lpSmallList
)
532 { TRACE("(%p,%p)\n",lpBigList
,lpSmallList
);
534 { *lpBigList
= ShellBigIconList
;
537 { *lpSmallList
= ShellSmallIconList
;
542 /*************************************************************************
543 * PidlToSicIndex [INTERNAL]
546 * sh [IN] IShellFolder
550 * pIndex [OUT] index within the SIC
553 BOOL
PidlToSicIndex (
561 WCHAR szIconFile
[MAX_PATH
]; /* file containing the icon */
562 INT iSourceIndex
; /* index or resID(negated) in this file */
565 int iShortcutDefaultIndex
= INVALID_INDEX
;
567 TRACE("sf=%p pidl=%p %s\n", sh
, pidl
, bBigIcon
?"Big":"Small");
569 if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh
, 0, 1, &pidl
, &IID_IExtractIconW
, 0, (void **)&ei
)))
571 if (SUCCEEDED(IExtractIconW_GetIconLocation(ei
, uFlags
, szIconFile
, MAX_PATH
, &iSourceIndex
, &dwFlags
)))
573 *pIndex
= SIC_GetIconIndex(szIconFile
, iSourceIndex
, uFlags
);
576 IExtractIconW_Release(ei
);
579 if (INVALID_INDEX
== *pIndex
) /* default icon when failed */
581 if (0 == (uFlags
& GIL_FORSHORTCUT
))
587 if (INVALID_INDEX
== iShortcutDefaultIndex
)
589 iShortcutDefaultIndex
= SIC_LoadIcon(swShell32Name
, 0, GIL_FORSHORTCUT
);
591 *pIndex
= (INVALID_INDEX
!= iShortcutDefaultIndex
? iShortcutDefaultIndex
: 0);
599 /*************************************************************************
600 * SHMapPIDLToSystemImageListIndex [SHELL32.77]
603 * sh [IN] pointer to an instance of IShellFolder
605 * pIndex [OUT][OPTIONAL] SIC index for big icon
608 int WINAPI
SHMapPIDLToSystemImageListIndex(
616 TRACE("(SF=%p,pidl=%p,%p)\n",sh
,pidl
,pIndex
);
619 if (SHELL_IsShortcut(pidl
))
620 uGilFlags
|= GIL_FORSHORTCUT
;
623 if (!PidlToSicIndex ( sh
, pidl
, 1, uGilFlags
, pIndex
))
626 if (!PidlToSicIndex ( sh
, pidl
, 0, uGilFlags
, &Index
))
632 /*************************************************************************
633 * SHMapIDListToImageListIndexAsync [SHELL32.148]
635 HRESULT WINAPI
SHMapIDListToImageListIndexAsync(IUnknown
*pts
, IShellFolder
*psf
,
636 LPCITEMIDLIST pidl
, UINT flags
,
637 void *pfn
, void *pvData
, void *pvHint
,
638 int *piIndex
, int *piIndexSel
)
640 FIXME("(%p, %p, %p, 0x%08x, %p, %p, %p, %p, %p)\n",
641 pts
, psf
, pidl
, flags
, pfn
, pvData
, pvHint
, piIndex
, piIndexSel
);
645 /*************************************************************************
646 * Shell_GetCachedImageIndex [SHELL32.72]
649 INT WINAPI
Shell_GetCachedImageIndexA(LPCSTR szPath
, INT nIndex
, BOOL bSimulateDoc
)
654 WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath
), nIndex
, bSimulateDoc
);
656 len
= MultiByteToWideChar( CP_ACP
, 0, szPath
, -1, NULL
, 0 );
657 szTemp
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
658 MultiByteToWideChar( CP_ACP
, 0, szPath
, -1, szTemp
, len
);
660 ret
= SIC_GetIconIndex( szTemp
, nIndex
, 0 );
662 HeapFree( GetProcessHeap(), 0, szTemp
);
667 INT WINAPI
Shell_GetCachedImageIndexW(LPCWSTR szPath
, INT nIndex
, BOOL bSimulateDoc
)
669 WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath
), nIndex
, bSimulateDoc
);
671 return SIC_GetIconIndex(szPath
, nIndex
, 0);
674 INT WINAPI
Shell_GetCachedImageIndexAW(LPCVOID szPath
, INT nIndex
, BOOL bSimulateDoc
)
675 { if( SHELL_OsIsUnicode())
676 return Shell_GetCachedImageIndexW(szPath
, nIndex
, bSimulateDoc
);
677 return Shell_GetCachedImageIndexA(szPath
, nIndex
, bSimulateDoc
);
680 /*************************************************************************
681 * ExtractIconExW [SHELL32.@]
684 * -1 file is not valid
685 * or number of icons extracted
687 UINT WINAPI
ExtractIconExW(LPCWSTR lpszFile
, INT nIconIndex
, HICON
* phiconLarge
, HICON
* phiconSmall
, UINT nIcons
)
689 /* get entry point of undocumented function PrivateExtractIconExW() in user32 */
690 #if defined(__CYGWIN__) || defined (__MINGW32__) || defined(_MSC_VER)
691 static UINT (WINAPI
*PrivateExtractIconExW
)(LPCWSTR
,int,HICON
*,HICON
*,UINT
) = NULL
;
693 if (!PrivateExtractIconExW
) {
694 HMODULE hUser32
= GetModuleHandleA("user32");
695 PrivateExtractIconExW
= (UINT(WINAPI
*)(LPCWSTR
,int,HICON
*,HICON
*,UINT
)) GetProcAddress(hUser32
, "PrivateExtractIconExW");
697 if (!PrivateExtractIconExW
)
702 TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile
), nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
704 return PrivateExtractIconExW(lpszFile
, nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
707 /*************************************************************************
708 * ExtractIconExA [SHELL32.@]
710 UINT WINAPI
ExtractIconExA(LPCSTR lpszFile
, INT nIconIndex
, HICON
* phiconLarge
, HICON
* phiconSmall
, UINT nIcons
)
713 INT len
= MultiByteToWideChar(CP_ACP
, 0, lpszFile
, -1, NULL
, 0);
714 LPWSTR lpwstrFile
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
716 TRACE("%s %i %p %p %i\n", lpszFile
, nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
720 MultiByteToWideChar(CP_ACP
, 0, lpszFile
, -1, lpwstrFile
, len
);
721 ret
= ExtractIconExW(lpwstrFile
, nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
722 HeapFree(GetProcessHeap(), 0, lpwstrFile
);
727 /*************************************************************************
728 * ExtractAssociatedIconA (SHELL32.@)
730 * Return icon for given file (either from file itself or from associated
731 * executable) and patch parameters if needed.
733 HICON WINAPI
ExtractAssociatedIconA(HINSTANCE hInst
, LPSTR lpIconPath
, LPWORD lpiIcon
)
736 INT len
= MultiByteToWideChar(CP_ACP
, 0, lpIconPath
, -1, NULL
, 0);
737 /* Note that we need to allocate MAX_PATH, since we are supposed to fill
738 * the correct executable if there is no icon in lpIconPath directly.
739 * lpIconPath itself is supposed to be large enough, so make sure lpIconPathW
740 * is large enough too. Yes, I am puking too.
742 LPWSTR lpIconPathW
= HeapAlloc(GetProcessHeap(), 0, MAX_PATH
* sizeof(WCHAR
));
744 TRACE("%p %s %p\n", hInst
, debugstr_a(lpIconPath
), lpiIcon
);
748 MultiByteToWideChar(CP_ACP
, 0, lpIconPath
, -1, lpIconPathW
, len
);
749 hIcon
= ExtractAssociatedIconW(hInst
, lpIconPathW
, lpiIcon
);
750 WideCharToMultiByte(CP_ACP
, 0, lpIconPathW
, -1, lpIconPath
, MAX_PATH
, NULL
, NULL
);
751 HeapFree(GetProcessHeap(), 0, lpIconPathW
);
756 /*************************************************************************
757 * ExtractAssociatedIconW (SHELL32.@)
759 * Return icon for given file (either from file itself or from associated
760 * executable) and patch parameters if needed.
762 HICON WINAPI
ExtractAssociatedIconW(HINSTANCE hInst
, LPWSTR lpIconPath
, LPWORD lpiIcon
)
767 TRACE("%p %s %p\n", hInst
, debugstr_w(lpIconPath
), lpiIcon
);
770 lpiIcon
= &wDummyIcon
;
772 hIcon
= ExtractIconW(hInst
, lpIconPath
, *lpiIcon
);
774 if( hIcon
< (HICON
)2 )
775 { if( hIcon
== (HICON
)1 ) /* no icons found in given file */
776 { WCHAR tempPath
[MAX_PATH
];
777 HINSTANCE uRet
= FindExecutableW(lpIconPath
,NULL
,tempPath
);
779 if( uRet
> (HINSTANCE
)32 && tempPath
[0] )
780 { lstrcpyW(lpIconPath
,tempPath
);
781 hIcon
= ExtractIconW(hInst
, lpIconPath
, *lpiIcon
);
782 if( hIcon
> (HICON
)2 )
787 if( hIcon
== (HICON
)1 )
788 *lpiIcon
= 2; /* MSDOS icon - we found .exe but no icons in it */
790 *lpiIcon
= 6; /* generic icon - found nothing */
792 if (GetModuleFileNameW(hInst
, lpIconPath
, MAX_PATH
))
793 hIcon
= LoadIconW(hInst
, MAKEINTRESOURCEW(*lpiIcon
));
798 /*************************************************************************
799 * ExtractAssociatedIconExW (SHELL32.@)
801 * Return icon for given file (either from file itself or from associated
802 * executable) and patch parameters if needed.
804 HICON WINAPI
ExtractAssociatedIconExW(HINSTANCE hInst
, LPWSTR lpIconPath
, LPWORD lpiIconIdx
, LPWORD lpiIconId
)
806 FIXME("%p %s %p %p): stub\n", hInst
, debugstr_w(lpIconPath
), lpiIconIdx
, lpiIconId
);
810 /*************************************************************************
811 * ExtractAssociatedIconExA (SHELL32.@)
813 * Return icon for given file (either from file itself or from associated
814 * executable) and patch parameters if needed.
816 HICON WINAPI
ExtractAssociatedIconExA(HINSTANCE hInst
, LPSTR lpIconPath
, LPWORD lpiIconIdx
, LPWORD lpiIconId
)
819 INT len
= MultiByteToWideChar( CP_ACP
, 0, lpIconPath
, -1, NULL
, 0 );
820 LPWSTR lpwstrFile
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
822 TRACE("%p %s %p %p)\n", hInst
, lpIconPath
, lpiIconIdx
, lpiIconId
);
824 MultiByteToWideChar( CP_ACP
, 0, lpIconPath
, -1, lpwstrFile
, len
);
825 ret
= ExtractAssociatedIconExW(hInst
, lpwstrFile
, lpiIconIdx
, lpiIconId
);
826 HeapFree(GetProcessHeap(), 0, lpwstrFile
);
831 /****************************************************************************
832 * SHDefExtractIconW [SHELL32.@]
834 HRESULT WINAPI
SHDefExtractIconW(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
,
835 HICON
* phiconLarge
, HICON
* phiconSmall
, UINT nIconSize
)
839 WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile
), iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
841 ret
= PrivateExtractIconsW(pszIconFile
, iIndex
, nIconSize
, nIconSize
, hIcons
, NULL
, 2, LR_DEFAULTCOLOR
);
842 /* FIXME: deal with uFlags parameter which contains GIL_ flags */
843 if (ret
== 0xFFFFFFFF)
846 *phiconLarge
= hIcons
[0];
847 *phiconSmall
= hIcons
[1];
853 /****************************************************************************
854 * SHDefExtractIconA [SHELL32.@]
856 HRESULT WINAPI
SHDefExtractIconA(LPCSTR pszIconFile
, int iIndex
, UINT uFlags
,
857 HICON
* phiconLarge
, HICON
* phiconSmall
, UINT nIconSize
)
860 INT len
= MultiByteToWideChar(CP_ACP
, 0, pszIconFile
, -1, NULL
, 0);
861 LPWSTR lpwstrFile
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
863 TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
865 MultiByteToWideChar(CP_ACP
, 0, pszIconFile
, -1, lpwstrFile
, len
);
866 ret
= SHDefExtractIconW(lpwstrFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
867 HeapFree(GetProcessHeap(), 0, lpwstrFile
);