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                 {
 500                     ERR("Icon index in %s/%s corrupted, no comma.\n", debugstr_w(wszShellIcons),debugstr_w(wszIdx));
 501                     RegCloseKey(hKeyShellIcons);
 502                     return -1;
 503                 }
 504                 *p++ = 0;
 505                 iconPath = buffer;
 506                 iconIdx = atoiW(p);
 507             }
 508
 509             RegCloseKey(hKeyShellIcons);
 510         }
 511
 512         return SIC_LoadIcon(iconPath, iconIdx, 0);
 513 }
 514
 515 /*************************************************************************
 516  * Shell_GetImageLists                  [SHELL32.71]
 517  *
 518  * PARAMETERS
 519  *  imglist[1|2] [OUT] pointer which receives imagelist handles
 520  *
 521  */
 522 BOOL WINAPI Shell_GetImageLists(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList)
 523 {       TRACE("(%p,%p)\n",lpBigList,lpSmallList);
 524         if (lpBigList)
 525         { *lpBigList = ShellBigIconList;
 526         }
 527         if (lpSmallList)
 528         { *lpSmallList = ShellSmallIconList;
 529         }
 530
 531         return TRUE;
 532 }
 533 /*************************************************************************
 534  * PidlToSicIndex                       [INTERNAL]
 535  *
 536  * PARAMETERS
 537  *      sh      [IN]    IShellFolder
 538  *      pidl    [IN]
 539  *      bBigIcon [IN]
 540  *      uFlags  [IN]    GIL_*
 541  *      pIndex  [OUT]   index within the SIC
 542  *
 543  */
 544 BOOL PidlToSicIndex (
 545         IShellFolder * sh,
 546         LPCITEMIDLIST pidl,
 547         BOOL bBigIcon,
 548         UINT uFlags,
 549         int * pIndex)
 550 {
 551         IExtractIconW   *ei;
 552         WCHAR           szIconFile[MAX_PATH];   /* file containing the icon */
 553         INT             iSourceIndex;           /* index or resID(negated) in this file */
 554         BOOL            ret = FALSE;
 555         UINT            dwFlags = 0;
 556         int             iShortcutDefaultIndex = INVALID_INDEX;
 557
 558         TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
 559
 560         if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconW, 0, (void **)&ei)))
 561         {
 562           if (SUCCEEDED(IExtractIconW_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
 563           {
 564             *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex, uFlags);
 565             ret = TRUE;
 566           }
 567           IExtractIconW_Release(ei);
 568         }
 569
 570         if (INVALID_INDEX == *pIndex)   /* default icon when failed */
 571         {
 572           if (0 == (uFlags & GIL_FORSHORTCUT))
 573           {
 574             *pIndex = 0;
 575           }
 576           else
 577           {
 578             if (INVALID_INDEX == iShortcutDefaultIndex)
 579             {
 580               iShortcutDefaultIndex = SIC_LoadIcon(swShell32Name, 0, GIL_FORSHORTCUT);
 581             }
 582             *pIndex = (INVALID_INDEX != iShortcutDefaultIndex ? iShortcutDefaultIndex : 0);
 583           }
 584         }
 585
 586         return ret;
 587
 588 }
 589
 590 /*************************************************************************
 591  * SHMapPIDLToSystemImageListIndex      [SHELL32.77]
 592  *
 593  * PARAMETERS
 594  *      sh      [IN]            pointer to an instance of IShellFolder
 595  *      pidl    [IN]
 596  *      pIndex  [OUT][OPTIONAL] SIC index for big icon
 597  *
 598  */
 599 int WINAPI SHMapPIDLToSystemImageListIndex(
 600         IShellFolder *sh,
 601         LPCITEMIDLIST pidl,
 602         int *pIndex)
 603 {
 604         int Index;
 605         UINT uGilFlags = 0;
 606
 607         TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
 608         pdump(pidl);
 609
 610         if (SHELL_IsShortcut(pidl))
 611             uGilFlags |= GIL_FORSHORTCUT;
 612
 613         if (pIndex)
 614             if (!PidlToSicIndex ( sh, pidl, 1, uGilFlags, pIndex))
 615                 *pIndex = -1;
 616
 617         if (!PidlToSicIndex ( sh, pidl, 0, uGilFlags, &Index))
 618             return -1;
 619
 620         return Index;
 621 }
 622
 623 /*************************************************************************
 624  * SHMapIDListToImageListIndexAsync  [SHELL32.148]
 625  */
 626 HRESULT WINAPI SHMapIDListToImageListIndexAsync(IUnknown *pts, IShellFolder *psf,
 627                                                 LPCITEMIDLIST pidl, UINT flags,
 628                                                 void *pfn, void *pvData, void *pvHint,
 629                                                 int *piIndex, int *piIndexSel)
 630 {
 631     FIXME("(%p, %p, %p, 0x%08x, %p, %p, %p, %p, %p)\n",
 632             pts, psf, pidl, flags, pfn, pvData, pvHint, piIndex, piIndexSel);
 633     return E_FAIL;
 634 }
 635
 636 /*************************************************************************
 637  * Shell_GetCachedImageIndex            [SHELL32.72]
 638  *
 639  */
 640 static INT Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc)
 641 {
 642         INT ret, len;
 643         LPWSTR szTemp;
 644
 645         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
 646
 647         len = MultiByteToWideChar( CP_ACP, 0, szPath, -1, NULL, 0 );
 648         szTemp = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 649         MultiByteToWideChar( CP_ACP, 0, szPath, -1, szTemp, len );
 650
 651         ret = SIC_GetIconIndex( szTemp, nIndex, 0 );
 652
 653         HeapFree( GetProcessHeap(), 0, szTemp );
 654
 655         return ret;
 656 }
 657
 658 static INT Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc)
 659 {
 660         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
 661
 662         return SIC_GetIconIndex(szPath, nIndex, 0);
 663 }
 664
 665 INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
 666 {       if( SHELL_OsIsUnicode())
 667           return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc);
 668         return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc);
 669 }
 670
 671 /*************************************************************************
 672  * ExtractIconExW                       [SHELL32.@]
 673  * RETURNS
 674  *  0 no icon found
 675  *  -1 file is not valid
 676  *  or number of icons extracted
 677  */
 678 UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 679 {
 680         TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons);
 681
 682         return PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 683 }
 684
 685 /*************************************************************************
 686  * ExtractIconExA                       [SHELL32.@]
 687  */
 688 UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 689 {
 690     UINT ret = 0;
 691     INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
 692     LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 693
 694     TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 695
 696     if (lpwstrFile)
 697     {
 698         MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
 699         ret = ExtractIconExW(lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 700         HeapFree(GetProcessHeap(), 0, lpwstrFile);
 701     }
 702     return ret;
 703 }
 704
 705 /*************************************************************************
 706  *                              ExtractAssociatedIconA (SHELL32.@)
 707  *
 708  * Return icon for given file (either from file itself or from associated
 709  * executable) and patch parameters if needed.
 710  */
 711 HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
 712 {
 713     HICON hIcon = NULL;
 714     INT len = MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, NULL, 0);
 715     /* Note that we need to allocate MAX_PATH, since we are supposed to fill
 716      * the correct executable if there is no icon in lpIconPath directly.
 717      * lpIconPath itself is supposed to be large enough, so make sure lpIconPathW
 718      * is large enough too. Yes, I am puking too.
 719      */
 720     LPWSTR lpIconPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
 721
 722     TRACE("%p %s %p\n", hInst, debugstr_a(lpIconPath), lpiIcon);
 723
 724     if (lpIconPathW)
 725     {
 726         MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, lpIconPathW, len);
 727         hIcon = ExtractAssociatedIconW(hInst, lpIconPathW, lpiIcon);
 728         WideCharToMultiByte(CP_ACP, 0, lpIconPathW, -1, lpIconPath, MAX_PATH , NULL, NULL);
 729         HeapFree(GetProcessHeap(), 0, lpIconPathW);
 730     }
 731     return hIcon;
 732 }
 733
 734 /*************************************************************************
 735  *                              ExtractAssociatedIconW (SHELL32.@)
 736  *
 737  * Return icon for given file (either from file itself or from associated
 738  * executable) and patch parameters if needed.
 739  */
 740 HICON WINAPI ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIcon)
 741 {
 742     HICON hIcon = NULL;
 743     WORD wDummyIcon = 0;
 744
 745     TRACE("%p %s %p\n", hInst, debugstr_w(lpIconPath), lpiIcon);
 746
 747     if(lpiIcon == NULL)
 748         lpiIcon = &wDummyIcon;
 749
 750     hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
 751
 752     if( hIcon < (HICON)2 )
 753     { if( hIcon == (HICON)1 ) /* no icons found in given file */
 754       { WCHAR tempPath[MAX_PATH];
 755         HINSTANCE uRet = FindExecutableW(lpIconPath,NULL,tempPath);
 756
 757         if( uRet > (HINSTANCE)32 && tempPath[0] )
 758         { lstrcpyW(lpIconPath,tempPath);
 759           hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
 760           if( hIcon > (HICON)2 )
 761             return hIcon;
 762         }
 763       }
 764
 765       if( hIcon == (HICON)1 )
 766         *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
 767       else
 768         *lpiIcon = 6;   /* generic icon - found nothing */
 769
 770       if (GetModuleFileNameW(hInst, lpIconPath, MAX_PATH))
 771         hIcon = LoadIconW(hInst, MAKEINTRESOURCEW(*lpiIcon));
 772     }
 773     return hIcon;
 774 }
 775
 776 /*************************************************************************
 777  *                              ExtractAssociatedIconExW (SHELL32.@)
 778  *
 779  * Return icon for given file (either from file itself or from associated
 780  * executable) and patch parameters if needed.
 781  */
 782 HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 783 {
 784   FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId);
 785   return 0;
 786 }
 787
 788 /*************************************************************************
 789  *                              ExtractAssociatedIconExA (SHELL32.@)
 790  *
 791  * Return icon for given file (either from file itself or from associated
 792  * executable) and patch parameters if needed.
 793  */
 794 HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 795 {
 796   HICON ret;
 797   INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 );
 798   LPWSTR lpwstrFile = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 799
 800   TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId);
 801
 802   MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len );
 803   ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId);
 804   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 805   return ret;
 806 }
 807
 808
 809 /****************************************************************************
 810  * SHDefExtractIconW            [SHELL32.@]
 811  */
 812 HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags,
 813                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 814 {
 815         UINT ret;
 816         HICON hIcons[2];
 817         WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 818
 819         ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR);
 820         /* FIXME: deal with uFlags parameter which contains GIL_ flags */
 821         if (ret == 0xFFFFFFFF)
 822           return E_FAIL;
 823         if (ret > 0) {
 824           if (phiconLarge)
 825             *phiconLarge = hIcons[0];
 826           else
 827             DestroyIcon(hIcons[0]);
 828           if (phiconSmall)
 829             *phiconSmall = hIcons[1];
 830           else
 831             DestroyIcon(hIcons[1]);
 832           return S_OK;
 833         }
 834         return S_FALSE;
 835 }
 836
 837 /****************************************************************************
 838  * SHDefExtractIconA            [SHELL32.@]
 839  */
 840 HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags,
 841                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 842 {
 843   HRESULT ret;
 844   INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0);
 845   LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 846
 847   TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 848
 849   MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len);
 850   ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 851   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 852   return ret;
 853 }
 854
 855
 856 /****************************************************************************
 857  * SHGetIconOverlayIndexA    [SHELL32.@]
 858  *
 859  * Returns the index of the overlay icon in the system image list.
 860  */
 861 INT WINAPI SHGetIconOverlayIndexA(LPCSTR pszIconPath, INT iIconIndex)
 862 {
 863   FIXME("%s, %d\n", debugstr_a(pszIconPath), iIconIndex);
 864
 865   return -1;
 866 }
 867
 868 /****************************************************************************
 869  * SHGetIconOverlayIndexW    [SHELL32.@]
 870  *
 871  * Returns the index of the overlay icon in the system image list.
 872  */
 873 INT WINAPI SHGetIconOverlayIndexW(LPCWSTR pszIconPath, INT iIconIndex)
 874 {
 875   FIXME("%s, %d\n", debugstr_w(pszIconPath), iIconIndex);
 876
 877   return -1;
 878 }