git.oblomov.eu Git - wine/blob - dlls/shell32/iconcache.c

   1 /*
   2  *      shell icon cache (SIC)
   3  *
   4  */
   5 #include <string.h>
   6 #include <sys/types.h>
   7 #include <unistd.h>
   8 #include "winbase.h"
   9 #include "windef.h"
  10 #include "wingdi.h"
  11 #include "winuser.h"
  12 #include "wine/winuser16.h"
  13 #include "wine/winbase16.h"
  14 #include "heap.h"
  15 #include "debugtools.h"
  16
  17 #include "shellapi.h"
  18 #include "shlguid.h"
  19 #include "pidl.h"
  20 #include "shell32_main.h"
  21 #include "undocshell.h"
  22 #include "shlwapi.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(shell);
  25
  26 /********************** THE ICON CACHE ********************************/
  27
  28 #define INVALID_INDEX -1
  29
  30 typedef struct
  31 {
  32         LPSTR sSourceFile;      /* file (not path!) containing the icon */
  33         DWORD dwSourceIndex;    /* index within the file, if it is a resoure ID it will be negated */
  34         DWORD dwListIndex;      /* index within the iconlist */
  35         DWORD dwFlags;          /* GIL_* flags */
  36         DWORD dwAccessTime;
  37 } SIC_ENTRY, * LPSIC_ENTRY;
  38
  39 static HDPA             sic_hdpa = 0;
  40 static CRITICAL_SECTION SHELL32_SicCS = CRITICAL_SECTION_INIT("SHELL32_SicCS");
  41
  42 /*****************************************************************************
  43  * SIC_CompareEntrys                    [called by comctl32.dll]
  44  *
  45  * NOTES
  46  *  Callback for DPA_Search
  47  */
  48 INT CALLBACK SIC_CompareEntrys( LPVOID p1, LPVOID p2, LPARAM lparam)
  49 {       TRACE("%p %p\n", p1, p2);
  50
  51         if (((LPSIC_ENTRY)p1)->dwSourceIndex != ((LPSIC_ENTRY)p2)->dwSourceIndex) /* first the faster one*/
  52           return 1;
  53
  54         if (strcasecmp(((LPSIC_ENTRY)p1)->sSourceFile,((LPSIC_ENTRY)p2)->sSourceFile))
  55           return 1;
  56
  57         return 0;
  58 }
  59 /*****************************************************************************
  60  * SIC_IconAppend                       [internal]
  61  *
  62  * NOTES
  63  *  appends a icon pair to the end of the cache
  64  */
  65 static INT SIC_IconAppend (LPCSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon)
  66 {       LPSIC_ENTRY lpsice;
  67         INT ret, index, index1;
  68         char *path;
  69         TRACE("%s %i %x %x\n", sSourceFile, dwSourceIndex, hSmallIcon ,hBigIcon);
  70
  71         lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
  72
  73         path = PathFindFileNameA(sSourceFile);
  74         lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, strlen(path)+1 );
  75         strcpy( lpsice->sSourceFile, path );
  76
  77         lpsice->dwSourceIndex = dwSourceIndex;
  78
  79         EnterCriticalSection(&SHELL32_SicCS);
  80
  81         index = pDPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
  82         if ( INVALID_INDEX == index )
  83         {
  84           SHFree(lpsice);
  85           ret = INVALID_INDEX;
  86         }
  87         else
  88         {
  89           index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
  90           index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
  91
  92           if (index!=index1)
  93           {
  94             FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
  95           }
  96           lpsice->dwListIndex = index;
  97           ret = lpsice->dwListIndex;
  98         }
  99
 100         LeaveCriticalSection(&SHELL32_SicCS);
 101         return ret;
 102 }
 103 /****************************************************************************
 104  * SIC_LoadIcon                         [internal]
 105  *
 106  * NOTES
 107  *  gets small/big icon by number from a file
 108  */
 109 static INT SIC_LoadIcon (LPCSTR sSourceFile, INT dwSourceIndex)
 110 {       HICON   hiconLarge=0;
 111         HICON   hiconSmall=0;
 112
 113         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, 0, 1, 0 );
 114         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, 0, 1, 0 );
 115
 116         if ( !hiconLarge ||  !hiconSmall)
 117         {
 118           WARN("failure loading icon %i from %s (%x %x)\n", dwSourceIndex, sSourceFile, hiconLarge, hiconSmall);
 119           return -1;
 120         }
 121         return SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge);
 122 }
 123 /*****************************************************************************
 124  * SIC_GetIconIndex                     [internal]
 125  *
 126  * Parameters
 127  *      sSourceFile     [IN]    filename of file containing the icon
 128  *      index           [IN]    index/resID (negated) in this file
 129  *
 130  * NOTES
 131  *  look in the cache for a proper icon. if not available the icon is taken
 132  *  from the file and cached
 133  */
 134 INT SIC_GetIconIndex (LPCSTR sSourceFile, INT dwSourceIndex )
 135 {       SIC_ENTRY sice;
 136         INT ret, index = INVALID_INDEX;
 137
 138         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 139
 140         sice.sSourceFile = PathFindFileNameA(sSourceFile);
 141         sice.dwSourceIndex = dwSourceIndex;
 142
 143         EnterCriticalSection(&SHELL32_SicCS);
 144
 145         if (NULL != pDPA_GetPtr (sic_hdpa, 0))
 146         {
 147           index = pDPA_Search (sic_hdpa, &sice, -1L, SIC_CompareEntrys, 0, 0);
 148         }
 149
 150         if ( INVALID_INDEX == index )
 151         {
 152           ret = SIC_LoadIcon (sSourceFile, dwSourceIndex);
 153         }
 154         else
 155         {
 156           TRACE("-- found\n");
 157           ret = ((LPSIC_ENTRY)pDPA_GetPtr(sic_hdpa, index))->dwListIndex;
 158         }
 159
 160         LeaveCriticalSection(&SHELL32_SicCS);
 161         return ret;
 162 }
 163 /****************************************************************************
 164  * SIC_GetIcon                          [internal]
 165  *
 166  * NOTES
 167  *  retrives the specified icon from the iconcache. if not found try's to load the icon
 168  */
 169 static HICON WINE_UNUSED SIC_GetIcon (LPCSTR sSourceFile, INT dwSourceIndex, BOOL bSmallIcon )
 170 {       INT index;
 171
 172         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 173
 174         index = SIC_GetIconIndex(sSourceFile, dwSourceIndex);
 175
 176         if (INVALID_INDEX == index)
 177         {
 178           return INVALID_INDEX;
 179         }
 180
 181         if (bSmallIcon)
 182           return ImageList_GetIcon(ShellSmallIconList, index, ILD_NORMAL);
 183         return ImageList_GetIcon(ShellBigIconList, index, ILD_NORMAL);
 184
 185 }
 186 /*****************************************************************************
 187  * SIC_Initialize                       [internal]
 188  *
 189  * NOTES
 190  *  hack to load the resources from the shell32.dll under a different dll name
 191  *  will be removed when the resource-compiler is ready
 192  */
 193 BOOL SIC_Initialize(void)
 194 {
 195         HICON           hSm, hLg;
 196         UINT            index;
 197
 198         TRACE("\n");
 199
 200         if (sic_hdpa)   /* already initialized?*/
 201           return TRUE;
 202
 203         sic_hdpa = pDPA_Create(16);
 204
 205         if (!sic_hdpa)
 206         {
 207           return(FALSE);
 208         }
 209
 210         ShellSmallIconList = ImageList_Create(16,16,ILC_COLORDDB | ILC_MASK,0,0x20);
 211         ShellBigIconList = ImageList_Create(32,32,ILC_COLORDDB | ILC_MASK,0,0x20);
 212
 213         ImageList_SetBkColor(ShellSmallIconList, GetSysColor(COLOR_WINDOW));
 214         ImageList_SetBkColor(ShellBigIconList, GetSysColor(COLOR_WINDOW));
 215
 216         for (index=1; index<39; index++)
 217         {
 218           hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 16, 16,LR_SHARED);
 219           hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 32, 32,LR_SHARED);
 220
 221           if(!hSm)
 222           {
 223             hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 16, 16,LR_SHARED);
 224             hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 32, 32,LR_SHARED);
 225           }
 226           SIC_IconAppend ("shell32.dll", index, hSm, hLg);
 227         }
 228
 229         TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList);
 230
 231         return TRUE;
 232 }
 233 /*************************************************************************
 234  * SIC_Destroy
 235  *
 236  * frees the cache
 237  */
 238 void SIC_Destroy(void)
 239 {
 240         LPSIC_ENTRY lpsice;
 241         int i;
 242
 243         TRACE("\n");
 244
 245         EnterCriticalSection(&SHELL32_SicCS);
 246
 247         if (sic_hdpa && NULL != pDPA_GetPtr (sic_hdpa, 0))
 248         {
 249           for (i=0; i < pDPA_GetPtrCount(sic_hdpa); ++i)
 250           {
 251             lpsice = pDPA_GetPtr(sic_hdpa, i);
 252             SHFree(lpsice);
 253           }
 254           pDPA_Destroy(sic_hdpa);
 255         }
 256
 257         sic_hdpa = NULL;
 258
 259         LeaveCriticalSection(&SHELL32_SicCS);
 260         DeleteCriticalSection(&SHELL32_SicCS);
 261 }
 262 /*************************************************************************
 263  * Shell_GetImageList                   [SHELL32.71]
 264  *
 265  * PARAMETERS
 266  *  imglist[1|2] [OUT] pointer which recive imagelist handles
 267  *
 268  */
 269 BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList)
 270 {       TRACE("(%p,%p)\n",lpBigList,lpSmallList);
 271         if (lpBigList)
 272         { *lpBigList = ShellBigIconList;
 273         }
 274         if (lpSmallList)
 275         { *lpSmallList = ShellSmallIconList;
 276         }
 277
 278         return TRUE;
 279 }
 280 /*************************************************************************
 281  * PidlToSicIndex                       [INTERNAL]
 282  *
 283  * PARAMETERS
 284  *      sh      [IN]    IShellFolder
 285  *      pidl    [IN]
 286  *      bBigIcon [IN]
 287  *      uFlags  [IN]    GIL_*
 288  *      pIndex  [OUT]   index within the SIC
 289  *
 290  */
 291 BOOL PidlToSicIndex (
 292         IShellFolder * sh,
 293         LPITEMIDLIST pidl,
 294         BOOL bBigIcon,
 295         UINT uFlags,
 296         UINT * pIndex)
 297 {
 298         IExtractIconA   *ei;
 299         char            szIconFile[MAX_PATH];   /* file containing the icon */
 300         INT             iSourceIndex;           /* index or resID(negated) in this file */
 301         BOOL            ret = FALSE;
 302         UINT            dwFlags = 0;
 303
 304         TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
 305
 306         if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconA, 0, (void **)&ei)))
 307         {
 308           if (SUCCEEDED(IExtractIconA_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
 309           {
 310             *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex);
 311             ret = TRUE;
 312           }
 313           IExtractIconA_Release(ei);
 314         }
 315
 316         if (INVALID_INDEX == *pIndex)   /* default icon when failed */
 317           *pIndex = 1;
 318
 319         return ret;
 320
 321 }
 322
 323 /*************************************************************************
 324  * SHMapPIDLToSystemImageListIndex      [SHELL32.77]
 325  *
 326  * PARAMETERS
 327  *      sh      [IN]            pointer to an instance of IShellFolder
 328  *      pidl    [IN]
 329  *      pIndex  [OUT][OPTIONAL] SIC index for big icon
 330  *
 331  */
 332 int WINAPI SHMapPIDLToSystemImageListIndex(
 333         LPSHELLFOLDER sh,
 334         LPCITEMIDLIST pidl,
 335         UINT * pIndex)
 336 {
 337         UINT    Index;
 338
 339         TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
 340         pdump(pidl);
 341
 342         if (pIndex)
 343           PidlToSicIndex ( sh, pidl, 1, 0, pIndex);
 344         PidlToSicIndex ( sh, pidl, 0, 0, &Index);
 345         return Index;
 346 }
 347
 348 /*************************************************************************
 349  * Shell_GetCachedImageIndex            [SHELL32.72]
 350  *
 351  */
 352 INT WINAPI Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc)
 353 {
 354         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
 355         return SIC_GetIconIndex(szPath, nIndex);
 356 }
 357
 358 INT WINAPI Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc)
 359 {       INT ret;
 360         LPSTR sTemp = HEAP_strdupWtoA (GetProcessHeap(),0,szPath);
 361
 362         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
 363
 364         ret = SIC_GetIconIndex(sTemp, nIndex);
 365         HeapFree(GetProcessHeap(),0,sTemp);
 366         return ret;
 367 }
 368
 369 INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
 370 {       if( SHELL_OsIsUnicode())
 371           return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc);
 372         return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc);
 373 }
 374
 375 /*************************************************************************
 376  * ExtractIconEx                        [SHELL32.@]
 377  */
 378 HICON WINAPI ExtractIconExAW ( LPCVOID lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons )
 379 {       if (SHELL_OsIsUnicode())
 380           return ExtractIconExW ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 381         return ExtractIconExA ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 382 }
 383 /*************************************************************************
 384  * ExtractIconExA                       [SHELL32.@]
 385  * RETURNS
 386  *  0 no icon found
 387  *  1 file is not valid
 388  *  HICON handle of a icon (phiconLarge/Small == NULL)
 389  */
 390 HICON WINAPI ExtractIconExA ( LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons )
 391 {       HICON ret=0;
 392
 393         TRACE("file=%s idx=%i %p %p num=%i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons );
 394
 395         if (nIconIndex==-1)     /* Number of icons requested */
 396             return PrivateExtractIconsA( lpszFile, -1, 0, 0, NULL, 0, 0, 0 );
 397
 398         if (phiconLarge)
 399         {
 400           ret = PrivateExtractIconsA( lpszFile, nIconIndex, 32, 32, phiconLarge, 0, nIcons, 0 );
 401           if ( nIcons==1)
 402           { ret = phiconLarge[0];
 403           }
 404         }
 405
 406         /* if no pointers given and one icon expected, return the handle directly*/
 407         if (!phiconLarge && ! phiconSmall && nIcons==1 )
 408           phiconSmall = &ret;
 409
 410         if (phiconSmall)
 411         {
 412           ret = PrivateExtractIconsA( lpszFile, nIconIndex, 16, 16, phiconSmall, 0, nIcons, 0 );
 413           if ( nIcons==1 )
 414           { ret = phiconSmall[0];
 415           }
 416         }
 417
 418         return ret;
 419 }
 420 /*************************************************************************
 421  * ExtractIconExW                       [SHELL32.@]
 422  */
 423 HICON WINAPI ExtractIconExW ( LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons )
 424 {       LPSTR sFile;
 425         DWORD ret;
 426
 427         TRACE("file=%s idx=%i %p %p num=%i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons );
 428
 429         sFile = HEAP_strdupWtoA (GetProcessHeap(),0,lpszFile);
 430         ret = ExtractIconExA ( sFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 431         HeapFree(GetProcessHeap(),0,sFile);
 432         return ret;
 433 }