| /* |
| * shell icon cache (SIC) |
| * |
| * Copyright 1998, 1999 Juergen Schmied |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <stdarg.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| |
| #define COBJMACROS |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| #include "winreg.h" |
| #include "wine/debug.h" |
| |
| #include "shellapi.h" |
| #include "objbase.h" |
| #include "pidl.h" |
| #include "shell32_main.h" |
| #include "undocshell.h" |
| #include "shresdef.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(shell); |
| |
| /********************** THE ICON CACHE ********************************/ |
| |
| #define INVALID_INDEX -1 |
| |
| typedef struct |
| { |
| LPWSTR sSourceFile; /* file (not path!) containing the icon */ |
| DWORD dwSourceIndex; /* index within the file, if it is a resource ID it will be negated */ |
| DWORD dwListIndex; /* index within the iconlist */ |
| DWORD dwFlags; /* GIL_* flags */ |
| DWORD dwAccessTime; |
| } SIC_ENTRY, * LPSIC_ENTRY; |
| |
| static HDPA sic_hdpa = 0; |
| |
| static CRITICAL_SECTION SHELL32_SicCS; |
| static CRITICAL_SECTION_DEBUG critsect_debug = |
| { |
| 0, 0, &SHELL32_SicCS, |
| { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, |
| 0, 0, { (DWORD_PTR)(__FILE__ ": SHELL32_SicCS") } |
| }; |
| static CRITICAL_SECTION SHELL32_SicCS = { &critsect_debug, -1, 0, 0, 0, 0 }; |
| |
| /***************************************************************************** |
| * SIC_CompareEntries |
| * |
| * NOTES |
| * Callback for DPA_Search |
| */ |
| static INT CALLBACK SIC_CompareEntries( LPVOID p1, LPVOID p2, LPARAM lparam) |
| { |
| LPSIC_ENTRY e1 = p1, e2 = p2; |
| |
| TRACE("%p %p %8lx\n", p1, p2, lparam); |
| |
| /* Icons in the cache are keyed by the name of the file they are |
| * loaded from, their resource index and the fact if they have a shortcut |
| * icon overlay or not. |
| */ |
| if (e1->dwSourceIndex != e2->dwSourceIndex || /* first the faster one */ |
| (e1->dwFlags & GIL_FORSHORTCUT) != (e2->dwFlags & GIL_FORSHORTCUT)) |
| return 1; |
| |
| if (strcmpiW(e1->sSourceFile,e2->sSourceFile)) |
| return 1; |
| |
| return 0; |
| } |
| |
| /* declare SIC_LoadOverlayIcon() */ |
| static int SIC_LoadOverlayIcon(int icon_idx); |
| |
| /***************************************************************************** |
| * SIC_OverlayShortcutImage [internal] |
| * |
| * NOTES |
| * Creates a new icon as a copy of the passed-in icon, overlayed with a |
| * shortcut image. |
| */ |
| static HICON SIC_OverlayShortcutImage(HICON SourceIcon, BOOL large) |
| { ICONINFO SourceIconInfo, ShortcutIconInfo, TargetIconInfo; |
| HICON ShortcutIcon, TargetIcon; |
| BITMAP SourceBitmapInfo, ShortcutBitmapInfo; |
| HDC SourceDC = NULL, |
| ShortcutDC = NULL, |
| TargetDC = NULL, |
| ScreenDC = NULL; |
| HBITMAP OldSourceBitmap = NULL, |
| OldShortcutBitmap = NULL, |
| OldTargetBitmap = NULL; |
| |
| static int s_imgListIdx = -1; |
| |
| /* Get information about the source icon and shortcut overlay */ |
| if (! GetIconInfo(SourceIcon, &SourceIconInfo) |
| || 0 == GetObjectW(SourceIconInfo.hbmColor, sizeof(BITMAP), &SourceBitmapInfo)) |
| { |
| return NULL; |
| } |
| |
| /* search for the shortcut icon only once */ |
| if (s_imgListIdx == -1) |
| s_imgListIdx = SIC_LoadOverlayIcon(- IDI_SHELL_SHORTCUT); |
| /* FIXME should use icon index 29 instead of the |
| resource id, but not all icons are present yet |
| so we can't use icon indices */ |
| |
| if (s_imgListIdx != -1) |
| { |
| if (large) |
| ShortcutIcon = ImageList_GetIcon(ShellBigIconList, s_imgListIdx, ILD_TRANSPARENT); |
| else |
| ShortcutIcon = ImageList_GetIcon(ShellSmallIconList, s_imgListIdx, ILD_TRANSPARENT); |
| } else |
| ShortcutIcon = NULL; |
| |
| if (NULL == ShortcutIcon |
| || ! GetIconInfo(ShortcutIcon, &ShortcutIconInfo) |
| || 0 == GetObjectW(ShortcutIconInfo.hbmColor, sizeof(BITMAP), &ShortcutBitmapInfo)) |
| { |
| return NULL; |
| } |
| |
| TargetIconInfo = SourceIconInfo; |
| TargetIconInfo.hbmMask = NULL; |
| TargetIconInfo.hbmColor = NULL; |
| |
| /* Setup the source, shortcut and target masks */ |
| SourceDC = CreateCompatibleDC(NULL); |
| if (NULL == SourceDC) goto fail; |
| OldSourceBitmap = SelectObject(SourceDC, SourceIconInfo.hbmMask); |
| if (NULL == OldSourceBitmap) goto fail; |
| |
| ShortcutDC = CreateCompatibleDC(NULL); |
| if (NULL == ShortcutDC) goto fail; |
| OldShortcutBitmap = SelectObject(ShortcutDC, ShortcutIconInfo.hbmMask); |
| if (NULL == OldShortcutBitmap) goto fail; |
| |
| TargetDC = CreateCompatibleDC(NULL); |
| if (NULL == TargetDC) goto fail; |
| TargetIconInfo.hbmMask = CreateCompatibleBitmap(TargetDC, SourceBitmapInfo.bmWidth, |
| SourceBitmapInfo.bmHeight); |
| if (NULL == TargetIconInfo.hbmMask) goto fail; |
| ScreenDC = GetDC(NULL); |
| if (NULL == ScreenDC) goto fail; |
| TargetIconInfo.hbmColor = CreateCompatibleBitmap(ScreenDC, SourceBitmapInfo.bmWidth, |
| SourceBitmapInfo.bmHeight); |
| ReleaseDC(NULL, ScreenDC); |
| if (NULL == TargetIconInfo.hbmColor) goto fail; |
| OldTargetBitmap = SelectObject(TargetDC, TargetIconInfo.hbmMask); |
| if (NULL == OldTargetBitmap) goto fail; |
| |
| /* Create the target mask by ANDing the source and shortcut masks */ |
| if (! BitBlt(TargetDC, 0, 0, SourceBitmapInfo.bmWidth, SourceBitmapInfo.bmHeight, |
| SourceDC, 0, 0, SRCCOPY) || |
| ! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight, |
| ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight, |
| ShortcutDC, 0, 0, SRCAND)) |
| { |
| goto fail; |
| } |
| |
| /* Setup the source and target xor bitmap */ |
| if (NULL == SelectObject(SourceDC, SourceIconInfo.hbmColor) || |
| NULL == SelectObject(TargetDC, TargetIconInfo.hbmColor)) |
| { |
| goto fail; |
| } |
| |
| /* Copy the source xor bitmap to the target and clear out part of it by using |
| the shortcut mask */ |
| if (! BitBlt(TargetDC, 0, 0, SourceBitmapInfo.bmWidth, SourceBitmapInfo.bmHeight, |
| SourceDC, 0, 0, SRCCOPY) || |
| ! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight, |
| ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight, |
| ShortcutDC, 0, 0, SRCAND)) |
| { |
| goto fail; |
| } |
| |
| if (NULL == SelectObject(ShortcutDC, ShortcutIconInfo.hbmColor)) goto fail; |
| |
| /* Now put in the shortcut xor mask */ |
| if (! BitBlt(TargetDC, 0, SourceBitmapInfo.bmHeight - ShortcutBitmapInfo.bmHeight, |
| ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight, |
| ShortcutDC, 0, 0, SRCINVERT)) |
| { |
| goto fail; |
| } |
| |
| /* Clean up, we're not goto'ing to 'fail' after this so we can be lazy and not set |
| handles to NULL */ |
| SelectObject(TargetDC, OldTargetBitmap); |
| DeleteObject(TargetDC); |
| SelectObject(ShortcutDC, OldShortcutBitmap); |
| DeleteObject(ShortcutDC); |
| SelectObject(SourceDC, OldSourceBitmap); |
| DeleteObject(SourceDC); |
| |
| /* Create the icon using the bitmaps prepared earlier */ |
| TargetIcon = CreateIconIndirect(&TargetIconInfo); |
| |
| /* CreateIconIndirect copies the bitmaps, so we can release our bitmaps now */ |
| DeleteObject(TargetIconInfo.hbmColor); |
| DeleteObject(TargetIconInfo.hbmMask); |
| |
| return TargetIcon; |
| |
| fail: |
| /* Clean up scratch resources we created */ |
| if (NULL != OldTargetBitmap) SelectObject(TargetDC, OldTargetBitmap); |
| if (NULL != TargetIconInfo.hbmColor) DeleteObject(TargetIconInfo.hbmColor); |
| if (NULL != TargetIconInfo.hbmMask) DeleteObject(TargetIconInfo.hbmMask); |
| if (NULL != TargetDC) DeleteObject(TargetDC); |
| if (NULL != OldShortcutBitmap) SelectObject(ShortcutDC, OldShortcutBitmap); |
| if (NULL != ShortcutDC) DeleteObject(ShortcutDC); |
| if (NULL != OldSourceBitmap) SelectObject(SourceDC, OldSourceBitmap); |
| if (NULL != SourceDC) DeleteObject(SourceDC); |
| |
| return NULL; |
| } |
| |
| /***************************************************************************** |
| * SIC_IconAppend [internal] |
| * |
| * NOTES |
| * appends an icon pair to the end of the cache |
| */ |
| static INT SIC_IconAppend (LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags) |
| { LPSIC_ENTRY lpsice; |
| INT ret, index, index1; |
| WCHAR path[MAX_PATH]; |
| TRACE("%s %i %p %p\n", debugstr_w(sSourceFile), dwSourceIndex, hSmallIcon ,hBigIcon); |
| |
| lpsice = SHAlloc(sizeof(SIC_ENTRY)); |
| |
| GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL); |
| lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, (strlenW(path)+1)*sizeof(WCHAR) ); |
| strcpyW( lpsice->sSourceFile, path ); |
| |
| lpsice->dwSourceIndex = dwSourceIndex; |
| lpsice->dwFlags = dwFlags; |
| |
| EnterCriticalSection(&SHELL32_SicCS); |
| |
| index = DPA_InsertPtr(sic_hdpa, 0x7fff, lpsice); |
| if ( INVALID_INDEX == index ) |
| { |
| HeapFree(GetProcessHeap(), 0, lpsice->sSourceFile); |
| SHFree(lpsice); |
| ret = INVALID_INDEX; |
| } |
| else |
| { |
| index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon); |
| index1= ImageList_AddIcon (ShellBigIconList, hBigIcon); |
| |
| if (index!=index1) |
| { |
| FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1); |
| } |
| lpsice->dwListIndex = index; |
| ret = lpsice->dwListIndex; |
| } |
| |
| LeaveCriticalSection(&SHELL32_SicCS); |
| return ret; |
| } |
| /**************************************************************************** |
| * SIC_LoadIcon [internal] |
| * |
| * NOTES |
| * gets small/big icon by number from a file |
| */ |
| static INT SIC_LoadIcon (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags) |
| { HICON hiconLarge=0; |
| HICON hiconSmall=0; |
| HICON hiconLargeShortcut; |
| HICON hiconSmallShortcut; |
| |
| PrivateExtractIconsW( sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, 0, 1, 0 ); |
| PrivateExtractIconsW( sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, 0, 1, 0 ); |
| |
| if ( !hiconLarge || !hiconSmall) |
| { |
| WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex, debugstr_w(sSourceFile), hiconLarge, hiconSmall); |
| return -1; |
| } |
| |
| if (0 != (dwFlags & GIL_FORSHORTCUT)) |
| { |
| hiconLargeShortcut = SIC_OverlayShortcutImage(hiconLarge, TRUE); |
| hiconSmallShortcut = SIC_OverlayShortcutImage(hiconSmall, FALSE); |
| if (NULL != hiconLargeShortcut && NULL != hiconSmallShortcut) |
| { |
| hiconLarge = hiconLargeShortcut; |
| hiconSmall = hiconSmallShortcut; |
| } |
| else |
| { |
| WARN("Failed to create shortcut overlayed icons\n"); |
| if (NULL != hiconLargeShortcut) DestroyIcon(hiconLargeShortcut); |
| if (NULL != hiconSmallShortcut) DestroyIcon(hiconSmallShortcut); |
| dwFlags &= ~ GIL_FORSHORTCUT; |
| } |
| } |
| |
| return SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge, dwFlags); |
| } |
| /***************************************************************************** |
| * SIC_GetIconIndex [internal] |
| * |
| * Parameters |
| * sSourceFile [IN] filename of file containing the icon |
| * index [IN] index/resID (negated) in this file |
| * |
| * NOTES |
| * look in the cache for a proper icon. if not available the icon is taken |
| * from the file and cached |
| */ |
| INT SIC_GetIconIndex (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags ) |
| { |
| SIC_ENTRY sice; |
| INT ret, index = INVALID_INDEX; |
| WCHAR path[MAX_PATH]; |
| |
| TRACE("%s %i\n", debugstr_w(sSourceFile), dwSourceIndex); |
| |
| GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL); |
| sice.sSourceFile = path; |
| sice.dwSourceIndex = dwSourceIndex; |
| sice.dwFlags = dwFlags; |
| |
| EnterCriticalSection(&SHELL32_SicCS); |
| |
| if (NULL != DPA_GetPtr (sic_hdpa, 0)) |
| { |
| /* search linear from position 0*/ |
| index = DPA_Search (sic_hdpa, &sice, 0, SIC_CompareEntries, 0, 0); |
| } |
| |
| if ( INVALID_INDEX == index ) |
| { |
| ret = SIC_LoadIcon (sSourceFile, dwSourceIndex, dwFlags); |
| } |
| else |
| { |
| TRACE("-- found\n"); |
| ret = ((LPSIC_ENTRY)DPA_GetPtr(sic_hdpa, index))->dwListIndex; |
| } |
| |
| LeaveCriticalSection(&SHELL32_SicCS); |
| return ret; |
| } |
| /***************************************************************************** |
| * SIC_Initialize [internal] |
| */ |
| BOOL SIC_Initialize(void) |
| { |
| HICON hSm, hLg; |
| int cx_small, cy_small; |
| int cx_large, cy_large; |
| |
| cx_small = GetSystemMetrics(SM_CXSMICON); |
| cy_small = GetSystemMetrics(SM_CYSMICON); |
| cx_large = GetSystemMetrics(SM_CXICON); |
| cy_large = GetSystemMetrics(SM_CYICON); |
| |
| TRACE("\n"); |
| |
| if (sic_hdpa) /* already initialized?*/ |
| return TRUE; |
| |
| sic_hdpa = DPA_Create(16); |
| |
| if (!sic_hdpa) |
| { |
| return(FALSE); |
| } |
| |
| ShellSmallIconList = ImageList_Create(cx_small,cy_small,ILC_COLOR32|ILC_MASK,0,0x20); |
| ShellBigIconList = ImageList_Create(cx_large,cy_large,ILC_COLOR32|ILC_MASK,0,0x20); |
| |
| ImageList_SetBkColor(ShellSmallIconList, CLR_NONE); |
| ImageList_SetBkColor(ShellBigIconList, CLR_NONE); |
| |
| /* Load the document icon, which is used as the default if an icon isn't found. */ |
| hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT), |
| IMAGE_ICON, cx_small, cy_small, LR_SHARED); |
| hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(IDI_SHELL_DOCUMENT), |
| IMAGE_ICON, cx_large, cy_large, LR_SHARED); |
| |
| if (!hSm || !hLg) |
| { |
| FIXME("Failed to load IDI_SHELL_DOCUMENT icon!\n"); |
| return FALSE; |
| } |
| |
| SIC_IconAppend (swShell32Name, IDI_SHELL_DOCUMENT-1, hSm, hLg, 0); |
| SIC_IconAppend (swShell32Name, -IDI_SHELL_DOCUMENT, hSm, hLg, 0); |
| |
| TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList); |
| |
| return TRUE; |
| } |
| /************************************************************************* |
| * SIC_Destroy |
| * |
| * frees the cache |
| */ |
| static INT CALLBACK sic_free( LPVOID ptr, LPVOID lparam ) |
| { |
| HeapFree(GetProcessHeap(), 0, ((LPSIC_ENTRY)ptr)->sSourceFile); |
| SHFree(ptr); |
| return TRUE; |
| } |
| |
| void SIC_Destroy(void) |
| { |
| TRACE("\n"); |
| |
| EnterCriticalSection(&SHELL32_SicCS); |
| |
| if (sic_hdpa) DPA_DestroyCallback(sic_hdpa, sic_free, NULL ); |
| |
| sic_hdpa = NULL; |
| ImageList_Destroy(ShellSmallIconList); |
| ShellSmallIconList = 0; |
| ImageList_Destroy(ShellBigIconList); |
| ShellBigIconList = 0; |
| |
| LeaveCriticalSection(&SHELL32_SicCS); |
| DeleteCriticalSection(&SHELL32_SicCS); |
| } |
| |
| /***************************************************************************** |
| * SIC_LoadOverlayIcon [internal] |
| * |
| * Load a shell overlay icon and return its icon cache index. |
| */ |
| static int SIC_LoadOverlayIcon(int icon_idx) |
| { |
| WCHAR buffer[1024], wszIdx[8]; |
| HKEY hKeyShellIcons; |
| LPCWSTR iconPath; |
| int iconIdx; |
| |
| static const WCHAR wszShellIcons[] = { |
| 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\', |
| 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', |
| 'E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','I','c','o','n','s',0 |
| }; |
| static const WCHAR wszNumFmt[] = {'%','d',0}; |
| |
| iconPath = swShell32Name; /* default: load icon from shell32.dll */ |
| iconIdx = icon_idx; |
| |
| if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszShellIcons, 0, KEY_READ, &hKeyShellIcons) == ERROR_SUCCESS) |
| { |
| DWORD count = sizeof(buffer); |
| |
| sprintfW(wszIdx, wszNumFmt, icon_idx); |
| |
| /* read icon path and index */ |
| if (RegQueryValueExW(hKeyShellIcons, wszIdx, NULL, NULL, (LPBYTE)buffer, &count) == ERROR_SUCCESS) |
| { |
| LPWSTR p = strchrW(buffer, ','); |
| |
| if (p) |
| *p++ = 0; |
| |
| iconPath = buffer; |
| iconIdx = atoiW(p); |
| } |
| |
| RegCloseKey(hKeyShellIcons); |
| } |
| |
| return SIC_LoadIcon(iconPath, iconIdx, 0); |
| } |
| |
| /************************************************************************* |
| * Shell_GetImageList [SHELL32.71] |
| * |
| * PARAMETERS |
| * imglist[1|2] [OUT] pointer which receives imagelist handles |
| * |
| */ |
| BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList) |
| { TRACE("(%p,%p)\n",lpBigList,lpSmallList); |
| if (lpBigList) |
| { *lpBigList = ShellBigIconList; |
| } |
| if (lpSmallList) |
| { *lpSmallList = ShellSmallIconList; |
| } |
| |
| return TRUE; |
| } |
| /************************************************************************* |
| * PidlToSicIndex [INTERNAL] |
| * |
| * PARAMETERS |
| * sh [IN] IShellFolder |
| * pidl [IN] |
| * bBigIcon [IN] |
| * uFlags [IN] GIL_* |
| * pIndex [OUT] index within the SIC |
| * |
| */ |
| BOOL PidlToSicIndex ( |
| IShellFolder * sh, |
| LPCITEMIDLIST pidl, |
| BOOL bBigIcon, |
| UINT uFlags, |
| int * pIndex) |
| { |
| IExtractIconW *ei; |
| WCHAR szIconFile[MAX_PATH]; /* file containing the icon */ |
| INT iSourceIndex; /* index or resID(negated) in this file */ |
| BOOL ret = FALSE; |
| UINT dwFlags = 0; |
| int iShortcutDefaultIndex = INVALID_INDEX; |
| |
| TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small"); |
| |
| if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconW, 0, (void **)&ei))) |
| { |
| if (SUCCEEDED(IExtractIconW_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags))) |
| { |
| *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex, uFlags); |
| ret = TRUE; |
| } |
| IExtractIconW_Release(ei); |
| } |
| |
| if (INVALID_INDEX == *pIndex) /* default icon when failed */ |
| { |
| if (0 == (uFlags & GIL_FORSHORTCUT)) |
| { |
| *pIndex = 0; |
| } |
| else |
| { |
| if (INVALID_INDEX == iShortcutDefaultIndex) |
| { |
| iShortcutDefaultIndex = SIC_LoadIcon(swShell32Name, 0, GIL_FORSHORTCUT); |
| } |
| *pIndex = (INVALID_INDEX != iShortcutDefaultIndex ? iShortcutDefaultIndex : 0); |
| } |
| } |
| |
| return ret; |
| |
| } |
| |
| /************************************************************************* |
| * SHMapPIDLToSystemImageListIndex [SHELL32.77] |
| * |
| * PARAMETERS |
| * sh [IN] pointer to an instance of IShellFolder |
| * pidl [IN] |
| * pIndex [OUT][OPTIONAL] SIC index for big icon |
| * |
| */ |
| int WINAPI SHMapPIDLToSystemImageListIndex( |
| IShellFolder *sh, |
| LPCITEMIDLIST pidl, |
| int *pIndex) |
| { |
| int Index; |
| UINT uGilFlags = 0; |
| |
| TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex); |
| pdump(pidl); |
| |
| if (SHELL_IsShortcut(pidl)) |
| uGilFlags |= GIL_FORSHORTCUT; |
| |
| if (pIndex) |
| if (!PidlToSicIndex ( sh, pidl, 1, uGilFlags, pIndex)) |
| *pIndex = -1; |
| |
| if (!PidlToSicIndex ( sh, pidl, 0, uGilFlags, &Index)) |
| return -1; |
| |
| return Index; |
| } |
| |
| /************************************************************************* |
| * SHMapIDListToImageListIndexAsync [SHELL32.148] |
| */ |
| HRESULT WINAPI SHMapIDListToImageListIndexAsync(IUnknown *pts, IShellFolder *psf, |
| LPCITEMIDLIST pidl, UINT flags, |
| void *pfn, void *pvData, void *pvHint, |
| int *piIndex, int *piIndexSel) |
| { |
| FIXME("(%p, %p, %p, 0x%08x, %p, %p, %p, %p, %p)\n", |
| pts, psf, pidl, flags, pfn, pvData, pvHint, piIndex, piIndexSel); |
| return E_FAIL; |
| } |
| |
| /************************************************************************* |
| * Shell_GetCachedImageIndex [SHELL32.72] |
| * |
| */ |
| static INT Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc) |
| { |
| INT ret, len; |
| LPWSTR szTemp; |
| |
| WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc); |
| |
| len = MultiByteToWideChar( CP_ACP, 0, szPath, -1, NULL, 0 ); |
| szTemp = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); |
| MultiByteToWideChar( CP_ACP, 0, szPath, -1, szTemp, len ); |
| |
| ret = SIC_GetIconIndex( szTemp, nIndex, 0 ); |
| |
| HeapFree( GetProcessHeap(), 0, szTemp ); |
| |
| return ret; |
| } |
| |
| static INT Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc) |
| { |
| WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc); |
| |
| return SIC_GetIconIndex(szPath, nIndex, 0); |
| } |
| |
| INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc) |
| { if( SHELL_OsIsUnicode()) |
| return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc); |
| return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc); |
| } |
| |
| /************************************************************************* |
| * ExtractIconExW [SHELL32.@] |
| * RETURNS |
| * 0 no icon found |
| * -1 file is not valid |
| * or number of icons extracted |
| */ |
| UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons) |
| { |
| TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons); |
| |
| return PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons); |
| } |
| |
| /************************************************************************* |
| * ExtractIconExA [SHELL32.@] |
| */ |
| UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons) |
| { |
| UINT ret = 0; |
| INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0); |
| LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| |
| TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons); |
| |
| if (lpwstrFile) |
| { |
| MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len); |
| ret = ExtractIconExW(lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons); |
| HeapFree(GetProcessHeap(), 0, lpwstrFile); |
| } |
| return ret; |
| } |
| |
| /************************************************************************* |
| * ExtractAssociatedIconA (SHELL32.@) |
| * |
| * Return icon for given file (either from file itself or from associated |
| * executable) and patch parameters if needed. |
| */ |
| HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon) |
| { |
| HICON hIcon = NULL; |
| INT len = MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, NULL, 0); |
| /* Note that we need to allocate MAX_PATH, since we are supposed to fill |
| * the correct executable if there is no icon in lpIconPath directly. |
| * lpIconPath itself is supposed to be large enough, so make sure lpIconPathW |
| * is large enough too. Yes, I am puking too. |
| */ |
| LPWSTR lpIconPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR)); |
| |
| TRACE("%p %s %p\n", hInst, debugstr_a(lpIconPath), lpiIcon); |
| |
| if (lpIconPathW) |
| { |
| MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, lpIconPathW, len); |
| hIcon = ExtractAssociatedIconW(hInst, lpIconPathW, lpiIcon); |
| WideCharToMultiByte(CP_ACP, 0, lpIconPathW, -1, lpIconPath, MAX_PATH , NULL, NULL); |
| HeapFree(GetProcessHeap(), 0, lpIconPathW); |
| } |
| return hIcon; |
| } |
| |
| /************************************************************************* |
| * ExtractAssociatedIconW (SHELL32.@) |
| * |
| * Return icon for given file (either from file itself or from associated |
| * executable) and patch parameters if needed. |
| */ |
| HICON WINAPI ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIcon) |
| { |
| HICON hIcon = NULL; |
| WORD wDummyIcon = 0; |
| |
| TRACE("%p %s %p\n", hInst, debugstr_w(lpIconPath), lpiIcon); |
| |
| if(lpiIcon == NULL) |
| lpiIcon = &wDummyIcon; |
| |
| hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon); |
| |
| if( hIcon < (HICON)2 ) |
| { if( hIcon == (HICON)1 ) /* no icons found in given file */ |
| { WCHAR tempPath[MAX_PATH]; |
| HINSTANCE uRet = FindExecutableW(lpIconPath,NULL,tempPath); |
| |
| if( uRet > (HINSTANCE)32 && tempPath[0] ) |
| { lstrcpyW(lpIconPath,tempPath); |
| hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon); |
| if( hIcon > (HICON)2 ) |
| return hIcon; |
| } |
| } |
| |
| if( hIcon == (HICON)1 ) |
| *lpiIcon = 2; /* MSDOS icon - we found .exe but no icons in it */ |
| else |
| *lpiIcon = 6; /* generic icon - found nothing */ |
| |
| if (GetModuleFileNameW(hInst, lpIconPath, MAX_PATH)) |
| hIcon = LoadIconW(hInst, MAKEINTRESOURCEW(*lpiIcon)); |
| } |
| return hIcon; |
| } |
| |
| /************************************************************************* |
| * ExtractAssociatedIconExW (SHELL32.@) |
| * |
| * Return icon for given file (either from file itself or from associated |
| * executable) and patch parameters if needed. |
| */ |
| HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId) |
| { |
| FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId); |
| return 0; |
| } |
| |
| /************************************************************************* |
| * ExtractAssociatedIconExA (SHELL32.@) |
| * |
| * Return icon for given file (either from file itself or from associated |
| * executable) and patch parameters if needed. |
| */ |
| HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId) |
| { |
| HICON ret; |
| INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 ); |
| LPWSTR lpwstrFile = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); |
| |
| TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId); |
| |
| MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len ); |
| ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId); |
| HeapFree(GetProcessHeap(), 0, lpwstrFile); |
| return ret; |
| } |
| |
| |
| /**************************************************************************** |
| * SHDefExtractIconW [SHELL32.@] |
| */ |
| HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, |
| HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize) |
| { |
| UINT ret; |
| HICON hIcons[2]; |
| WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize); |
| |
| ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR); |
| /* FIXME: deal with uFlags parameter which contains GIL_ flags */ |
| if (ret == 0xFFFFFFFF) |
| return E_FAIL; |
| if (ret > 0) { |
| if (phiconLarge) |
| *phiconLarge = hIcons[0]; |
| else |
| DestroyIcon(hIcons[0]); |
| if (phiconSmall) |
| *phiconSmall = hIcons[1]; |
| else |
| DestroyIcon(hIcons[1]); |
| return S_OK; |
| } |
| return S_FALSE; |
| } |
| |
| /**************************************************************************** |
| * SHDefExtractIconA [SHELL32.@] |
| */ |
| HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags, |
| HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize) |
| { |
| HRESULT ret; |
| INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0); |
| LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| |
| TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize); |
| |
| MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len); |
| ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize); |
| HeapFree(GetProcessHeap(), 0, lpwstrFile); |
| return ret; |
| } |
| |
| |
| /**************************************************************************** |
| * SHGetIconOverlayIndexA [SHELL32.@] |
| * |
| * Returns the index of the overlay icon in the system image list. |
| */ |
| INT WINAPI SHGetIconOverlayIndexA(LPCSTR pszIconPath, INT iIconIndex) |
| { |
| FIXME("%s, %d\n", debugstr_a(pszIconPath), iIconIndex); |
| |
| return -1; |
| } |
| |
| /**************************************************************************** |
| * SHGetIconOverlayIndexW [SHELL32.@] |
| * |
| * Returns the index of the overlay icon in the system image list. |
| */ |
| INT WINAPI SHGetIconOverlayIndexW(LPCWSTR pszIconPath, INT iIconIndex) |
| { |
| FIXME("%s, %d\n", debugstr_w(pszIconPath), iIconIndex); |
| |
| return -1; |
| } |