ReactOS 0.4.15-dev-7076-gc00d41d
iconcache.cpp
Go to the documentation of this file.
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 "precomp.h"
22
24
25/********************** THE ICON CACHE ********************************/
26
27#define INVALID_INDEX -1
28
29typedef struct
30{
31 LPWSTR sSourceFile; /* file (not path!) containing the icon */
32 DWORD dwSourceIndex; /* index within the file, if it is a resoure ID it will be negated */
33 DWORD dwListIndex; /* index within the iconlist */
34 DWORD dwFlags; /* GIL_* flags */
37
38static HDPA sic_hdpa = 0;
39
42
43namespace
44{
47{
48 0, 0, &SHELL32_SicCS,
50 0, 0, { (DWORD_PTR)(__FILE__ ": SHELL32_SicCS") }
51};
53}
54
55/*****************************************************************************
56 * SIC_CompareEntries
57 *
58 * NOTES
59 * Callback for DPA_Search
60 */
62{ LPSIC_ENTRY e1 = (LPSIC_ENTRY)p1, e2 = (LPSIC_ENTRY)p2;
63
64 TRACE("%p %p %8lx\n", p1, p2, lparam);
65
66 /* Icons in the cache are keyed by the name of the file they are
67 * loaded from, their resource index and the fact if they have a shortcut
68 * icon overlay or not.
69 */
70 /* first the faster one */
71 if (e1->dwSourceIndex != e2->dwSourceIndex)
72 return (e1->dwSourceIndex < e2->dwSourceIndex) ? -1 : 1;
73
74 if ((e1->dwFlags & GIL_FORSHORTCUT) != (e2->dwFlags & GIL_FORSHORTCUT))
75 return ((e1->dwFlags & GIL_FORSHORTCUT) < (e2->dwFlags & GIL_FORSHORTCUT)) ? -1 : 1;
76
77 return wcsicmp(e1->sSourceFile,e2->sSourceFile);
78}
79
80/* declare SIC_LoadOverlayIcon() */
81static int SIC_LoadOverlayIcon(int icon_idx);
82
83/*****************************************************************************
84 * SIC_OverlayShortcutImage [internal]
85 *
86 * NOTES
87 * Creates a new icon as a copy of the passed-in icon, overlayed with a
88 * shortcut image.
89 * FIXME: This should go to the ImageList implementation!
90 */
91static HICON SIC_OverlayShortcutImage(HICON SourceIcon, BOOL large)
92{
93 ICONINFO ShortcutIconInfo, TargetIconInfo;
94 HICON ShortcutIcon = NULL, TargetIcon;
95 BITMAP TargetBitmapInfo, ShortcutBitmapInfo;
96 HDC ShortcutDC = NULL,
97 TargetDC = NULL;
98 HBITMAP OldShortcutBitmap = NULL,
99 OldTargetBitmap = NULL;
100
101 static int s_imgListIdx = -1;
102 ZeroMemory(&ShortcutIconInfo, sizeof(ShortcutIconInfo));
103 ZeroMemory(&TargetIconInfo, sizeof(TargetIconInfo));
104
105 /* Get information about the source icon and shortcut overlay.
106 * We will write over the source bitmaps to get the final ones */
107 if (! GetIconInfo(SourceIcon, &TargetIconInfo))
108 return NULL;
109
110 /* Is it possible with the ImageList implementation? */
111 if(!TargetIconInfo.hbmColor)
112 {
113 /* Maybe we'll support this at some point */
114 FIXME("1bpp icon wants its overlay!\n");
115 goto fail;
116 }
117
118 if(!GetObjectW(TargetIconInfo.hbmColor, sizeof(BITMAP), &TargetBitmapInfo))
119 {
120 goto fail;
121 }
122
123 /* search for the shortcut icon only once */
124 if (s_imgListIdx == -1)
125 s_imgListIdx = SIC_LoadOverlayIcon(- IDI_SHELL_SHORTCUT);
126 /* FIXME should use icon index 29 instead of the
127 resource id, but not all icons are present yet
128 so we can't use icon indices */
129
130 if (s_imgListIdx != -1)
131 {
132 if (large)
133 ShortcutIcon = ImageList_GetIcon(ShellBigIconList, s_imgListIdx, ILD_TRANSPARENT);
134 else
135 ShortcutIcon = ImageList_GetIcon(ShellSmallIconList, s_imgListIdx, ILD_TRANSPARENT);
136 } else
137 ShortcutIcon = NULL;
138
139 if (!ShortcutIcon || !GetIconInfo(ShortcutIcon, &ShortcutIconInfo))
140 {
141 goto fail;
142 }
143
144 /* Is it possible with the ImageLists ? */
145 if(!ShortcutIconInfo.hbmColor)
146 {
147 /* Maybe we'll support this at some point */
148 FIXME("Should draw 1bpp overlay!\n");
149 goto fail;
150 }
151
152 if(!GetObjectW(ShortcutIconInfo.hbmColor, sizeof(BITMAP), &ShortcutBitmapInfo))
153 {
154 goto fail;
155 }
156
157 /* Setup the masks */
158 ShortcutDC = CreateCompatibleDC(NULL);
159 if (NULL == ShortcutDC) goto fail;
160 OldShortcutBitmap = (HBITMAP)SelectObject(ShortcutDC, ShortcutIconInfo.hbmMask);
161 if (NULL == OldShortcutBitmap) goto fail;
162
163 TargetDC = CreateCompatibleDC(NULL);
164 if (NULL == TargetDC) goto fail;
165 OldTargetBitmap = (HBITMAP)SelectObject(TargetDC, TargetIconInfo.hbmMask);
166 if (NULL == OldTargetBitmap) goto fail;
167
168 /* Create the complete mask by ANDing the source and shortcut masks.
169 * NOTE: in an ImageList, all icons have the same dimensions */
170 if (!BitBlt(TargetDC, 0, 0, ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight,
171 ShortcutDC, 0, 0, SRCAND))
172 {
173 goto fail;
174 }
175
176 /*
177 * We must remove or add the alpha component to the shortcut overlay:
178 * If we don't, SRCCOPY will copy it to our resulting icon, resulting in a
179 * partially transparent icons where it shouldn't be, and to an invisible icon
180 * if the underlying icon don't have any alpha channel information. (16bpp only icon for instance).
181 * But if the underlying icon has alpha channel information, then we must mark the overlay information
182 * as opaque.
183 * NOTE: This code sucks(tm) and should belong to the ImageList implementation.
184 * NOTE2: there are better ways to do this.
185 */
186 if(ShortcutBitmapInfo.bmBitsPixel == 32)
187 {
188 BOOL add_alpha;
189 BYTE buffer[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
190 BITMAPINFO* lpbmi = (BITMAPINFO*)buffer;
191 PVOID bits;
192 PULONG pixel;
193 INT i, j;
194
195 /* Find if the source bitmap has an alpha channel */
196 if(TargetBitmapInfo.bmBitsPixel != 32) add_alpha = FALSE;
197 else
198 {
199 ZeroMemory(buffer, sizeof(buffer));
200 lpbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
201 lpbmi->bmiHeader.biWidth = TargetBitmapInfo.bmWidth;
202 lpbmi->bmiHeader.biHeight = TargetBitmapInfo.bmHeight;
203 lpbmi->bmiHeader.biPlanes = 1;
204 lpbmi->bmiHeader.biBitCount = 32;
205
206 bits = HeapAlloc(GetProcessHeap(), 0, TargetBitmapInfo.bmHeight * TargetBitmapInfo.bmWidthBytes);
207
208 if(!bits) goto fail;
209
210 if(!GetDIBits(TargetDC, TargetIconInfo.hbmColor, 0, TargetBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS))
211 {
212 ERR("GetBIBits failed!\n");
214 goto fail;
215 }
216
217 i = j = 0;
218 pixel = (PULONG)bits;
219
220 for(i=0; i<TargetBitmapInfo.bmHeight; i++)
221 {
222 for(j=0; j<TargetBitmapInfo.bmWidth; j++)
223 {
224 add_alpha = (*pixel++ & 0xFF000000) != 0;
225 if(add_alpha) break;
226 }
227 if(add_alpha) break;
228 }
230 }
231
232 /* Allocate the bits */
233 bits = HeapAlloc(GetProcessHeap(), 0, ShortcutBitmapInfo.bmHeight*ShortcutBitmapInfo.bmWidthBytes);
234 if(!bits) goto fail;
235
236 ZeroMemory(buffer, sizeof(buffer));
237 lpbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
238 lpbmi->bmiHeader.biWidth = ShortcutBitmapInfo.bmWidth;
239 lpbmi->bmiHeader.biHeight = ShortcutBitmapInfo.bmHeight;
240 lpbmi->bmiHeader.biPlanes = 1;
241 lpbmi->bmiHeader.biBitCount = 32;
242
243 if(!GetDIBits(TargetDC, ShortcutIconInfo.hbmColor, 0, ShortcutBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS))
244 {
245 ERR("GetBIBits failed!\n");
247 goto fail;
248 }
249
250 pixel = (PULONG)bits;
251 /* Remove alpha channel component or make it totally opaque */
252 for(i=0; i<ShortcutBitmapInfo.bmHeight; i++)
253 {
254 for(j=0; j<ShortcutBitmapInfo.bmWidth; j++)
255 {
256 if(add_alpha) *pixel++ |= 0xFF000000;
257 else *pixel++ &= 0x00FFFFFF;
258 }
259 }
260
261 /* GetDIBits return BI_BITFIELDS with masks set to 0, and SetDIBits fails when masks are 0. The irony... */
263
264 /* Set the bits again */
265 if(!SetDIBits(TargetDC, ShortcutIconInfo.hbmColor, 0, ShortcutBitmapInfo.bmHeight, bits, lpbmi, DIB_RGB_COLORS))
266 {
267 ERR("SetBIBits failed!, %lu\n", GetLastError());
269 goto fail;
270 }
272 }
273
274 /* Now do the copy. We overwrite the original icon data */
275 if (NULL == SelectObject(ShortcutDC, ShortcutIconInfo.hbmColor) ||
276 NULL == SelectObject(TargetDC, TargetIconInfo.hbmColor))
277 goto fail;
278 if (!MaskBlt(TargetDC, 0, 0, ShortcutBitmapInfo.bmWidth, ShortcutBitmapInfo.bmHeight,
279 ShortcutDC, 0, 0, ShortcutIconInfo.hbmMask, 0, 0,
280 MAKEROP4(0xAA0000, SRCCOPY)))
281 {
282 goto fail;
283 }
284
285 /* Clean up, we're not goto'ing to 'fail' after this so we can be lazy and not set
286 handles to NULL */
287 SelectObject(TargetDC, OldTargetBitmap);
288 DeleteDC(TargetDC);
289 SelectObject(ShortcutDC, OldShortcutBitmap);
290 DeleteDC(ShortcutDC);
291
292 /* Create the icon using the bitmaps prepared earlier */
293 TargetIcon = CreateIconIndirect(&TargetIconInfo);
294
295 /* CreateIconIndirect copies the bitmaps, so we can release our bitmaps now */
296 DeleteObject(TargetIconInfo.hbmColor);
297 DeleteObject(TargetIconInfo.hbmMask);
298 /* Delete what GetIconInfo gave us */
299 DeleteObject(ShortcutIconInfo.hbmColor);
300 DeleteObject(ShortcutIconInfo.hbmMask);
301 DestroyIcon(ShortcutIcon);
302
303 return TargetIcon;
304
305fail:
306 /* Clean up scratch resources we created */
307 if (NULL != OldTargetBitmap) SelectObject(TargetDC, OldTargetBitmap);
308 if (NULL != TargetDC) DeleteDC(TargetDC);
309 if (NULL != OldShortcutBitmap) SelectObject(ShortcutDC, OldShortcutBitmap);
310 if (NULL != ShortcutDC) DeleteDC(ShortcutDC);
311 if (NULL != TargetIconInfo.hbmColor) DeleteObject(TargetIconInfo.hbmColor);
312 if (NULL != TargetIconInfo.hbmMask) DeleteObject(TargetIconInfo.hbmMask);
313 if (NULL != ShortcutIconInfo.hbmColor) DeleteObject(ShortcutIconInfo.hbmColor);
314 if (NULL != ShortcutIconInfo.hbmMask) DeleteObject(ShortcutIconInfo.hbmMask);
315 if (NULL != ShortcutIcon) DestroyIcon(ShortcutIcon);
316
317 return NULL;
318}
319
320/*****************************************************************************
321 * SIC_IconAppend [internal]
322 *
323 * NOTES
324 * appends an icon pair to the end of the cache
325 */
326static INT SIC_IconAppend (LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags)
327{
328 LPSIC_ENTRY lpsice;
329 INT ret, index, index1, indexDPA;
331 TRACE("%s %i %p %p\n", debugstr_w(sSourceFile), dwSourceIndex, hSmallIcon ,hBigIcon);
332
333 lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
334
335 GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
336 lpsice->sSourceFile = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, (wcslen(path)+1)*sizeof(WCHAR) );
337 wcscpy( lpsice->sSourceFile, path );
338
339 lpsice->dwSourceIndex = dwSourceIndex;
340 lpsice->dwFlags = dwFlags;
341
343
345 indexDPA = DPA_InsertPtr(sic_hdpa, indexDPA, lpsice);
346 if ( -1 == indexDPA )
347 {
349 goto leave;
350 }
351
353 index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
354
355 /* Something went wrong when allocating a new image in the list. Abort. */
356 if((index == -1) || (index1 == -1))
357 {
358 WARN("Something went wrong when adding the icon to the list: small - 0x%x, big - 0x%x.\n",
359 index, index1);
361 if(index1 != -1) ImageList_Remove(ShellBigIconList, index1);
363 goto leave;
364 }
365
366 if (index!=index1)
367 {
368 FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
369 /* What to do ???? */
370 }
371 lpsice->dwListIndex = index;
372 ret = lpsice->dwListIndex;
373
374leave:
375 if(ret == INVALID_INDEX)
376 {
377 if(indexDPA != -1) DPA_DeletePtr(sic_hdpa, indexDPA);
378 HeapFree(GetProcessHeap(), 0, lpsice->sSourceFile);
379 SHFree(lpsice);
380 }
382 return ret;
383}
384/****************************************************************************
385 * SIC_LoadIcon [internal]
386 *
387 * NOTES
388 * gets small/big icon by number from a file
389 */
390static INT SIC_LoadIcon (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags)
391{
392 HICON hiconLarge=0;
393 HICON hiconSmall=0;
394 UINT ret;
395
396 PrivateExtractIconsW(sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, NULL, 1, LR_COPYFROMRESOURCE);
397 PrivateExtractIconsW(sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, NULL, 1, LR_COPYFROMRESOURCE);
398
399 if ( !hiconLarge || !hiconSmall)
400 {
401 WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex, debugstr_w(sSourceFile), hiconLarge, hiconSmall);
402 if(hiconLarge) DestroyIcon(hiconLarge);
403 if(hiconSmall) DestroyIcon(hiconSmall);
404 return INVALID_INDEX;
405 }
406
407 if (0 != (dwFlags & GIL_FORSHORTCUT))
408 {
409 HICON hiconLargeShortcut = SIC_OverlayShortcutImage(hiconLarge, TRUE);
410 HICON hiconSmallShortcut = SIC_OverlayShortcutImage(hiconSmall, FALSE);
411 if (NULL != hiconLargeShortcut && NULL != hiconSmallShortcut)
412 {
413 DestroyIcon(hiconLarge);
414 DestroyIcon(hiconSmall);
415 hiconLarge = hiconLargeShortcut;
416 hiconSmall = hiconSmallShortcut;
417 }
418 else
419 {
420 WARN("Failed to create shortcut overlayed icons\n");
421 if (NULL != hiconLargeShortcut) DestroyIcon(hiconLargeShortcut);
422 if (NULL != hiconSmallShortcut) DestroyIcon(hiconSmallShortcut);
423 dwFlags &= ~ GIL_FORSHORTCUT;
424 }
425 }
426
427 ret = SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge, dwFlags);
428 DestroyIcon(hiconLarge);
429 DestroyIcon(hiconSmall);
430 return ret;
431}
432/*****************************************************************************
433 * SIC_GetIconIndex [internal]
434 *
435 * Parameters
436 * sSourceFile [IN] filename of file containing the icon
437 * index [IN] index/resID (negated) in this file
438 *
439 * NOTES
440 * look in the cache for a proper icon. if not available the icon is taken
441 * from the file and cached
442 */
443INT SIC_GetIconIndex (LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags )
444{
445 SIC_ENTRY sice;
448
449 TRACE("%s %i\n", debugstr_w(sSourceFile), dwSourceIndex);
450
451 GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
452 sice.sSourceFile = path;
453 sice.dwSourceIndex = dwSourceIndex;
454 sice.dwFlags = dwFlags;
455
456 if (!sic_hdpa)
458
460
461 if (NULL != DPA_GetPtr (sic_hdpa, 0))
462 {
463 /* search linear from position 0*/
465 }
466
467 if ( INVALID_INDEX == index )
468 {
469 ret = SIC_LoadIcon (sSourceFile, dwSourceIndex, dwFlags);
470 }
471 else
472 {
473 TRACE("-- found\n");
474 ret = ((LPSIC_ENTRY)DPA_GetPtr(sic_hdpa, index))->dwListIndex;
475 }
476
478 return ret;
479}
480
481/*****************************************************************************
482 * SIC_Initialize [internal]
483 */
485{
486 HICON hSm = NULL, hLg = NULL;
487 INT cx_small, cy_small;
488 INT cx_large, cy_large;
489 HDC hDC;
490 INT bpp;
491 DWORD ilMask;
492 BOOL result = FALSE;
493
494 TRACE("Entered SIC_Initialize\n");
495
496 if (sic_hdpa)
497 {
498 TRACE("Icon cache already initialized\n");
499 return TRUE;
500 }
501
502 sic_hdpa = DPA_Create(16);
503 if (!sic_hdpa)
504 {
505 return FALSE;
506 }
507
508 hDC = CreateICW(L"DISPLAY", NULL, NULL, NULL);
509 if (!hDC)
510 {
511 ERR("Failed to create information context (error %d)\n", GetLastError());
512 goto end;
513 }
514
516 DeleteDC(hDC);
517
518 if (bpp <= 4)
519 ilMask = ILC_COLOR4;
520 else if (bpp <= 8)
521 ilMask = ILC_COLOR8;
522 else if (bpp <= 16)
523 ilMask = ILC_COLOR16;
524 else if (bpp <= 24)
525 ilMask = ILC_COLOR24;
526 else if (bpp <= 32)
527 ilMask = ILC_COLOR32;
528 else
529 ilMask = ILC_COLOR;
530
531 ilMask |= ILC_MASK;
532
533 cx_small = GetSystemMetrics(SM_CXSMICON);
534 cy_small = GetSystemMetrics(SM_CYSMICON);
535 cx_large = GetSystemMetrics(SM_CXICON);
536 cy_large = GetSystemMetrics(SM_CYICON);
537
539 cy_small,
540 ilMask,
541 100,
542 100);
544 {
545 ERR("Failed to create the small icon list.\n");
546 goto end;
547 }
548
550 cy_large,
551 ilMask,
552 100,
553 100);
554 if (!ShellBigIconList)
555 {
556 ERR("Failed to create the big icon list.\n");
557 goto end;
558 }
559
560 /* Load the document icon, which is used as the default if an icon isn't found. */
564 cx_small,
565 cy_small,
567 if (!hSm)
568 {
569 ERR("Failed to load small IDI_SHELL_DOCUMENT icon!\n");
570 goto end;
571 }
572
576 cx_large,
577 cy_large,
579 if (!hLg)
580 {
581 ERR("Failed to load large IDI_SHELL_DOCUMENT icon!\n");
582 goto end;
583 }
584
586 {
587 ERR("Failed to add IDI_SHELL_DOCUMENT icon to cache.\n");
588 goto end;
589 }
591 {
592 ERR("Failed to add IDI_SHELL_DOCUMENT icon to cache.\n");
593 goto end;
594 }
595
596 /* Everything went fine */
597 result = TRUE;
598
599end:
600 /* The image list keeps a copy of the icons, we must destroy them */
601 if(hSm) DestroyIcon(hSm);
602 if(hLg) DestroyIcon(hLg);
603
604 /* Clean everything if something went wrong */
605 if(!result)
606 {
610 sic_hdpa = NULL;
613 }
614
615 TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList);
616
617 return result;
618}
619
620/*************************************************************************
621 * SIC_Destroy
622 *
623 * frees the cache
624 */
626{
627 HeapFree(GetProcessHeap(), 0, ((LPSIC_ENTRY)ptr)->sSourceFile);
628 SHFree(ptr);
629 return TRUE;
630}
631
632void SIC_Destroy(void)
633{
634 TRACE("\n");
635
637
639
640 sic_hdpa = NULL;
645
647 //DeleteCriticalSection(&SHELL32_SicCS); //static
648}
649
650/*****************************************************************************
651 * SIC_LoadOverlayIcon [internal]
652 *
653 * Load a shell overlay icon and return its icon cache index.
654 */
655static int SIC_LoadOverlayIcon(int icon_idx)
656{
657 WCHAR buffer[1024], wszIdx[8];
658 HKEY hKeyShellIcons;
659 LPCWSTR iconPath;
660 int iconIdx;
661
662 iconPath = swShell32Name; /* default: load icon from shell32.dll */
663 iconIdx = icon_idx;
664
665 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Icons",
666 0, KEY_READ, &hKeyShellIcons) == ERROR_SUCCESS)
667 {
668 DWORD count = sizeof(buffer);
669
670 swprintf(wszIdx, L"%d", icon_idx);
671
672 /* read icon path and index */
673 if (RegQueryValueExW(hKeyShellIcons, wszIdx, NULL, NULL, (LPBYTE)buffer, &count) == ERROR_SUCCESS)
674 {
675 LPWSTR p = wcschr(buffer, ',');
676
677 if (p)
678 *p++ = 0;
679
680 iconPath = buffer;
681 iconIdx = _wtoi(p);
682 }
683
684 RegCloseKey(hKeyShellIcons);
685 }
686
687 if (!sic_hdpa)
689
690 return SIC_LoadIcon(iconPath, iconIdx, 0);
691}
692
693/*************************************************************************
694 * Shell_GetImageLists [SHELL32.71]
695 *
696 * PARAMETERS
697 * imglist[1|2] [OUT] pointer which receives imagelist handles
698 *
699 */
701{
702 TRACE("(%p,%p)\n",lpBigList,lpSmallList);
703
704 if (!sic_hdpa)
706
707 if (lpBigList)
708 *lpBigList = ShellBigIconList;
709
710 if (lpSmallList)
711 *lpSmallList = ShellSmallIconList;
712
713 return TRUE;
714}
715/*************************************************************************
716 * PidlToSicIndex [INTERNAL]
717 *
718 * PARAMETERS
719 * sh [IN] IShellFolder
720 * pidl [IN]
721 * bBigIcon [IN]
722 * uFlags [IN] GIL_*
723 * pIndex [OUT] index within the SIC
724 *
725 */
728 LPCITEMIDLIST pidl,
729 BOOL bBigIcon,
730 UINT uFlags,
731 int * pIndex)
732{
734 WCHAR szIconFile[MAX_PATH]; /* file containing the icon */
735 INT iSourceIndex; /* index or resID(negated) in this file */
736 BOOL ret = FALSE;
737 UINT dwFlags = 0;
738 int iShortcutDefaultIndex = INVALID_INDEX;
739
740 TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
741
742 if (!sic_hdpa)
744
745 if (SUCCEEDED (sh->GetUIObjectOf(0, 1, &pidl, IID_NULL_PPV_ARG(IExtractIconW, &ei))))
746 {
747 if (SUCCEEDED(ei->GetIconLocation(uFlags &~ GIL_FORSHORTCUT, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
748 {
749 *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex, uFlags);
750 ret = TRUE;
751 }
752 }
753
754 if (INVALID_INDEX == *pIndex) /* default icon when failed */
755 {
756 if (0 == (uFlags & GIL_FORSHORTCUT))
757 {
758 *pIndex = 0;
759 }
760 else
761 {
762 if (INVALID_INDEX == iShortcutDefaultIndex)
763 {
764 iShortcutDefaultIndex = SIC_LoadIcon(swShell32Name, 0, GIL_FORSHORTCUT);
765 }
766 *pIndex = (INVALID_INDEX != iShortcutDefaultIndex ? iShortcutDefaultIndex : 0);
767 }
768 }
769
770 return ret;
771
772}
773
774/*************************************************************************
775 * SHMapPIDLToSystemImageListIndex [SHELL32.77]
776 *
777 * PARAMETERS
778 * sh [IN] pointer to an instance of IShellFolder
779 * pidl [IN]
780 * pIndex [OUT][OPTIONAL] SIC index for big icon
781 *
782 */
785 LPCITEMIDLIST pidl,
786 int *pIndex)
787{
788 int Index;
789 UINT uGilFlags = 0;
790
791 TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
792 pdump(pidl);
793
794 if (SHELL_IsShortcut(pidl))
795 uGilFlags |= GIL_FORSHORTCUT;
796
797 if (pIndex)
798 if (!PidlToSicIndex ( sh, pidl, 1, uGilFlags, pIndex))
799 *pIndex = -1;
800
801 if (!PidlToSicIndex ( sh, pidl, 0, uGilFlags, &Index))
802 return -1;
803
804 return Index;
805}
806
807/*************************************************************************
808 * SHMapIDListToImageListIndexAsync [SHELL32.148]
809 */
812 PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint,
813 int *piIndex, int *piIndexSel)
814{
815 FIXME("(%p, %p, %p, 0x%08x, %p, %p, %p, %p, %p)\n",
816 pts, psf, pidl, flags, pfn, pvData, pvHint, piIndex, piIndexSel);
817 return E_FAIL;
818}
819
820/*************************************************************************
821 * Shell_GetCachedImageIndex [SHELL32.72]
822 *
823 */
825{
826 INT ret, len;
827 LPWSTR szTemp;
828
829 WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
830
831 len = MultiByteToWideChar( CP_ACP, 0, szPath, -1, NULL, 0 );
832 szTemp = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
833 MultiByteToWideChar( CP_ACP, 0, szPath, -1, szTemp, len );
834
835 ret = SIC_GetIconIndex( szTemp, nIndex, 0 );
836
837 HeapFree( GetProcessHeap(), 0, szTemp );
838
839 return ret;
840}
841
843{
844 WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
845
846 return SIC_GetIconIndex(szPath, nIndex, 0);
847}
848
850{ if( SHELL_OsIsUnicode())
851 return Shell_GetCachedImageIndexW((LPCWSTR)szPath, nIndex, bSimulateDoc);
852 return Shell_GetCachedImageIndexA((LPCSTR)szPath, nIndex, bSimulateDoc);
853}
854
856{
857 return Shell_GetCachedImageIndexAW(szPath, nIndex, bSimulateDoc);
858}
859
860/*************************************************************************
861 * ExtractIconExW [SHELL32.@]
862 * RETURNS
863 * 0 no icon found (or the file is not valid)
864 * or number of icons extracted
865 */
866UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
867{
868 UINT ret = 0;
869
870 /* get entry point of undocumented function PrivateExtractIconExW() in user32 */
871#if defined(__CYGWIN__) || defined (__MINGW32__) || defined(_MSC_VER)
873
875 HMODULE hUser32 = GetModuleHandleA("user32");
876 PrivateExtractIconExW = (UINT(WINAPI*)(LPCWSTR,int,HICON*,HICON*,UINT)) GetProcAddress(hUser32, "PrivateExtractIconExW");
877
879 return ret;
880 }
881#endif
882
883 TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons);
884 ret = PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
885
886 /* PrivateExtractIconExW() may return -1 if the provided file is not a valid PE image file or the said
887 * file couldn't be found. The behaviour is correct although ExtractIconExW() only returns the successfully
888 * extracted icons from a file. In such scenario, simply return 0.
889 */
890 if (ret == 0xFFFFFFFF)
891 {
892 WARN("Invalid file or couldn't be found - %s\n", debugstr_w(lpszFile));
893 ret = 0;
894 }
895
896 return ret;
897}
898
899/*************************************************************************
900 * ExtractIconExA [SHELL32.@]
901 */
902UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
903{
904 UINT ret = 0;
905 INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
906 LPWSTR lpwstrFile = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
907
908 TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
909
910 if (lpwstrFile)
911 {
912 MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
913 ret = ExtractIconExW(lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
914 HeapFree(GetProcessHeap(), 0, lpwstrFile);
915 }
916 return ret;
917}
918
919/*************************************************************************
920 * ExtractAssociatedIconA (SHELL32.@)
921 *
922 * Return icon for given file (either from file itself or from associated
923 * executable) and patch parameters if needed.
924 */
926{
927 HICON hIcon = NULL;
928 INT len = MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, NULL, 0);
929 /* Note that we need to allocate MAX_PATH, since we are supposed to fill
930 * the correct executable if there is no icon in lpIconPath directly.
931 * lpIconPath itself is supposed to be large enough, so make sure lpIconPathW
932 * is large enough too. Yes, I am puking too.
933 */
934 LPWSTR lpIconPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
935
936 TRACE("%p %s %p\n", hInst, debugstr_a(lpIconPath), lpiIcon);
937
938 if (lpIconPathW)
939 {
940 MultiByteToWideChar(CP_ACP, 0, lpIconPath, -1, lpIconPathW, len);
941 hIcon = ExtractAssociatedIconW(hInst, lpIconPathW, lpiIcon);
942 WideCharToMultiByte(CP_ACP, 0, lpIconPathW, -1, lpIconPath, MAX_PATH , NULL, NULL);
943 HeapFree(GetProcessHeap(), 0, lpIconPathW);
944 }
945 return hIcon;
946}
947
948/*************************************************************************
949 * ExtractAssociatedIconW (SHELL32.@)
950 *
951 * Return icon for given file (either from file itself or from associated
952 * executable) and patch parameters if needed.
953 */
955{
956 HICON hIcon = NULL;
957 WORD wDummyIcon = 0;
958
959 TRACE("%p %s %p\n", hInst, debugstr_w(lpIconPath), lpiIcon);
960
961 if(lpiIcon == NULL)
962 lpiIcon = &wDummyIcon;
963
964 hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
965
966 if( hIcon < (HICON)2 )
967 { if( hIcon == (HICON)1 ) /* no icons found in given file */
968 { WCHAR tempPath[MAX_PATH];
969 HINSTANCE uRet = FindExecutableW(lpIconPath,NULL,tempPath);
970
971 if( uRet > (HINSTANCE)32 && tempPath[0] )
972 { wcscpy(lpIconPath,tempPath);
973 hIcon = ExtractIconW(hInst, lpIconPath, *lpiIcon);
974 if( hIcon > (HICON)2 )
975 return hIcon;
976 }
977 }
978
979 if( hIcon == (HICON)1 )
980 *lpiIcon = 2; /* MSDOS icon - we found .exe but no icons in it */
981 else
982 *lpiIcon = 6; /* generic icon - found nothing */
983
984 if (GetModuleFileNameW(hInst, lpIconPath, MAX_PATH))
986 }
987 return hIcon;
988}
989
990/*************************************************************************
991 * ExtractAssociatedIconExW (SHELL32.@)
992 *
993 * Return icon for given file (either from file itself or from associated
994 * executable) and patch parameters if needed.
995 */
997{
998 FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId);
999 return 0;
1000}
1001
1002/*************************************************************************
1003 * ExtractAssociatedIconExA (SHELL32.@)
1004 *
1005 * Return icon for given file (either from file itself or from associated
1006 * executable) and patch parameters if needed.
1007 */
1009{
1010 HICON ret;
1011 INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 );
1012 LPWSTR lpwstrFile = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1013
1014 TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId);
1015
1016 MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len );
1017 ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId);
1018 HeapFree(GetProcessHeap(), 0, lpwstrFile);
1019 return ret;
1020}
1021
1022
1023/****************************************************************************
1024 * SHDefExtractIconW [SHELL32.@]
1025 */
1027 HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
1028{
1029 UINT ret;
1030 HICON hIcons[2];
1031 WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
1032
1033 ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR);
1034 /* FIXME: deal with uFlags parameter which contains GIL_ flags */
1035 if (ret == 0xFFFFFFFF)
1036 return E_FAIL;
1037 if (ret > 0) {
1038 if (phiconLarge)
1039 *phiconLarge = hIcons[0];
1040 else
1041 DestroyIcon(hIcons[0]);
1042 if (phiconSmall)
1043 *phiconSmall = hIcons[1];
1044 else
1045 DestroyIcon(hIcons[1]);
1046 return S_OK;
1047 }
1048 return S_FALSE;
1049}
1050
1051/****************************************************************************
1052 * SHDefExtractIconA [SHELL32.@]
1053 */
1055 HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
1056{
1057 HRESULT ret;
1058 INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0);
1059 LPWSTR lpwstrFile = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1060
1061 TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
1062
1063 MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len);
1064 ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
1065 HeapFree(GetProcessHeap(), 0, lpwstrFile);
1066 return ret;
1067}
1068
1069/****************************************************************************
1070 * SHGetIconOverlayIndexA [SHELL32.@]
1071 *
1072 * Returns the index of the overlay icon in the system image list.
1073 */
1075{
1076 FIXME("%s, %d\n", debugstr_a(pszIconPath), iIconIndex);
1077
1078 return -1;
1079}
1080
1081/****************************************************************************
1082 * SHGetIconOverlayIndexW [SHELL32.@]
1083 *
1084 * Returns the index of the overlay icon in the system image list.
1085 */
1087{
1088 FIXME("%s, %d\n", debugstr_w(pszIconPath), iIconIndex);
1089
1090 return -1;
1091}
static HDC hDC
Definition: 3dtext.c:33
#define shell32_hInstance
@ lparam
Definition: SystemMenu.c:31
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define index(s, c)
Definition: various.h:29
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
#define EXTERN_C
Definition: basetyps.h:12
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define RegCloseKey(hKey)
Definition: registry.h:49
#define leave
Definition: btrfs_drv.h:138
#define E_FAIL
Definition: ddrawi.h:102
void pdump(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:311
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
DWORD bpp
Definition: surface.c:185
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3353
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4123
UINT uFlags
Definition: api.c:59
INT WINAPI DPA_Search(HDPA hdpa, LPVOID pFind, INT nStart, PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
Definition: dpa.c:845
void WINAPI DPA_DestroyCallback(HDPA hdpa, PFNDPAENUMCALLBACK enumProc, LPVOID lParam)
Definition: dpa.c:1003
LPVOID WINAPI DPA_DeletePtr(HDPA hdpa, INT i)
Definition: dpa.c:677
BOOL WINAPI DPA_Destroy(HDPA hdpa)
Definition: dpa.c:396
HDPA WINAPI DPA_Create(INT nGrow)
Definition: dpa.c:950
INT WINAPI DPA_InsertPtr(HDPA hdpa, INT i, LPVOID p)
Definition: dpa.c:591
BOOL WINAPI ImageList_Remove(HIMAGELIST himl, INT i)
Definition: imagelist.c:2568
BOOL WINAPI ImageList_Destroy(HIMAGELIST himl)
Definition: imagelist.c:928
HICON WINAPI ImageList_GetIcon(HIMAGELIST himl, INT i, UINT fStyle)
Definition: imagelist.c:1963
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
Definition: imagelist.c:804
#define wcschr
Definition: compat.h:17
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define GetProcAddress(x, y)
Definition: compat.h:753
#define HeapAlloc
Definition: compat.h:733
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CALLBACK
Definition: compat.h:35
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
#define wcsicmp
Definition: compat.h:15
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1106
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:326
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:304
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define swprintf
Definition: precomp.h:40
static VOID NTAPI BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:49
#define BI_RGB
Definition: precomp.h:47
ULONG RGBQUAD
Definition: precomp.h:50
HINSTANCE hInst
Definition: dxdiag.c:13
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
WCHAR swShell32Name[MAX_PATH]
Definition: folders.cpp:22
pKey DeleteObject()
GLuint GLuint end
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint buffer
Definition: glext.h:5915
GLuint index
Definition: glext.h:6031
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
GLbitfield flags
Definition: glext.h:7161
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
EXTERN_C HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
Definition: iconcache.cpp:1008
void SIC_Destroy(void)
Definition: iconcache.cpp:632
static INT CALLBACK sic_free(LPVOID ptr, LPVOID lparam)
Definition: iconcache.cpp:625
EXTERN_C INT WINAPI SHGetIconOverlayIndexW(LPCWSTR pszIconPath, INT iIconIndex)
Definition: iconcache.cpp:1086
INT SIC_GetIconIndex(LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags)
Definition: iconcache.cpp:443
static INT SIC_IconAppend(LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags)
Definition: iconcache.cpp:326
EXTERN_C HRESULT WINAPI SHMapIDListToImageListIndexAsync(IShellTaskScheduler *pts, IShellFolder *psf, LPCITEMIDLIST pidl, UINT flags, PFNASYNCICONTASKBALLBACK pfn, void *pvData, void *pvHint, int *piIndex, int *piIndexSel)
Definition: iconcache.cpp:810
BOOL PidlToSicIndex(IShellFolder *sh, LPCITEMIDLIST pidl, BOOL bBigIcon, UINT uFlags, int *pIndex)
Definition: iconcache.cpp:726
INT WINAPI Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, UINT bSimulateDoc)
Definition: iconcache.cpp:824
static HICON SIC_OverlayShortcutImage(HICON SourceIcon, BOOL large)
Definition: iconcache.cpp:91
static HDPA sic_hdpa
Definition: iconcache.cpp:38
BOOL SIC_Initialize(void)
Definition: iconcache.cpp:484
UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons)
Definition: iconcache.cpp:902
EXTERN_C INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
Definition: iconcache.cpp:849
static HIMAGELIST ShellSmallIconList
Definition: iconcache.cpp:40
struct SIC_ENTRY * LPSIC_ENTRY
HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize)
Definition: iconcache.cpp:1054
HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize)
Definition: iconcache.cpp:1026
static INT SIC_LoadIcon(LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags)
Definition: iconcache.cpp:390
static HIMAGELIST ShellBigIconList
Definition: iconcache.cpp:41
static int SIC_LoadOverlayIcon(int icon_idx)
Definition: iconcache.cpp:655
INT WINAPI Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, UINT bSimulateDoc)
Definition: iconcache.cpp:842
EXTERN_C INT WINAPI Shell_GetCachedImageIndex(LPCWSTR szPath, INT nIndex, UINT bSimulateDoc)
Definition: iconcache.cpp:855
#define INVALID_INDEX
Definition: iconcache.cpp:27
UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons)
Definition: iconcache.cpp:866
BOOL WINAPI Shell_GetImageLists(HIMAGELIST *lpBigList, HIMAGELIST *lpSmallList)
Definition: iconcache.cpp:700
HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
Definition: iconcache.cpp:925
EXTERN_C HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
Definition: iconcache.cpp:996
EXTERN_C INT WINAPI SHGetIconOverlayIndexA(LPCSTR pszIconPath, INT iIconIndex)
Definition: iconcache.cpp:1074
static INT CALLBACK SIC_CompareEntries(LPVOID p1, LPVOID p2, LPARAM lparam)
Definition: iconcache.cpp:61
HICON WINAPI ExtractAssociatedIconW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIcon)
Definition: iconcache.cpp:954
int WINAPI SHMapPIDLToSystemImageListIndex(IShellFolder *sh, LPCITEMIDLIST pidl, int *pIndex)
Definition: iconcache.cpp:783
_Check_return_ _CRTIMP int __cdecl _wtoi(_In_z_ const wchar_t *_Str)
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define bits
Definition: infblock.c:15
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
LPCWSTR szPath
Definition: env.c:37
static PVOID ptr
Definition: dispmode.c:27
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
static HICON
Definition: imagelist.c:84
HICON hIcon
Definition: msconfig.c:44
CRITICAL_SECTION_DEBUG critsect_debug
Definition: iconcache.cpp:46
_Out_ PULONG _Out_ PULONG pIndex
Definition: ndis.h:4565
unsigned int UINT
Definition: ndis.h:50
#define KEY_READ
Definition: nt_native.h:1023
#define L(x)
Definition: ntvdm.h:50
#define ILC_COLOR4
Definition: commctrl.h:354
#define ILC_COLOR16
Definition: commctrl.h:356
#define ILC_COLOR8
Definition: commctrl.h:355
#define ILC_COLOR32
Definition: commctrl.h:358
#define DPAS_SORTED
Definition: commctrl.h:4862
#define ILD_TRANSPARENT
Definition: commctrl.h:418
#define ImageList_AddIcon(himl, hicon)
Definition: commctrl.h:415
#define ILC_MASK
Definition: commctrl.h:351
#define DPAS_INSERTAFTER
Definition: commctrl.h:4864
#define ILC_COLOR24
Definition: commctrl.h:357
#define ILC_COLOR
Definition: commctrl.h:352
#define DPA_GetPtr
Definition: commctrl.h:5
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
short sh
Definition: format.c:272
BOOL SHELL_IsShortcut(LPCITEMIDLIST pidlLast)
Definition: shell32_main.c:383
HICON WINAPI ExtractIconW(HINSTANCE hInstance, LPCWSTR lpszFile, UINT nIconIndex)
Definition: shell32_main.c:876
static __inline BOOL SHELL_OsIsUnicode(void)
Definition: shell32_main.h:130
HINSTANCE WINAPI FindExecutableW(LPCWSTR lpFile, LPCWSTR lpDirectory, LPWSTR lpResult)
Definition: shlexec.cpp:1257
void(CALLBACK * PFNASYNCICONTASKBALLBACK)(LPCITEMIDLIST pidl, LPVOID pvData, LPVOID pvHint, INT iIconIndex, INT iOpenIconIndex)
Definition: shlobj.h:2700
#define IDI_SHELL_DOCUMENT
Definition: shresdef.h:538
#define IDI_SHELL_SHORTCUT
Definition: shresdef.h:567
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
#define TRACE(s)
Definition: solgame.cpp:4
Definition: iconcache.cpp:30
DWORD dwFlags
Definition: iconcache.cpp:34
DWORD dwSourceIndex
Definition: iconcache.cpp:32
DWORD dwAccessTime
Definition: iconcache.cpp:35
DWORD dwListIndex
Definition: iconcache.cpp:33
LPWSTR sSourceFile
Definition: iconcache.cpp:31
Definition: bl.h:1331
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883
Definition: dpa.c:49
HBITMAP hbmColor
Definition: winuser.h:3126
HBITMAP hbmMask
Definition: winuser.h:3125
USHORT biBitCount
Definition: precomp.h:37
ULONG biCompression
Definition: precomp.h:38
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1476
#define DWORD_PTR
Definition: treelist.c:76
uint32_t * PULONG
Definition: typedefs.h:59
unsigned char * LPBYTE
Definition: typedefs.h:53
uint16_t * LPWORD
Definition: typedefs.h:56
int32_t INT
Definition: typedefs.h:58
int ret
_In_ WDFCOLLECTION _In_ ULONG Index
#define ZeroMemory
Definition: winbase.h:1712
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3749
LONG_PTR LPARAM
Definition: windef.h:208
CONST void * LPCVOID
Definition: windef.h:191
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define DIB_RGB_COLORS
Definition: wingdi.h:367
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
int WINAPI GetDIBits(_In_ HDC hdc, _In_ HBITMAP hbm, _In_ UINT start, _In_ UINT cLines, _Out_opt_ LPVOID lpvBits, _At_((LPBITMAPINFOHEADER) lpbmi, _Inout_) LPBITMAPINFO lpbmi, _In_ UINT usage)
HDC WINAPI CreateICW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_opt_ LPCWSTR, _In_opt_ const DEVMODEW *)
int WINAPI SetDIBits(_In_opt_ HDC, _In_ HBITMAP, _In_ UINT, _In_ UINT, _In_ CONST VOID *, _In_ CONST BITMAPINFO *, _In_ UINT)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
BOOL WINAPI MaskBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ HDC, _In_ int, _In_ int, _In_ HBITMAP, _In_ int, _In_ int, _In_ DWORD)
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define SRCCOPY
Definition: wingdi.h:333
#define BITSPIXEL
Definition: wingdi.h:720
struct tagBITMAPINFO BITMAPINFO
BOOL WINAPI DeleteDC(_In_ HDC)
#define SRCAND
Definition: wingdi.h:330
#define MAKEROP4(f, b)
Definition: wingdi.h:2946
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2550
#define IMAGE_ICON
Definition: winuser.h:212
BOOL WINAPI GetIconInfo(_In_ HICON, _Out_ PICONINFO)
Definition: cursoricon.c:2014
UINT WINAPI PrivateExtractIconsW(_In_reads_(MAX_PATH) LPCWSTR szFileName, _In_ int nIconIndex, _In_ int cxIcon, _In_ int cyIcon, _Out_writes_opt_(nIcons) HICON *phicon, _Out_writes_opt_(nIcons) UINT *piconid, _In_ UINT nIcons, _In_ UINT flags)
#define LR_COPYFROMRESOURCE
Definition: winuser.h:1098
HANDLE WINAPI LoadImageW(_In_opt_ HINSTANCE hInst, _In_ LPCWSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2172
#define SM_CYSMICON
Definition: winuser.h:1012
#define SM_CXSMICON
Definition: winuser.h:1011
#define SM_CYICON
Definition: winuser.h:972
#define LR_SHARED
Definition: winuser.h:1099
#define LR_DEFAULTCOLOR
Definition: winuser.h:1086
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define SM_CXICON
Definition: winuser.h:971
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2044
int WINAPI GetSystemMetrics(_In_ int)
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2022
UINT WINAPI WINAPI PrivateExtractIconExW(LPCWSTR, int, HICON *, HICON *, UINT)
Definition: exticon.c:847
#define IID_NULL_PPV_ARG(Itype, ppType)
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193