git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #ifdef HAVE_UNISTD_H
  26 # include <unistd.h>
  27 #endif
  28 #include "winbase.h"
  29 #include "windef.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "winreg.h"
  33 #include "wine/winuser16.h"
  34 #include "wine/winbase16.h"
  35 #include "heap.h"
  36 #include "wine/debug.h"
  37
  38 #include "shellapi.h"
  39 #include "shlguid.h"
  40 #include "pidl.h"
  41 #include "shell32_main.h"
  42 #include "undocshell.h"
  43 #include "shlwapi.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  46
  47 /********************** THE ICON CACHE ********************************/
  48
  49 #define INVALID_INDEX -1
  50
  51 typedef struct
  52 {
  53         LPSTR sSourceFile;      /* file (not path!) containing the icon */
  54         DWORD dwSourceIndex;    /* index within the file, if it is a resoure ID it will be negated */
  55         DWORD dwListIndex;      /* index within the iconlist */
  56         DWORD dwFlags;          /* GIL_* flags */
  57         DWORD dwAccessTime;
  58 } SIC_ENTRY, * LPSIC_ENTRY;
  59
  60 static HDPA             sic_hdpa = 0;
  61
  62 static CRITICAL_SECTION SHELL32_SicCS;
  63 static CRITICAL_SECTION_DEBUG critsect_debug =
  64 {
  65     0, 0, &SHELL32_SicCS,
  66     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  67       0, 0, { 0, (DWORD)(__FILE__ ": SHELL32_SicCS") }
  68 };
  69 static CRITICAL_SECTION SHELL32_SicCS = { &critsect_debug, -1, 0, 0, 0, 0 };
  70
  71 /*****************************************************************************
  72  * SIC_CompareEntries
  73  *
  74  * NOTES
  75  *  Callback for DPA_Search
  76  */
  77 static INT CALLBACK SIC_CompareEntries( LPVOID p1, LPVOID p2, LPARAM lparam)
  78 {       TRACE("%p %p %8lx\n", p1, p2, lparam);
  79
  80         if (((LPSIC_ENTRY)p1)->dwSourceIndex != ((LPSIC_ENTRY)p2)->dwSourceIndex) /* first the faster one*/
  81           return 1;
  82
  83         if (strcasecmp(((LPSIC_ENTRY)p1)->sSourceFile,((LPSIC_ENTRY)p2)->sSourceFile))
  84           return 1;
  85
  86         return 0;
  87 }
  88 /*****************************************************************************
  89  * SIC_IconAppend                       [internal]
  90  *
  91  * NOTES
  92  *  appends a icon pair to the end of the cache
  93  */
  94 static INT SIC_IconAppend (LPCSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon)
  95 {       LPSIC_ENTRY lpsice;
  96         INT ret, index, index1;
  97         char *path;
  98         TRACE("%s %i %p %p\n", sSourceFile, dwSourceIndex, hSmallIcon ,hBigIcon);
  99
 100         lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
 101
 102         path = PathFindFileNameA(sSourceFile);
 103         lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, strlen(path)+1 );
 104         strcpy( lpsice->sSourceFile, path );
 105
 106         lpsice->dwSourceIndex = dwSourceIndex;
 107
 108         EnterCriticalSection(&SHELL32_SicCS);
 109
 110         index = DPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
 111         if ( INVALID_INDEX == index )
 112         {
 113           SHFree(lpsice);
 114           ret = INVALID_INDEX;
 115         }
 116         else
 117         {
 118           index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
 119           index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
 120
 121           if (index!=index1)
 122           {
 123             FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
 124           }
 125           lpsice->dwListIndex = index;
 126           ret = lpsice->dwListIndex;
 127         }
 128
 129         LeaveCriticalSection(&SHELL32_SicCS);
 130         return ret;
 131 }
 132 /****************************************************************************
 133  * SIC_LoadIcon                         [internal]
 134  *
 135  * NOTES
 136  *  gets small/big icon by number from a file
 137  */
 138 static INT SIC_LoadIcon (LPCSTR sSourceFile, INT dwSourceIndex)
 139 {       HICON   hiconLarge=0;
 140         HICON   hiconSmall=0;
 141
 142         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, 0, 1, 0 );
 143         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, 0, 1, 0 );
 144
 145         if ( !hiconLarge ||  !hiconSmall)
 146         {
 147           WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex, sSourceFile, hiconLarge, hiconSmall);
 148           return -1;
 149         }
 150         return SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge);
 151 }
 152 /*****************************************************************************
 153  * SIC_GetIconIndex                     [internal]
 154  *
 155  * Parameters
 156  *      sSourceFile     [IN]    filename of file containing the icon
 157  *      index           [IN]    index/resID (negated) in this file
 158  *
 159  * NOTES
 160  *  look in the cache for a proper icon. if not available the icon is taken
 161  *  from the file and cached
 162  */
 163 INT SIC_GetIconIndex (LPCSTR sSourceFile, INT dwSourceIndex )
 164 {       SIC_ENTRY sice;
 165         INT ret, index = INVALID_INDEX;
 166
 167         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 168
 169         sice.sSourceFile = PathFindFileNameA(sSourceFile);
 170         sice.dwSourceIndex = dwSourceIndex;
 171
 172         EnterCriticalSection(&SHELL32_SicCS);
 173
 174         if (NULL != DPA_GetPtr (sic_hdpa, 0))
 175         {
 176           /* search linear from position 0*/
 177           index = DPA_Search (sic_hdpa, &sice, 0, SIC_CompareEntries, 0, 0);
 178         }
 179
 180         if ( INVALID_INDEX == index )
 181         {
 182           ret = SIC_LoadIcon (sSourceFile, dwSourceIndex);
 183         }
 184         else
 185         {
 186           TRACE("-- found\n");
 187           ret = ((LPSIC_ENTRY)DPA_GetPtr(sic_hdpa, index))->dwListIndex;
 188         }
 189
 190         LeaveCriticalSection(&SHELL32_SicCS);
 191         return ret;
 192 }
 193 /****************************************************************************
 194  * SIC_GetIcon                          [internal]
 195  *
 196  * NOTES
 197  *  retrieves the specified icon from the iconcache. if not found tries to load the icon
 198  */
 199 static HICON WINE_UNUSED SIC_GetIcon (LPCSTR sSourceFile, INT dwSourceIndex, BOOL bSmallIcon )
 200 {       INT index;
 201
 202         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 203
 204         index = SIC_GetIconIndex(sSourceFile, dwSourceIndex);
 205
 206         if (INVALID_INDEX == index)
 207         {
 208           return (HICON)INVALID_INDEX;
 209         }
 210
 211         if (bSmallIcon)
 212           return ImageList_GetIcon(ShellSmallIconList, index, ILD_NORMAL);
 213         return ImageList_GetIcon(ShellBigIconList, index, ILD_NORMAL);
 214
 215 }
 216 /*****************************************************************************
 217  * SIC_Initialize                       [internal]
 218  *
 219  * NOTES
 220  *  hack to load the resources from the shell32.dll under a different dll name
 221  *  will be removed when the resource-compiler is ready
 222  */
 223 BOOL SIC_Initialize(void)
 224 {
 225         HICON           hSm, hLg;
 226         UINT            index;
 227
 228         TRACE("\n");
 229
 230         if (sic_hdpa)   /* already initialized?*/
 231           return TRUE;
 232
 233         sic_hdpa = DPA_Create(16);
 234
 235         if (!sic_hdpa)
 236         {
 237           return(FALSE);
 238         }
 239
 240         ShellSmallIconList = ImageList_Create(16,16,ILC_COLORDDB | ILC_MASK,0,0x20);
 241         ShellBigIconList = ImageList_Create(32,32,ILC_COLORDDB | ILC_MASK,0,0x20);
 242
 243         ImageList_SetBkColor(ShellSmallIconList, GetSysColor(COLOR_WINDOW));
 244         ImageList_SetBkColor(ShellBigIconList, GetSysColor(COLOR_WINDOW));
 245
 246         for (index=1; index<39; index++)
 247         {
 248           hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 16, 16,LR_SHARED);
 249           hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 32, 32,LR_SHARED);
 250
 251           if(!hSm)
 252           {
 253             hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 16, 16,LR_SHARED);
 254             hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 32, 32,LR_SHARED);
 255           }
 256           SIC_IconAppend ("shell32.dll", index, hSm, hLg);
 257         }
 258
 259         TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList);
 260
 261         return TRUE;
 262 }
 263 /*************************************************************************
 264  * SIC_Destroy
 265  *
 266  * frees the cache
 267  */
 268 void SIC_Destroy(void)
 269 {
 270         LPSIC_ENTRY lpsice;
 271         int i;
 272
 273         TRACE("\n");
 274
 275         EnterCriticalSection(&SHELL32_SicCS);
 276
 277         if (sic_hdpa && NULL != DPA_GetPtr (sic_hdpa, 0))
 278         {
 279           for (i=0; i < DPA_GetPtrCount(sic_hdpa); ++i)
 280           {
 281             lpsice = DPA_GetPtr(sic_hdpa, i);
 282             SHFree(lpsice);
 283           }
 284           DPA_Destroy(sic_hdpa);
 285         }
 286
 287         sic_hdpa = NULL;
 288
 289         LeaveCriticalSection(&SHELL32_SicCS);
 290         DeleteCriticalSection(&SHELL32_SicCS);
 291 }
 292 /*************************************************************************
 293  * Shell_GetImageList                   [SHELL32.71]
 294  *
 295  * PARAMETERS
 296  *  imglist[1|2] [OUT] pointer which recive imagelist handles
 297  *
 298  */
 299 BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList)
 300 {       TRACE("(%p,%p)\n",lpBigList,lpSmallList);
 301         if (lpBigList)
 302         { *lpBigList = ShellBigIconList;
 303         }
 304         if (lpSmallList)
 305         { *lpSmallList = ShellSmallIconList;
 306         }
 307
 308         return TRUE;
 309 }
 310 /*************************************************************************
 311  * PidlToSicIndex                       [INTERNAL]
 312  *
 313  * PARAMETERS
 314  *      sh      [IN]    IShellFolder
 315  *      pidl    [IN]
 316  *      bBigIcon [IN]
 317  *      uFlags  [IN]    GIL_*
 318  *      pIndex  [OUT]   index within the SIC
 319  *
 320  */
 321 BOOL PidlToSicIndex (
 322         IShellFolder * sh,
 323         LPITEMIDLIST pidl,
 324         BOOL bBigIcon,
 325         UINT uFlags,
 326         UINT * pIndex)
 327 {
 328         IExtractIconA   *ei;
 329         char            szIconFile[MAX_PATH];   /* file containing the icon */
 330         INT             iSourceIndex;           /* index or resID(negated) in this file */
 331         BOOL            ret = FALSE;
 332         UINT            dwFlags = 0;
 333
 334         TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
 335
 336         if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconA, 0, (void **)&ei)))
 337         {
 338           if (SUCCEEDED(IExtractIconA_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
 339           {
 340             *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex);
 341             ret = TRUE;
 342           }
 343           IExtractIconA_Release(ei);
 344         }
 345
 346         if (INVALID_INDEX == *pIndex)   /* default icon when failed */
 347           *pIndex = 1;
 348
 349         return ret;
 350
 351 }
 352
 353 /*************************************************************************
 354  * SHMapPIDLToSystemImageListIndex      [SHELL32.77]
 355  *
 356  * PARAMETERS
 357  *      sh      [IN]            pointer to an instance of IShellFolder
 358  *      pidl    [IN]
 359  *      pIndex  [OUT][OPTIONAL] SIC index for big icon
 360  *
 361  */
 362 int WINAPI SHMapPIDLToSystemImageListIndex(
 363         LPSHELLFOLDER sh,
 364         LPCITEMIDLIST pidl,
 365         UINT * pIndex)
 366 {
 367         UINT    Index;
 368
 369         TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
 370         pdump(pidl);
 371
 372         if (pIndex)
 373           PidlToSicIndex ( sh, pidl, 1, 0, pIndex);
 374         PidlToSicIndex ( sh, pidl, 0, 0, &Index);
 375         return Index;
 376 }
 377
 378 /*************************************************************************
 379  * Shell_GetCachedImageIndex            [SHELL32.72]
 380  *
 381  */
 382 INT WINAPI Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc)
 383 {
 384         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
 385         return SIC_GetIconIndex(szPath, nIndex);
 386 }
 387
 388 INT WINAPI Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc)
 389 {       INT ret;
 390         LPSTR sTemp = HEAP_strdupWtoA (GetProcessHeap(),0,szPath);
 391
 392         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
 393
 394         ret = SIC_GetIconIndex(sTemp, nIndex);
 395         HeapFree(GetProcessHeap(),0,sTemp);
 396         return ret;
 397 }
 398
 399 INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
 400 {       if( SHELL_OsIsUnicode())
 401           return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc);
 402         return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc);
 403 }
 404
 405 /*************************************************************************
 406  * ExtractIconEx                        [SHELL32.@]
 407  */
 408 UINT WINAPI ExtractIconExAW(LPCVOID lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 409 {       if (SHELL_OsIsUnicode())
 410           return ExtractIconExW ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 411         return ExtractIconExA ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 412 }
 413
 414 /*************************************************************************
 415  * ExtractIconExW                       [SHELL32.@]
 416  * RETURNS:
 417  *  0 no icon found
 418  *  -1 file is not valid
 419  *  or number of icons extracted
 420  */
 421 UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 422 {
 423         TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons);
 424
 425         return PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 426 }
 427
 428 /*************************************************************************
 429  * ExtractIconExA                       [SHELL32.@]
 430  */
 431 UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 432 {
 433     UINT ret;
 434     INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
 435     LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 436
 437     TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 438
 439     MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
 440     ret = ExtractIconExW (lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 441     HeapFree(GetProcessHeap(), 0, lpwstrFile);
 442     return ret;
 443 }
 444
 445 /*************************************************************************
 446  *                              ExtractAssociatedIconA (SHELL32.@)
 447  *
 448  * Return icon for given file (either from file itself or from associated
 449  * executable) and patch parameters if needed.
 450  */
 451 HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
 452 {
 453         HICON hIcon;
 454         WORD wDummyIcon = 0;
 455
 456         TRACE("\n");
 457
 458         if(lpiIcon == NULL)
 459             lpiIcon = &wDummyIcon;
 460
 461         hIcon = ExtractIconA(hInst, lpIconPath, *lpiIcon);
 462
 463         if( hIcon < (HICON)2 )
 464         { if( hIcon == (HICON)1 ) /* no icons found in given file */
 465           { char  tempPath[0x80];
 466             HINSTANCE uRet = FindExecutableA(lpIconPath,NULL,tempPath);
 467
 468             if( uRet > (HINSTANCE)32 && tempPath[0] )
 469             { strcpy(lpIconPath,tempPath);
 470               hIcon = ExtractIconA(hInst, lpIconPath, *lpiIcon);
 471               if( hIcon > (HICON)2 )
 472                 return hIcon;
 473             }
 474             else hIcon = 0;
 475           }
 476
 477           if( hIcon == (HICON)1 )
 478             *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
 479           else
 480             *lpiIcon = 6;   /* generic icon - found nothing */
 481
 482           GetModuleFileNameA(hInst, lpIconPath, 0x80);
 483           hIcon = LoadIconA( hInst, MAKEINTRESOURCEA(*lpiIcon));
 484         }
 485         return hIcon;
 486 }
 487
 488 /*************************************************************************
 489  *                              ExtractAssociatedIconExW (SHELL32.@)
 490  *
 491  * Return icon for given file (either from file itself or from associated
 492  * executable) and patch parameters if needed.
 493  */
 494 HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 495 {
 496   FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId);
 497   return 0;
 498 }
 499
 500 /*************************************************************************
 501  *                              ExtractAssociatedIconExA (SHELL32.@)
 502  *
 503  * Return icon for given file (either from file itself or from associated
 504  * executable) and patch parameters if needed.
 505  */
 506 HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 507 {
 508   HICON ret;
 509   INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 );
 510   LPWSTR lpwstrFile = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 511
 512   TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId);
 513
 514   MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len );
 515   ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId);
 516   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 517   return ret;
 518 }
 519
 520
 521 /****************************************************************************
 522  * SHDefExtractIconW            [SHELL32.@]
 523  */
 524 HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags,
 525                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 526 {
 527         UINT ret;
 528         HICON hIcons[2];
 529         WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 530
 531         ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR);
 532         /* FIXME: deal with uFlags parameter which contains GIL_ flags */
 533         if (ret == 0xFFFFFFFF)
 534           return E_FAIL;
 535         if (ret > 0) {
 536           *phiconLarge = hIcons[0];
 537           *phiconSmall = hIcons[1];
 538           return S_OK;
 539         }
 540         return S_FALSE;
 541 }
 542
 543 /****************************************************************************
 544  * SHDefExtractIconA            [SHELL32.@]
 545  */
 546 HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags,
 547                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 548 {
 549   HRESULT ret;
 550   INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0);
 551   LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 552
 553   TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 554
 555   MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len);
 556   ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 557   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 558   return ret;
 559 }