2 * ImageList implementation
4 * Copyright 1998 Eric Kohl
6 * 2001 Michael Stefaniuc
7 * 2001 Charles Loep for CodeWeavers
10 * - Fix ImageList_DrawIndirect (xBitmap, yBitmap, rgbFg, rgbBk, dwRop).
11 * - Fix ImageList_GetIcon.
12 * - Fix ImageList_SetFilter (undocumented).
13 * BTW does anybody know anything about this function???
14 * - It removes 12 Bytes from the stack (3 Parameters).
15 * - First parameter SHOULD be a HIMAGELIST.
16 * - Second parameter COULD be an index?????
17 * - Third parameter.... ?????????????????????
20 * - ImageList_Draw, ImageList_DrawEx and ImageList_GetIcon use
21 * ImageList_DrawIndirect. Since ImageList_DrawIndirect is still
22 * partially implemented, the functions mentioned above will be
23 * limited in functionality too.
30 #include "wine/obj_base.h"
31 #include "wine/obj_storage.h"
33 #include "imagelist.h"
34 #include "debugtools.h"
36 DEFAULT_DEBUG_CHANNEL(imagelist
);
39 #define MAX_OVERLAYIMAGE 15
41 /* internal image list data used for Drag & Drop operations */
46 /* position of the drag image relative to the window */
49 /* offset of the hotspot relative to the origin of the image */
52 /* is the drag image visible */
54 /* saved background */
58 static INTERNALDRAG InternalDrag
= { 0, 0, 0, 0, 0, 0, FALSE
, 0 };
62 /*************************************************************************
63 * IMAGELIST_InternalExpandBitmaps [Internal]
65 * Expands the bitmaps of an image list by the given number of images.
68 * himl [I] handle to image list
69 * nImageCount [I] number of images to add
75 * This function can NOT be used to reduce the number of images.
78 IMAGELIST_InternalExpandBitmaps (HIMAGELIST himl
, INT nImageCount
, INT cx
, INT cy
)
80 HDC hdcImageList
, hdcBitmap
;
82 INT nNewWidth
, nNewCount
;
84 if ((himl
->cCurImage
+ nImageCount
<= himl
->cMaxImage
)
88 if (cy
== 0) cy
= himl
->cy
;
89 nNewCount
= himl
->cCurImage
+ nImageCount
+ himl
->cGrow
;
90 nNewWidth
= nNewCount
* himl
->cx
;
92 TRACE("Create expanded bitmaps : himl=%p x=%d y=%d count=%d\n", himl
, nNewWidth
, cy
, nNewCount
);
93 hdcImageList
= CreateCompatibleDC (0);
94 hdcBitmap
= CreateCompatibleDC (0);
97 CreateBitmap (nNewWidth
, cy
, 1, himl
->uBitsPixel
, NULL
);
98 if (hbmNewBitmap
== 0)
99 ERR("creating new image bitmap (x=%d y=%d)!\n", nNewWidth
, cy
);
101 SelectObject (hdcImageList
, himl
->hbmImage
);
102 SelectObject (hdcBitmap
, hbmNewBitmap
);
103 BitBlt (hdcBitmap
, 0, 0, himl
->cCurImage
* himl
->cx
, cy
,
104 hdcImageList
, 0, 0, SRCCOPY
);
106 DeleteObject (himl
->hbmImage
);
107 himl
->hbmImage
= hbmNewBitmap
;
111 CreateBitmap (nNewWidth
, cy
, 1, 1, NULL
);
113 if (hbmNewBitmap
== 0)
114 ERR("creating new mask bitmap!\n");
116 SelectObject (hdcImageList
, himl
->hbmMask
);
117 SelectObject (hdcBitmap
, hbmNewBitmap
);
118 BitBlt (hdcBitmap
, 0, 0, himl
->cCurImage
* himl
->cx
, cy
,
119 hdcImageList
, 0, 0, SRCCOPY
);
120 DeleteObject (himl
->hbmMask
);
121 himl
->hbmMask
= hbmNewBitmap
;
124 himl
->cMaxImage
= nNewCount
;
126 DeleteDC (hdcImageList
);
127 DeleteDC (hdcBitmap
);
131 /*************************************************************************
132 * IMAGELIST_InternalDraw [Internal]
134 * Draws the image in the ImageList (without the mask)
137 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
138 * cx [I] the width of the image to display
139 * cy............[I] the height of the image to display
145 * This function is used by ImageList_DrawIndirect, when it is
146 * required to draw only the Image (without the mask) to the screen.
148 * Blending and Overlays styles are accomplished by another function
151 IMAGELIST_InternalDraw(IMAGELISTDRAWPARAMS
*pimldp
, INT cx
, INT cy
)
156 hImageDC
= CreateCompatibleDC(0);
157 hOldBitmap
= SelectObject(hImageDC
, pimldp
->himl
->hbmImage
);
158 BitBlt(pimldp
->hdcDst
,
159 pimldp
->x
, pimldp
->y
, cx
, cy
,
161 pimldp
->himl
->cx
* pimldp
->i
, 0,
164 SelectObject(hImageDC
, hOldBitmap
);
169 /*************************************************************************
170 * IMAGELIST_InternalDrawMask [Internal]
172 * Draws the image in the ImageList with the mask
175 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
176 * cx [I] the width of the image to display
177 * cy............[I] the height of the image to display
183 * This function is used by ImageList_DrawIndirect, when it is
184 * required to draw the Image with the mask to the screen.
186 * Blending and Overlays styles are accomplished by another function.
189 IMAGELIST_InternalDrawMask(IMAGELISTDRAWPARAMS
*pimldp
, INT cx
, INT cy
)
191 BOOL bUseCustomBackground
, bBlendFlag
;
192 HBRUSH hBrush
, hOldBrush
;
193 HDC hMaskDC
, hImageDC
;
194 HBITMAP hOldBitmapImage
, hOldBitmapMask
;
195 HIMAGELIST himlLocal
= pimldp
->himl
;
196 COLORREF oldBkColor
, oldFgColor
;
197 UINT fStyle
= pimldp
->fStyle
& (~ILD_OVERLAYMASK
);
200 * We need a dc and bitmap to draw on that is
203 HDC hOffScreenDC
= 0;
204 HBITMAP hOffScreenBmp
= 0;
206 bUseCustomBackground
= (himlLocal
->clrBk
!= CLR_NONE
);
207 bBlendFlag
= (fStyle
& ILD_BLEND50
) || (fStyle
& ILD_BLEND25
);
209 hImageDC
= CreateCompatibleDC(0);
210 hMaskDC
= CreateCompatibleDC(0);
212 /* Create a compatible DC. */
213 hOffScreenDC
= CreateCompatibleDC( pimldp
->hdcDst
);
217 hOffScreenBmp
= CreateCompatibleBitmap( pimldp
->hdcDst
, cx
, cy
);
220 SelectObject( hOffScreenDC
, hOffScreenBmp
);
227 hOldBitmapImage
= SelectObject(hImageDC
, himlLocal
->hbmImage
);
228 hOldBitmapMask
= SelectObject(hMaskDC
, himlLocal
->hbmMask
);
231 * Get a copy of the image for the masking operations.
232 * We will use the copy, and this dc for all the various
233 * blitting, and then do one final blit to the screen dc.
234 * This should clean up most of the flickering.
236 BitBlt( hOffScreenDC
, 0, 0, cx
, cy
, pimldp
->hdcDst
, pimldp
->x
,
240 * Draw the Background for the appropriate Styles
242 if( bUseCustomBackground
&& (fStyle
== ILD_NORMAL
|| fStyle
& ILD_IMAGE
246 hBrush
= CreateSolidBrush (himlLocal
->clrBk
);
247 hOldBrush
= SelectObject (pimldp
->hdcDst
, hBrush
);
249 PatBlt( hOffScreenDC
, pimldp
->x
, pimldp
->y
, cx
, cy
, PATCOPY
);
251 DeleteObject (SelectObject (pimldp
->hdcDst
, hOldBrush
));
255 * Draw Image Transparently over the current background
257 if(fStyle
== ILD_NORMAL
|| (fStyle
& ILD_TRANSPARENT
) ||
258 ((fStyle
& ILD_IMAGE
) && bUseCustomBackground
) || bBlendFlag
)
260 * To obtain a transparent look, background color should be set
261 * to white and foreground color to black when blting the
265 oldBkColor
= SetBkColor( hOffScreenDC
, RGB( 0xff, 0xff, 0xff ) );
266 oldFgColor
= SetTextColor( hOffScreenDC
, RGB( 0, 0, 0 ) );
268 BitBlt( hOffScreenDC
, 0, 0, cx
, cy
,hMaskDC
, himlLocal
->cx
* pimldp
->i
,
271 BitBlt( hOffScreenDC
, 0, 0, cx
, cy
, hImageDC
,himlLocal
->cx
* pimldp
->i
,
277 * Draw the image when no Background is specified
279 else if((fStyle
& ILD_IMAGE
) && !bUseCustomBackground
)
281 BitBlt( hOffScreenDC
, 0, 0, cx
, cy
, hImageDC
,
282 himlLocal
->cx
* pimldp
->i
, 0, SRCCOPY
);
285 * Draw the mask with or without a background
287 else if(fStyle
& ILD_MASK
)
289 BitBlt( hOffScreenDC
, 0, 0, cx
, cy
, hMaskDC
, himlLocal
->cx
* pimldp
->i
,
290 0, bUseCustomBackground
? SRCCOPY
: SRCAND
);
294 * Blit the bitmap to the screen now.
296 BitBlt( pimldp
->hdcDst
, pimldp
->x
, pimldp
->y
, cx
, cy
,
297 hOffScreenDC
, 0, 0, SRCCOPY
);
300 SelectObject(hImageDC
, hOldBitmapImage
);
301 SelectObject(hMaskDC
, hOldBitmapMask
);
308 DeleteDC( hOffScreenDC
);
309 DeleteObject( hOffScreenBmp
);
314 /*************************************************************************
315 * IMAGELIST_InternalDrawBlend [Internal]
317 * Draws the Blend over the current image
320 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
321 * cx [I] the width of the image to display
322 * cy............[I] the height of the image to display
328 * This functions is used by ImageList_DrawIndirect, when it is
329 * required to add the blend to the current image.
333 IMAGELIST_InternalDrawBlend(IMAGELISTDRAWPARAMS
*pimldp
, INT cx
, INT cy
)
336 HDC hBlendMaskDC
,hMaskDC
;
337 HBRUSH hBlendColorBrush
, hBlendBrush
, hOldBrush
;
338 HBITMAP hBlendMaskBitmap
, hOldBitmap
;
339 COLORREF clrBlend
, OldTextColor
, OldBkColor
;
340 HIMAGELIST himlLocal
= pimldp
->himl
;
342 clrBlend
= GetSysColor (COLOR_HIGHLIGHT
);
343 if (!(pimldp
->rgbFg
== CLR_DEFAULT
))
345 clrBlend
= pimldp
->rgbFg
;
347 /* Create the blend Mask
349 hBlendMaskDC
= CreateCompatibleDC(0);
350 hBlendBrush
= pimldp
->fStyle
& ILD_BLEND50
?
351 himlLocal
->hbrBlend50
: himlLocal
->hbrBlend25
;
353 hBlendMaskBitmap
= CreateBitmap(cx
, cy
, 1, 1, NULL
);
354 hOldBitmap
= SelectObject(hBlendMaskDC
, hBlendMaskBitmap
);
356 hOldBrush
= (HBRUSH
) SelectObject(hBlendMaskDC
, hBlendBrush
);
357 PatBlt(hBlendMaskDC
, 0, 0, cx
, cy
, PATCOPY
);
358 SelectObject(hBlendMaskDC
, hOldBrush
);
360 /* Modify the blend mask if an Image Mask exist
362 if(pimldp
->himl
->hbmMask
!= 0)
364 HBITMAP hOldMaskBitmap
;
365 hMaskDC
= CreateCompatibleDC(0);
366 hOldMaskBitmap
= (HBITMAP
) SelectObject(hMaskDC
, himlLocal
->hbmMask
);
371 himlLocal
->cx
* pimldp
->i
,0,
372 0x220326); /* NOTSRCAND */
380 SelectObject(hMaskDC
, hOldMaskBitmap
);
384 /* Apply blend to the current image given the BlendMask
386 OldTextColor
= SetTextColor(pimldp
->hdcDst
, 0);
387 OldBkColor
= SetBkColor(pimldp
->hdcDst
, RGB(255,255,255));
388 hBlendColorBrush
= CreateSolidBrush(clrBlend
);
389 hOldBrush
= (HBRUSH
) SelectObject (pimldp
->hdcDst
, hBlendColorBrush
);
391 BitBlt (pimldp
->hdcDst
,
392 pimldp
->x
, pimldp
->y
, cx
, cy
,
395 0xB8074A); /* PSDPxax */
397 SelectObject(pimldp
->hdcDst
, hOldBrush
);
398 SetTextColor(pimldp
->hdcDst
, OldTextColor
);
399 SetBkColor(pimldp
->hdcDst
, OldBkColor
);
400 SelectObject(hBlendMaskDC
, hOldBitmap
);
401 DeleteDC(hBlendMaskDC
);
402 DeleteObject(hBlendMaskBitmap
);
403 DeleteObject(hBlendColorBrush
);
406 /*************************************************************************
407 * IMAGELIST_InternalDrawOverlay [Internal]
409 * Draws the overlay image
412 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
413 * cx [I] the width of the image to display
414 * cy............[I] the height of the image to display
420 * This functions is used by ImageList_DrawIndirect, when it is
421 * required to draw the overlay
426 IMAGELIST_InternalDrawOverlay(IMAGELISTDRAWPARAMS
*pimldp
, INT cx
, INT cy
)
432 nOvlIdx
= (pimldp
->fStyle
& ILD_OVERLAYMASK
) >> 8;
433 if ((nOvlIdx
>= 1) && (nOvlIdx
<= MAX_OVERLAYIMAGE
))
435 nOvlIdx
= pimldp
->himl
->nOvlIdx
[nOvlIdx
- 1];
436 if ((nOvlIdx
>= 0) && (nOvlIdx
<= pimldp
->himl
->cCurImage
))
438 hImageDC
= CreateCompatibleDC(0);
439 if (pimldp
->himl
->hbmMask
)
441 hOldBitmap
= (HBITMAP
) SelectObject (hImageDC
,
442 pimldp
->himl
->hbmMask
);
444 BitBlt (pimldp
->hdcDst
,
445 pimldp
->x
, pimldp
->y
, cx
, cy
,
446 hImageDC
, pimldp
->himl
->cx
* nOvlIdx
, 0,
449 SelectObject(hImageDC
, hOldBitmap
);
451 hOldBitmap
= (HBITMAP
) SelectObject (hImageDC
,
452 pimldp
->himl
->hbmImage
);
454 BitBlt (pimldp
->hdcDst
,
455 pimldp
->x
, pimldp
->y
, cx
, cy
,
457 pimldp
->himl
->cx
* nOvlIdx
, 0,
460 SelectObject(hImageDC
, hOldBitmap
);
467 /*************************************************************************
468 * ImageList_Add [COMCTL32.40]
470 * Add an image or images to an image list.
473 * himl [I] handle to image list
474 * hbmImage [I] handle to image bitmap
475 * hbmMask [I] handle to mask bitmap
478 * Success: Index of the first new image.
483 ImageList_Add (HIMAGELIST himl
, HBITMAP hbmImage
, HBITMAP hbmMask
)
485 HDC hdcImage
, hdcBitmap
;
486 INT nFirstIndex
, nImageCount
;
489 HBITMAP hOldBitmapImage
, hOldBitmap
;
491 TRACE("himl=%p hbmimage=%x hbmmask=%x\n", himl
, hbmImage
, hbmMask
);
492 if (!himl
|| !hbmImage
)
495 GetObjectA (hbmImage
, sizeof(BITMAP
), (LPVOID
)&bmp
);
496 nImageCount
= bmp
.bmWidth
/ himl
->cx
;
498 IMAGELIST_InternalExpandBitmaps (himl
, nImageCount
, bmp
.bmWidth
, bmp
.bmHeight
);
500 nStartX
= himl
->cCurImage
* himl
->cx
;
502 hdcImage
= CreateCompatibleDC(0);
503 hdcBitmap
= CreateCompatibleDC(0);
505 hOldBitmapImage
= SelectObject(hdcImage
, himl
->hbmImage
);
506 hOldBitmap
= SelectObject(hdcBitmap
, hbmImage
);
508 /* Copy result to the imagelist
510 BitBlt (hdcImage
, nStartX
, 0, bmp
.bmWidth
, bmp
.bmHeight
,
511 hdcBitmap
, 0, 0, SRCCOPY
);
515 HDC hdcMask
, hdcTemp
, hOldBitmapMask
, hOldBitmapTemp
;
517 hdcMask
= CreateCompatibleDC (0);
518 hdcTemp
= CreateCompatibleDC(0);
519 hOldBitmapMask
= (HBITMAP
) SelectObject(hdcMask
, himl
->hbmMask
);
520 hOldBitmapTemp
= (HBITMAP
) SelectObject(hdcTemp
, hbmMask
);
523 nStartX
, 0, bmp
.bmWidth
, bmp
.bmHeight
,
528 SelectObject(hdcTemp
, hOldBitmapTemp
);
531 /* Remove the background from the image
534 nStartX
, 0, bmp
.bmWidth
, bmp
.bmHeight
,
537 0x220326); /* NOTSRCAND */
539 SelectObject(hdcMask
, hOldBitmapMask
);
543 SelectObject(hdcImage
, hOldBitmapImage
);
544 SelectObject(hdcBitmap
, hOldBitmap
);
548 nFirstIndex
= himl
->cCurImage
;
549 himl
->cCurImage
+= nImageCount
;
555 /*************************************************************************
556 * ImageList_AddIcon [COMCTL32.41]
558 * Adds an icon to an image list.
561 * himl [I] handle to image list
562 * hIcon [I] handle to icon
565 * Success: index of the new image
570 ImageList_AddIcon (HIMAGELIST himl
, HICON hIcon
)
572 return ImageList_ReplaceIcon (himl
, -1, hIcon
);
576 /*************************************************************************
577 * ImageList_AddMasked [COMCTL32.42]
579 * Adds an image or images to an image list and creates a mask from the
580 * specified bitmap using the mask color.
583 * himl [I] handle to image list.
584 * hBitmap [I] handle to bitmap
585 * clrMask [I] mask color.
588 * Success: Index of the first new image.
593 ImageList_AddMasked (HIMAGELIST himl
, HBITMAP hBitmap
, COLORREF clrMask
)
595 HDC hdcImage
, hdcMask
, hdcBitmap
;
596 INT nIndex
, nImageCount
, nMaskXOffset
=0;
598 HBITMAP hOldBitmap
, hOldBitmapMask
, hOldBitmapImage
;
599 HBITMAP hMaskBitmap
=0;
602 TRACE("himl=%p hbitmap=%x clrmask=%lx\n", himl
, hBitmap
, clrMask
);
606 if (!GetObjectA (hBitmap
, sizeof(BITMAP
), &bmp
))
609 nImageCount
= bmp
.bmWidth
/ himl
->cx
;
611 IMAGELIST_InternalExpandBitmaps (himl
, nImageCount
, bmp
.bmWidth
, bmp
.bmHeight
);
613 nIndex
= himl
->cCurImage
;
614 himl
->cCurImage
+= nImageCount
;
616 hdcMask
= CreateCompatibleDC (0);
617 hdcImage
= CreateCompatibleDC(0);
618 hdcBitmap
= CreateCompatibleDC(0);
621 hOldBitmapImage
= SelectObject(hdcImage
, himl
->hbmImage
);
622 hOldBitmap
= SelectObject(hdcBitmap
, hBitmap
);
625 hOldBitmapMask
= SelectObject(hdcMask
, himl
->hbmMask
);
626 nMaskXOffset
= nIndex
* himl
->cx
;
631 Create a temp Mask so we can remove the background of
632 the Image (Windows does this even if there is no mask)
634 hMaskBitmap
= CreateBitmap(bmp
.bmWidth
, bmp
.bmHeight
, 1, 1, NULL
);
635 hOldBitmapMask
= SelectObject(hdcMask
, hMaskBitmap
);
638 /* create monochrome image to the mask bitmap */
639 bkColor
= (clrMask
!= CLR_DEFAULT
) ? clrMask
:
640 GetPixel (hdcBitmap
, 0, 0);
641 SetBkColor (hdcBitmap
, bkColor
);
643 nMaskXOffset
, 0, bmp
.bmWidth
, bmp
.bmHeight
,
647 SetBkColor(hdcBitmap
, RGB(255,255,255));
648 /*Remove the background from the image
651 WINDOWS BUG ALERT!!!!!!
652 The statement below should not be done in common practice
653 but this is how ImageList_AddMasked works in Windows.
654 It overwrites the original bitmap passed, this was discovered
655 by using the same bitmap to iterate the different styles
656 on windows where it failed (BUT ImageList_Add is OK)
657 This is here in case some apps rely on this bug
660 0, 0, bmp
.bmWidth
, bmp
.bmHeight
,
663 0x220326); /* NOTSRCAND */
664 /* Copy result to the imagelist
667 nIndex
* himl
->cx
, 0, bmp
.bmWidth
, bmp
.bmHeight
,
673 SelectObject(hdcMask
,hOldBitmapMask
);
674 SelectObject(hdcImage
, hOldBitmapImage
);
675 SelectObject(hdcBitmap
, hOldBitmap
);
681 DeleteObject(hMaskBitmap
);
688 /*************************************************************************
689 * ImageList_BeginDrag [COMCTL32.43]
691 * Creates a temporary image list that contains one image. It will be used
695 * himlTrack [I] handle to the source image list
696 * iTrack [I] index of the drag image in the source image list
697 * dxHotspot [I] X position of the hot spot of the drag image
698 * dyHotspot [I] Y position of the hot spot of the drag image
706 ImageList_BeginDrag (HIMAGELIST himlTrack
, INT iTrack
,
707 INT dxHotspot
, INT dyHotspot
)
712 TRACE("(himlTrack=%p iTrack=%d dx=%d dy=%d)\n", himlTrack
, iTrack
,
713 dxHotspot
, dyHotspot
);
715 if (himlTrack
== NULL
)
718 if (InternalDrag
.himl
)
719 ImageList_EndDrag ();
724 InternalDrag
.himl
= ImageList_Create (cx
, cy
, himlTrack
->flags
, 1, 1);
725 if (InternalDrag
.himl
== NULL
) {
726 ERR("Error creating drag image list!\n");
730 InternalDrag
.dxHotspot
= dxHotspot
;
731 InternalDrag
.dyHotspot
= dyHotspot
;
733 hdcSrc
= CreateCompatibleDC (0);
734 hdcDst
= CreateCompatibleDC (0);
737 SelectObject (hdcSrc
, himlTrack
->hbmImage
);
738 SelectObject (hdcDst
, InternalDrag
.himl
->hbmImage
);
739 BitBlt (hdcDst
, 0, 0, cx
, cy
, hdcSrc
, iTrack
* cx
, 0, SRCCOPY
);
742 SelectObject (hdcSrc
, himlTrack
->hbmMask
);
743 SelectObject (hdcDst
, InternalDrag
.himl
->hbmMask
);
744 BitBlt (hdcDst
, 0, 0, cx
, cy
, hdcSrc
, iTrack
* cx
, 0, SRCCOPY
);
749 InternalDrag
.himl
->cCurImage
= 1;
755 /*************************************************************************
756 * ImageList_Copy [COMCTL32.44]
758 * Copies an image of the source image list to an image of the
759 * destination image list. Images can be copied or swapped.
762 * himlDst [I] handle to the destination image list
763 * iDst [I] destination image index.
764 * himlSrc [I] handle to the source image list
765 * iSrc [I] source image index
766 * uFlags [I] flags for the copy operation
773 * Copying from one image list to another is possible. The original
774 * implementation just copies or swaps within one image list.
775 * Could this feature become a bug??? ;-)
779 ImageList_Copy (HIMAGELIST himlDst
, INT iDst
, HIMAGELIST himlSrc
,
780 INT iSrc
, INT uFlags
)
784 TRACE("iDst=%d iSrc=%d\n", iDst
, iSrc
);
786 if ((himlSrc
== NULL
) || (himlDst
== NULL
))
788 if ((iDst
< 0) || (iDst
>= himlDst
->cCurImage
))
790 if ((iSrc
< 0) || (iSrc
>= himlSrc
->cCurImage
))
793 hdcSrc
= CreateCompatibleDC (0);
794 if (himlDst
== himlSrc
)
797 hdcDst
= CreateCompatibleDC (0);
799 if (uFlags
& ILCF_SWAP
) {
801 HBITMAP hbmTempImage
, hbmTempMask
;
803 /* create temporary bitmaps */
804 hbmTempImage
= CreateBitmap (himlSrc
->cx
, himlSrc
->cy
, 1,
805 himlSrc
->uBitsPixel
, NULL
);
806 hbmTempMask
= CreateBitmap (himlSrc
->cx
, himlSrc
->cy
, 1,
809 /* copy (and stretch) destination to temporary bitmaps.(save) */
811 SelectObject (hdcSrc
, himlDst
->hbmImage
);
812 SelectObject (hdcDst
, hbmTempImage
);
813 StretchBlt (hdcDst
, 0, 0, himlSrc
->cx
, himlSrc
->cy
,
814 hdcSrc
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
817 SelectObject (hdcSrc
, himlDst
->hbmMask
);
818 SelectObject (hdcDst
, hbmTempMask
);
819 StretchBlt (hdcDst
, 0, 0, himlSrc
->cx
, himlSrc
->cy
,
820 hdcSrc
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
823 /* copy (and stretch) source to destination */
825 SelectObject (hdcSrc
, himlSrc
->hbmImage
);
826 SelectObject (hdcDst
, himlDst
->hbmImage
);
827 StretchBlt (hdcDst
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
828 hdcSrc
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
831 SelectObject (hdcSrc
, himlSrc
->hbmMask
);
832 SelectObject (hdcDst
, himlDst
->hbmMask
);
833 StretchBlt (hdcDst
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
834 hdcSrc
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
837 /* copy (without stretching) temporary bitmaps to source (restore) */
839 SelectObject (hdcSrc
, hbmTempImage
);
840 SelectObject (hdcDst
, himlSrc
->hbmImage
);
841 BitBlt (hdcDst
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
842 hdcSrc
, 0, 0, SRCCOPY
);
844 SelectObject (hdcSrc
, hbmTempMask
);
845 SelectObject (hdcDst
, himlSrc
->hbmMask
);
846 BitBlt (hdcDst
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
847 hdcSrc
, 0, 0, SRCCOPY
);
849 /* delete temporary bitmaps */
850 DeleteObject (hbmTempMask
);
851 DeleteObject (hbmTempImage
);
855 SelectObject (hdcSrc
, himlSrc
->hbmImage
);
856 if (himlSrc
== himlDst
)
859 SelectObject (hdcDst
, himlDst
->hbmImage
);
860 StretchBlt (hdcDst
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
861 hdcSrc
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
865 SelectObject (hdcSrc
, himlSrc
->hbmMask
);
866 if (himlSrc
== himlDst
)
869 SelectObject (hdcDst
, himlDst
->hbmMask
);
870 StretchBlt (hdcDst
, iDst
* himlDst
->cx
, 0, himlDst
->cx
, himlDst
->cy
,
871 hdcSrc
, iSrc
* himlSrc
->cx
, 0, himlSrc
->cx
, himlSrc
->cy
,
876 if (himlSrc
!= himlDst
)
883 /*************************************************************************
884 * ImageList_Create [COMCTL32.45] Creates a new image list.
887 * cx [I] image height
889 * flags [I] creation flags
890 * cInitial [I] initial number of images in the image list
891 * cGrow [I] number of images by which image list grows
894 * Success: Handle to the created image list
899 ImageList_Create (INT cx
, INT cy
, UINT flags
,
900 INT cInitial
, INT cGrow
)
906 static WORD aBitBlend25
[] =
907 {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
909 static WORD aBitBlend50
[] =
910 {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
912 TRACE("(%d %d 0x%x %d %d)\n", cx
, cy
, flags
, cInitial
, cGrow
);
914 himl
= (HIMAGELIST
)COMCTL32_Alloc (sizeof(struct _IMAGELIST
));
921 himl
->cMaxImage
= cInitial
+ cGrow
;
922 himl
->cInitial
= cInitial
;
925 himl
->clrFg
= CLR_DEFAULT
;
926 himl
->clrBk
= CLR_NONE
;
928 /* initialize overlay mask indices */
929 for (nCount
= 0; nCount
< MAX_OVERLAYIMAGE
; nCount
++)
930 himl
->nOvlIdx
[nCount
] = -1;
932 hdc
= CreateCompatibleDC (0);
933 himl
->uBitsPixel
= (UINT
)GetDeviceCaps (hdc
, BITSPIXEL
);
936 TRACE("Image: %d Bits per Pixel\n", himl
->uBitsPixel
);
938 if (himl
->cMaxImage
> 0) {
940 CreateBitmap (himl
->cx
* himl
->cMaxImage
, himl
->cy
,
941 1, himl
->uBitsPixel
, NULL
);
942 if (himl
->hbmImage
== 0) {
943 ERR("Error creating image bitmap!\n");
950 if ( (himl
->cMaxImage
> 0) && (himl
->flags
& ILC_MASK
)) {
951 himl
->hbmMask
= CreateBitmap (himl
->cx
* himl
->cMaxImage
, himl
->cy
,
953 if (himl
->hbmMask
== 0) {
954 ERR("Error creating mask bitmap!\n");
956 DeleteObject (himl
->hbmImage
);
963 /* create blending brushes */
964 hbmTemp
= CreateBitmap (8, 8, 1, 1, &aBitBlend25
);
965 himl
->hbrBlend25
= CreatePatternBrush (hbmTemp
);
966 DeleteObject (hbmTemp
);
968 hbmTemp
= CreateBitmap (8, 8, 1, 1, &aBitBlend50
);
969 himl
->hbrBlend50
= CreatePatternBrush (hbmTemp
);
970 DeleteObject (hbmTemp
);
972 TRACE("created imagelist %p\n", himl
);
977 /*************************************************************************
978 * ImageList_Destroy [COMCTL32.46]
980 * Destroys an image list.
983 * himl [I] handle to image list
991 ImageList_Destroy (HIMAGELIST himl
)
996 /* delete image bitmaps */
998 DeleteObject (himl
->hbmImage
);
1000 DeleteObject (himl
->hbmMask
);
1002 /* delete blending brushes */
1003 if (himl
->hbrBlend25
)
1004 DeleteObject (himl
->hbrBlend25
);
1005 if (himl
->hbrBlend50
)
1006 DeleteObject (himl
->hbrBlend50
);
1008 COMCTL32_Free (himl
);
1014 /*************************************************************************
1015 * ImageList_DragEnter [COMCTL32.47]
1017 * Locks window update and displays the drag image at the given position.
1020 * hwndLock [I] handle of the window that owns the drag image.
1021 * x [I] X position of the drag image.
1022 * y [I] Y position of the drag image.
1029 * The position of the drag image is relative to the window, not
1034 ImageList_DragEnter (HWND hwndLock
, INT x
, INT y
)
1036 TRACE("(hwnd=%#x x=%d y=%d)\n", hwndLock
, x
, y
);
1038 if (InternalDrag
.himl
== NULL
)
1042 InternalDrag
.hwnd
= hwndLock
;
1044 InternalDrag
.hwnd
= GetDesktopWindow ();
1049 /* draw the drag image and save the background */
1050 if (!ImageList_DragShowNolock(TRUE
)) {
1058 /*************************************************************************
1059 * ImageList_DragLeave [COMCTL32.48]
1061 * Unlocks window update and hides the drag image.
1064 * hwndLock [I] handle of the window that owns the drag image.
1072 ImageList_DragLeave (HWND hwndLock
)
1075 InternalDrag
.hwnd
= hwndLock
;
1077 InternalDrag
.hwnd
= GetDesktopWindow ();
1079 ImageList_DragShowNolock (FALSE
);
1085 /*************************************************************************
1086 * ImageList_DragMove [COMCTL32.49]
1088 * Moves the drag image.
1091 * x [I] X position of the drag image.
1092 * y [I] Y position of the drag image.
1099 * The position of the drag image is relative to the window, not
1103 * The drag image should be drawn semitransparent.
1107 ImageList_DragMove (INT x
, INT y
)
1109 TRACE("(x=%d y=%d)\n", x
, y
);
1111 if (!InternalDrag
.himl
) {
1115 /* draw/update the drag image */
1116 if (InternalDrag
.bShow
) {
1120 HBITMAP hbmOffScreen
;
1121 INT origNewX
, origNewY
;
1122 INT origOldX
, origOldY
;
1123 INT origRegX
, origRegY
;
1124 INT sizeRegX
, sizeRegY
;
1127 /* calculate the update region */
1128 origNewX
= x
- InternalDrag
.dxHotspot
;
1129 origNewY
= y
- InternalDrag
.dyHotspot
;
1130 origOldX
= InternalDrag
.x
- InternalDrag
.dxHotspot
;
1131 origOldY
= InternalDrag
.y
- InternalDrag
.dyHotspot
;
1132 origRegX
= min(origNewX
, origOldX
);
1133 origRegY
= min(origNewY
, origOldY
);
1134 sizeRegX
= InternalDrag
.himl
->cx
+ abs(x
- InternalDrag
.x
);
1135 sizeRegY
= InternalDrag
.himl
->cy
+ abs(y
- InternalDrag
.y
);
1137 hdcDrag
= GetDCEx(InternalDrag
.hwnd
, 0,
1138 DCX_WINDOW
| DCX_CACHE
| DCX_LOCKWINDOWUPDATE
);
1139 hdcOffScreen
= CreateCompatibleDC(hdcDrag
);
1140 hdcBg
= CreateCompatibleDC(hdcDrag
);
1142 hbmOffScreen
= CreateCompatibleBitmap(hdcDrag
, sizeRegX
, sizeRegY
);
1143 SelectObject(hdcOffScreen
, hbmOffScreen
);
1144 SelectObject(hdcBg
, InternalDrag
.hbmBg
);
1146 /* get the actual background of the update region */
1147 BitBlt(hdcOffScreen
, 0, 0, sizeRegX
, sizeRegY
, hdcDrag
,
1148 origRegX
, origRegY
, SRCCOPY
);
1149 /* erase the old image */
1150 BitBlt(hdcOffScreen
, origOldX
- origRegX
, origOldY
- origRegY
,
1151 InternalDrag
.himl
->cx
, InternalDrag
.himl
->cy
, hdcBg
, 0, 0,
1153 /* save the background */
1154 BitBlt(hdcBg
, 0, 0, InternalDrag
.himl
->cx
, InternalDrag
.himl
->cy
,
1155 hdcOffScreen
, origNewX
- origRegX
, origNewY
- origRegY
, SRCCOPY
);
1156 /* draw the image */
1157 /* FIXME: image should be drawn semitransparent */
1158 ImageList_Draw(InternalDrag
.himl
, 0, hdcOffScreen
, origNewX
- origRegX
,
1159 origNewY
- origRegY
, ILD_NORMAL
);
1160 /* draw the update region to the screen */
1161 BitBlt(hdcDrag
, origRegX
, origRegY
, sizeRegX
, sizeRegY
,
1162 hdcOffScreen
, 0, 0, SRCCOPY
);
1165 DeleteDC(hdcOffScreen
);
1166 DeleteObject(hbmOffScreen
);
1167 ReleaseDC(InternalDrag
.hwnd
, hdcDrag
);
1170 /* update the image position */
1178 /*************************************************************************
1179 * ImageList_DragShowNolock [COMCTL32.50]
1181 * Shows or hides the drag image.
1184 * bShow [I] TRUE shows the drag image, FALSE hides it.
1191 * The drag image should be drawn semitransparent.
1195 ImageList_DragShowNolock (BOOL bShow
)
1201 TRACE("bShow=0x%X!\n", bShow
);
1203 /* DragImage is already visible/hidden */
1204 if ((InternalDrag
.bShow
&& bShow
) || (!InternalDrag
.bShow
&& !bShow
)) {
1208 /* position of the origin of the DragImage */
1209 x
= InternalDrag
.x
- InternalDrag
.dxHotspot
;
1210 y
= InternalDrag
.y
- InternalDrag
.dyHotspot
;
1212 hdcDrag
= GetDCEx (InternalDrag
.hwnd
, 0,
1213 DCX_WINDOW
| DCX_CACHE
| DCX_LOCKWINDOWUPDATE
);
1218 hdcBg
= CreateCompatibleDC(hdcDrag
);
1219 if (!InternalDrag
.hbmBg
) {
1220 InternalDrag
.hbmBg
= CreateCompatibleBitmap(hdcDrag
,
1221 InternalDrag
.himl
->cx
, InternalDrag
.himl
->cy
);
1223 SelectObject(hdcBg
, InternalDrag
.hbmBg
);
1226 /* save the background */
1227 BitBlt(hdcBg
, 0, 0, InternalDrag
.himl
->cx
, InternalDrag
.himl
->cy
,
1228 hdcDrag
, x
, y
, SRCCOPY
);
1229 /* show the image */
1230 /* FIXME: this should be drawn semitransparent */
1231 ImageList_Draw(InternalDrag
.himl
, 0, hdcDrag
, x
, y
, ILD_NORMAL
);
1233 /* hide the image */
1234 BitBlt(hdcDrag
, x
, y
, InternalDrag
.himl
->cx
, InternalDrag
.himl
->cy
,
1235 hdcBg
, 0, 0, SRCCOPY
);
1238 InternalDrag
.bShow
= !InternalDrag
.bShow
;
1241 ReleaseDC (InternalDrag
.hwnd
, hdcDrag
);
1246 /*************************************************************************
1247 * ImageList_Draw [COMCTL32.51] Draws an image.
1250 * himl [I] handle to image list
1252 * hdc [I] handle to device context
1255 * fStyle [I] drawing flags
1262 * Calls ImageList_DrawIndirect.
1265 * ImageList_DrawIndirect.
1269 ImageList_Draw (HIMAGELIST himl
, INT i
, HDC hdc
,
1270 INT x
, INT y
, UINT fStyle
)
1272 IMAGELISTDRAWPARAMS imldp
;
1274 imldp
.cbSize
= sizeof(IMAGELISTDRAWPARAMS
);
1284 imldp
.rgbBk
= CLR_DEFAULT
;
1285 imldp
.rgbFg
= CLR_DEFAULT
;
1286 imldp
.fStyle
= fStyle
;
1289 return ImageList_DrawIndirect (&imldp
);
1293 /*************************************************************************
1294 * ImageList_DrawEx [COMCTL32.52]
1296 * Draws an image and allows to use extended drawing features.
1299 * himl [I] handle to image list
1301 * hdc [I] handle to device context
1304 * xOffs [I] X offset
1305 * yOffs [I] Y offset
1306 * rgbBk [I] background color
1307 * rgbFg [I] foreground color
1308 * fStyle [I] drawing flags
1315 * Calls ImageList_DrawIndirect.
1318 * ImageList_DrawIndirect.
1322 ImageList_DrawEx (HIMAGELIST himl
, INT i
, HDC hdc
, INT x
, INT y
,
1323 INT dx
, INT dy
, COLORREF rgbBk
, COLORREF rgbFg
,
1326 IMAGELISTDRAWPARAMS imldp
;
1328 imldp
.cbSize
= sizeof(IMAGELISTDRAWPARAMS
);
1338 imldp
.rgbBk
= rgbBk
;
1339 imldp
.rgbFg
= rgbFg
;
1340 imldp
.fStyle
= fStyle
;
1343 return ImageList_DrawIndirect (&imldp
);
1347 /*************************************************************************
1348 * ImageList_DrawIndirect [COMCTL32.53]
1350 * Draws an image using ...
1353 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
1361 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS
*pimldp
)
1365 Do some Error Checking
1369 if (pimldp
->cbSize
< sizeof(IMAGELISTDRAWPARAMS
))
1371 if (pimldp
->himl
== NULL
)
1373 if ((pimldp
->i
< 0) || (pimldp
->i
>= pimldp
->himl
->cCurImage
)) {
1374 ERR("%d not within range (max %d)\n",pimldp
->i
,pimldp
->himl
->cCurImage
-1);
1378 Get the Height and Width to display
1380 cx
= (pimldp
->cx
== 0) ? pimldp
->himl
->cx
: pimldp
->cx
;
1381 cy
= (pimldp
->cy
== 0) ? pimldp
->himl
->cy
: pimldp
->cy
;
1385 if(pimldp
->himl
->hbmMask
!= 0)
1387 IMAGELIST_InternalDrawMask(pimldp
, cx
, cy
);
1391 IMAGELIST_InternalDraw(pimldp
, cx
, cy
);
1394 Apply the blend if needed to the Image
1396 if((pimldp
->fStyle
& ILD_BLEND50
)
1397 || (pimldp
->fStyle
& ILD_BLEND25
))
1399 IMAGELIST_InternalDrawBlend(pimldp
, cx
, cy
);
1402 Apply the Overlay if needed
1404 if (pimldp
->fStyle
& ILD_OVERLAYMASK
)
1406 IMAGELIST_InternalDrawOverlay(pimldp
, cx
, cy
);
1413 /*************************************************************************
1414 * ImageList_Duplicate [COMCTL32.54] Duplicates an image list.
1417 * himlSrc [I] source image list handle
1420 * Success: Handle of duplicated image list.
1425 ImageList_Duplicate (HIMAGELIST himlSrc
)
1430 if (himlSrc
== NULL
) {
1431 ERR("Invalid image list handle!\n");
1435 himlDst
= ImageList_Create (himlSrc
->cx
, himlSrc
->cy
, himlSrc
->flags
,
1436 himlSrc
->cInitial
, himlSrc
->cGrow
);
1440 hdcSrc
= CreateCompatibleDC (0);
1441 hdcDst
= CreateCompatibleDC (0);
1442 SelectObject (hdcSrc
, himlSrc
->hbmImage
);
1443 SelectObject (hdcDst
, himlDst
->hbmImage
);
1444 BitBlt (hdcDst
, 0, 0, himlSrc
->cCurImage
* himlSrc
->cx
, himlSrc
->cy
,
1445 hdcSrc
, 0, 0, SRCCOPY
);
1447 if (himlDst
->hbmMask
)
1449 SelectObject (hdcSrc
, himlSrc
->hbmMask
);
1450 SelectObject (hdcDst
, himlDst
->hbmMask
);
1451 BitBlt (hdcDst
, 0, 0, himlSrc
->cCurImage
* himlSrc
->cx
,
1452 himlSrc
->cy
, hdcSrc
, 0, 0, SRCCOPY
);
1458 himlDst
->cCurImage
= himlSrc
->cCurImage
;
1459 himlDst
->cMaxImage
= himlSrc
->cMaxImage
;
1465 /*************************************************************************
1466 * ImageList_EndDrag [COMCTL32.55] Finishes a drag operation.
1468 * Finishes a drag operation.
1479 ImageList_EndDrag (void)
1481 /* cleanup the InternalDrag struct */
1482 InternalDrag
.hwnd
= 0;
1483 ImageList_Destroy (InternalDrag
.himl
);
1484 InternalDrag
.himl
= 0;
1487 InternalDrag
.dxHotspot
= 0;
1488 InternalDrag
.dyHotspot
= 0;
1489 InternalDrag
.bShow
= FALSE
;
1490 DeleteObject(InternalDrag
.hbmBg
);
1491 InternalDrag
.hbmBg
= 0;
1497 /*************************************************************************
1498 * ImageList_GetBkColor [COMCTL32.56]
1500 * Returns the background color of an image list.
1503 * himl [I] Image list handle.
1506 * Success: background color
1511 ImageList_GetBkColor (HIMAGELIST himl
)
1520 /*************************************************************************
1521 * ImageList_GetDragImage [COMCTL32.57]
1523 * Returns the handle to the internal drag image list.
1526 * ppt [O] Pointer to the drag position. Can be NULL.
1527 * pptHotspot [O] Pointer to the position of the hot spot. Can be NULL.
1530 * Success: Handle of the drag image list.
1535 ImageList_GetDragImage (POINT
*ppt
, POINT
*pptHotspot
)
1537 if (InternalDrag
.himl
) {
1539 ppt
->x
= InternalDrag
.x
;
1540 ppt
->y
= InternalDrag
.y
;
1543 pptHotspot
->x
= InternalDrag
.dxHotspot
;
1544 pptHotspot
->y
= InternalDrag
.dyHotspot
;
1546 return (InternalDrag
.himl
);
1553 /*************************************************************************
1554 * ImageList_GetFlags [COMCTL32.58]
1561 ImageList_GetFlags(HIMAGELIST himl
)
1563 FIXME("(%p):empty stub\n", himl
);
1568 /*************************************************************************
1569 * ImageList_GetIcon [COMCTL32.59]
1571 * Creates an icon from a masked image of an image list.
1574 * himl [I] handle to image list
1576 * flags [I] drawing style flags
1579 * Success: icon handle
1584 ImageList_GetIcon (HIMAGELIST himl
, INT i
, UINT fStyle
)
1588 HBITMAP hOldSrcBitmap
,hOldDstBitmap
;
1591 if ((himl
== NULL
) || (i
< 0) || (i
>= himl
->cCurImage
)) {
1592 FIXME("(%p,%d,%x), params out of range!\n",himl
,i
,fStyle
);
1596 hdcSrc
= CreateCompatibleDC(0);
1597 hdcDst
= CreateCompatibleDC(0);
1600 ii
.hbmMask
= CreateCompatibleBitmap (hdcDst
, himl
->cx
, himl
->cy
);
1603 hOldDstBitmap
= (HBITMAP
)SelectObject (hdcDst
, ii
.hbmMask
);
1604 if (himl
->hbmMask
) {
1605 SelectObject (hdcSrc
, himl
->hbmMask
);
1606 BitBlt (hdcDst
, 0, 0, himl
->cx
, himl
->cy
,
1607 hdcSrc
, i
* himl
->cx
, 0, SRCCOPY
);
1610 PatBlt (hdcDst
, 0, 0, himl
->cx
, himl
->cy
, BLACKNESS
);
1613 hOldSrcBitmap
= (HBITMAP
)SelectObject (hdcSrc
, himl
->hbmImage
);
1614 ii
.hbmColor
= CreateCompatibleBitmap (hdcSrc
, himl
->cx
, himl
->cy
);
1615 SelectObject (hdcDst
, ii
.hbmColor
);
1616 BitBlt (hdcDst
, 0, 0, himl
->cx
, himl
->cy
,
1617 hdcSrc
, i
* himl
->cx
, 0, SRCCOPY
);
1620 * CreateIconIndirect requires us to deselect the bitmaps from
1621 * the DCs before calling
1623 SelectObject(hdcSrc
, hOldSrcBitmap
);
1624 SelectObject(hdcDst
, hOldDstBitmap
);
1626 hIcon
= CreateIconIndirect (&ii
);
1630 DeleteObject (ii
.hbmMask
);
1631 DeleteObject (ii
.hbmColor
);
1637 /*************************************************************************
1638 * ImageList_GetIconSize [COMCTL32.60]
1640 * Retrieves the size of an image in an image list.
1643 * himl [I] handle to image list
1644 * cx [O] pointer to the image width.
1645 * cy [O] pointer to the image height.
1652 * All images in an image list have the same size.
1656 ImageList_GetIconSize (HIMAGELIST himl
, INT
*cx
, INT
*cy
)
1660 if ((himl
->cx
<= 0) || (himl
->cy
<= 0))
1672 /*************************************************************************
1673 * ImageList_GetImageCount [COMCTL32.61]
1675 * Returns the number of images in an image list.
1678 * himl [I] handle to image list
1681 * Success: Number of images.
1686 ImageList_GetImageCount (HIMAGELIST himl
)
1691 return himl
->cCurImage
;
1695 /*************************************************************************
1696 * ImageList_GetImageInfo [COMCTL32.62]
1698 * Returns information about an image in an image list.
1701 * himl [I] handle to image list
1703 * pImageInfo [O] pointer to the image information
1711 ImageList_GetImageInfo (HIMAGELIST himl
, INT i
, IMAGEINFO
*pImageInfo
)
1713 if ((himl
== NULL
) || (pImageInfo
== NULL
))
1715 if ((i
< 0) || (i
>= himl
->cCurImage
))
1718 pImageInfo
->hbmImage
= himl
->hbmImage
;
1719 pImageInfo
->hbmMask
= himl
->hbmMask
;
1721 pImageInfo
->rcImage
.top
= 0;
1722 pImageInfo
->rcImage
.bottom
= himl
->cy
;
1723 pImageInfo
->rcImage
.left
= i
* himl
->cx
;
1724 pImageInfo
->rcImage
.right
= (i
+1) * himl
->cx
;
1730 /*************************************************************************
1731 * ImageList_GetImageRect [COMCTL32.63]
1733 * Retrieves the rectangle of the specified image in an image list.
1736 * himl [I] handle to image list
1738 * lpRect [O] pointer to the image rectangle
1745 * This is an UNDOCUMENTED function!!!
1749 ImageList_GetImageRect (HIMAGELIST himl
, INT i
, LPRECT lpRect
)
1751 if ((himl
== NULL
) || (lpRect
== NULL
))
1753 if ((i
< 0) || (i
>= himl
->cCurImage
))
1756 lpRect
->left
= i
* himl
->cx
;
1758 lpRect
->right
= lpRect
->left
+ himl
->cx
;
1759 lpRect
->bottom
= himl
->cy
;
1765 /*************************************************************************
1766 * ImageList_LoadImage [COMCTL32.64]
1767 * ImageList_LoadImageA [COMCTL32.65]
1769 * Creates an image list from a bitmap, icon or cursor.
1772 * hi [I] instance handle
1773 * lpbmp [I] name or id of the image
1774 * cx [I] width of each image
1775 * cGrow [I] number of images to expand
1776 * clrMask [I] mask color
1777 * uType [I] type of image to load
1778 * uFlags [I] loading flags
1781 * Success: handle to the loaded image list
1789 ImageList_LoadImageA (HINSTANCE hi
, LPCSTR lpbmp
, INT cx
, INT cGrow
,
1790 COLORREF clrMask
, UINT uType
, UINT uFlags
)
1792 HIMAGELIST himl
= NULL
;
1796 handle
= LoadImageA (hi
, lpbmp
, uType
, 0, 0, uFlags
);
1798 ERR("Error loading image!\n");
1802 if (uType
== IMAGE_BITMAP
) {
1804 GetObjectA (handle
, sizeof(BITMAP
), &bmp
);
1806 /* To match windows behavior, if cx is set to zero and
1807 the flag DI_DEFAULTSIZE is specified, cx becomes the
1808 system metric value for icons. If the flag is not specified
1809 the function sets the size to the height of the bitmap */
1812 if (uFlags
& DI_DEFAULTSIZE
)
1813 cx
= GetSystemMetrics (SM_CXICON
);
1818 nImageCount
= bmp
.bmWidth
/ cx
;
1820 himl
= ImageList_Create (cx
, bmp
.bmHeight
, ILC_MASK
| ILC_COLOR
,
1821 nImageCount
, cGrow
);
1822 ImageList_AddMasked (himl
, (HBITMAP
)handle
, clrMask
);
1824 else if ((uType
== IMAGE_ICON
) || (uType
== IMAGE_CURSOR
)) {
1828 GetIconInfo (handle
, &ii
);
1829 GetObjectA (ii
.hbmColor
, sizeof(BITMAP
), (LPVOID
)&bmp
);
1830 himl
= ImageList_Create (bmp
.bmWidth
, bmp
.bmHeight
,
1831 ILC_MASK
| ILC_COLOR
, 1, cGrow
);
1832 ImageList_Add (himl
, ii
.hbmColor
, ii
.hbmMask
);
1833 DeleteObject (ii
.hbmColor
);
1834 DeleteObject (ii
.hbmMask
);
1837 DeleteObject (handle
);
1843 /*************************************************************************
1844 * ImageList_LoadImageW [COMCTL32.66]
1846 * Creates an image list from a bitmap, icon or cursor.
1849 * hi [I] instance handle
1850 * lpbmp [I] name or id of the image
1851 * cx [I] width of each image
1852 * cGrow [I] number of images to expand
1853 * clrMask [I] mask color
1854 * uType [I] type of image to load
1855 * uFlags [I] loading flags
1858 * Success: handle to the loaded image list
1866 ImageList_LoadImageW (HINSTANCE hi
, LPCWSTR lpbmp
, INT cx
, INT cGrow
,
1867 COLORREF clrMask
, UINT uType
, UINT uFlags
)
1869 HIMAGELIST himl
= NULL
;
1873 handle
= LoadImageW (hi
, lpbmp
, uType
, 0, 0, uFlags
);
1875 ERR("Error loading image!\n");
1879 if (uType
== IMAGE_BITMAP
) {
1881 GetObjectA (handle
, sizeof(BITMAP
), &bmp
);
1882 nImageCount
= bmp
.bmWidth
/ cx
;
1884 himl
= ImageList_Create (cx
, bmp
.bmHeight
, ILC_MASK
| ILC_COLOR
,
1885 nImageCount
, cGrow
);
1886 ImageList_AddMasked (himl
, (HBITMAP
)handle
, clrMask
);
1888 else if ((uType
== IMAGE_ICON
) || (uType
== IMAGE_CURSOR
)) {
1892 GetIconInfo (handle
, &ii
);
1893 GetObjectA (ii
.hbmMask
, sizeof(BITMAP
), (LPVOID
)&bmp
);
1894 himl
= ImageList_Create (bmp
.bmWidth
, bmp
.bmHeight
,
1895 ILC_MASK
| ILC_COLOR
, 1, cGrow
);
1896 ImageList_Add (himl
, ii
.hbmColor
, ii
.hbmMask
);
1897 DeleteObject (ii
.hbmColor
);
1898 DeleteObject (ii
.hbmMask
);
1901 DeleteObject (handle
);
1907 /*************************************************************************
1908 * ImageList_Merge [COMCTL32.67]
1910 * Creates a new image list that contains a merged image from the specified
1911 * images of both source image lists.
1914 * himl1 [I] handle to first image list
1915 * i1 [I] first image index
1916 * himl2 [I] handle to second image list
1917 * i2 [I] second image index
1918 * dx [I] X offset of the second image relative to the first.
1919 * dy [I] Y offset of the second image relative to the first.
1922 * Success: handle of the merged image list.
1927 ImageList_Merge (HIMAGELIST himl1
, INT i1
, HIMAGELIST himl2
, INT i2
,
1930 HIMAGELIST himlDst
= NULL
;
1931 HDC hdcSrcImage
, hdcDstImage
;
1933 INT xOff1
, yOff1
, xOff2
, yOff2
;
1936 TRACE("(himl1=%p i1=%d himl2=%p i2=%d dx=%d dy=%d)\n", himl1
, i1
, himl2
,
1939 if ((himl1
== NULL
) || (himl2
== NULL
))
1943 if ((i1
< 0) || (i1
>= himl1
->cCurImage
)) {
1944 ERR("Index 1 out of range! %d\n", i1
);
1948 if ((i2
< 0) || (i2
>= himl2
->cCurImage
)) {
1949 ERR("Index 2 out of range! %d\n", i2
);
1954 cxDst
= max (himl1
->cx
, dx
+ himl2
->cx
);
1959 cxDst
= max (himl2
->cx
, himl1
->cx
- dx
);
1964 cxDst
= max (himl1
->cx
, himl2
->cx
);
1970 cyDst
= max (himl1
->cy
, dy
+ himl2
->cy
);
1975 cyDst
= max (himl2
->cy
, himl1
->cy
- dy
);
1980 cyDst
= max (himl1
->cy
, himl2
->cy
);
1985 himlDst
= ImageList_Create (cxDst
, cyDst
, ILC_MASK
| ILC_COLOR
, 1, 1);
1988 hdcSrcImage
= CreateCompatibleDC (0);
1989 hdcDstImage
= CreateCompatibleDC (0);
1990 nX1
= i1
* himl1
->cx
;
1991 nX2
= i2
* himl2
->cx
;
1994 SelectObject (hdcSrcImage
, himl1
->hbmImage
);
1995 SelectObject (hdcDstImage
, himlDst
->hbmImage
);
1996 BitBlt (hdcDstImage
, 0, 0, cxDst
, cyDst
,
1997 hdcSrcImage
, 0, 0, BLACKNESS
);
1998 BitBlt (hdcDstImage
, xOff1
, yOff1
, himl1
->cx
, himl1
->cy
,
1999 hdcSrcImage
, nX1
, 0, SRCCOPY
);
2001 SelectObject (hdcSrcImage
, himl2
->hbmMask
);
2002 BitBlt (hdcDstImage
, xOff2
, yOff2
, himl2
->cx
, himl2
->cy
,
2003 hdcSrcImage
, nX2
, 0, SRCAND
);
2005 SelectObject (hdcSrcImage
, himl2
->hbmImage
);
2006 BitBlt (hdcDstImage
, xOff2
, yOff2
, himl2
->cx
, himl2
->cy
,
2007 hdcSrcImage
, nX2
, 0, SRCPAINT
);
2010 SelectObject (hdcSrcImage
, himl1
->hbmMask
);
2011 SelectObject (hdcDstImage
, himlDst
->hbmMask
);
2012 BitBlt (hdcDstImage
, 0, 0, cxDst
, cyDst
,
2013 hdcSrcImage
, 0, 0, WHITENESS
);
2014 BitBlt (hdcDstImage
, xOff1
, yOff1
, himl1
->cx
, himl1
->cy
,
2015 hdcSrcImage
, nX1
, 0, SRCCOPY
);
2017 SelectObject (hdcSrcImage
, himl2
->hbmMask
);
2018 BitBlt (hdcDstImage
, xOff2
, yOff2
, himl2
->cx
, himl2
->cy
,
2019 hdcSrcImage
, nX2
, 0, SRCAND
);
2021 DeleteDC (hdcSrcImage
);
2022 DeleteDC (hdcDstImage
);
2023 himlDst
->cCurImage
= 1;
2030 /* helper for _read_bitmap currently unused */
2032 static int may_use_dibsection(HDC hdc
) {
2033 int bitspixel
= GetDeviceCaps(hdc
,BITSPIXEL
)*GetDeviceCaps(hdc
,PLANES
);
2038 return GetDeviceCaps(hdc
,CAPS1
) & C1_DIBENGINE
;
2042 /* helper for ImageList_Read, see comments below */
2043 static HBITMAP
_read_bitmap(LPSTREAM pstm
,int ilcFlag
,int cx
,int cy
) {
2045 BITMAPFILEHEADER bmfh
;
2046 BITMAPINFOHEADER bmih
;
2047 int bitsperpixel
,palspace
,longsperline
,width
,height
;
2048 LPBITMAPINFOHEADER bmihc
= NULL
;
2050 HBITMAP hbitmap
= 0;
2051 LPBYTE bits
= NULL
,nbits
= NULL
;
2052 int nbytesperline
,bytesperline
;
2054 if (!SUCCEEDED(IStream_Read ( pstm
, &bmfh
, sizeof(bmfh
), NULL
)) ||
2055 (bmfh
.bfType
!= (('M'<<8)|'B')) ||
2056 !SUCCEEDED(IStream_Read ( pstm
, &bmih
, sizeof(bmih
), NULL
)) ||
2057 (bmih
.biSize
!= sizeof(bmih
))
2061 bitsperpixel
= bmih
.biPlanes
* bmih
.biBitCount
;
2062 if (bitsperpixel
<=8)
2063 palspace
= (1<<bitsperpixel
)*sizeof(RGBQUAD
);
2066 width
= bmih
.biWidth
;
2067 height
= bmih
.biHeight
;
2068 bmihc
= (LPBITMAPINFOHEADER
)LocalAlloc(LMEM_ZEROINIT
,sizeof(bmih
)+palspace
);
2069 memcpy(bmihc
,&bmih
,sizeof(bmih
));
2070 longsperline
= ((width
*bitsperpixel
+31)&~0x1f)>>5;
2071 bmihc
->biSizeImage
= (longsperline
*height
)<<2;
2073 /* read the palette right after the end of the bitmapinfoheader */
2075 if (!SUCCEEDED(IStream_Read ( pstm
, bmihc
+1, palspace
, NULL
)))
2079 #if 0 /* Magic for NxM -> 1x(N*M) not implemented for DIB Sections */
2080 if ((bitsperpixel
>1) &&
2081 ((ilcFlag
!=ILC_COLORDDB
) && (!ilcFlag
|| may_use_dibsection(xdc
)))
2083 hbitmap
= CreateDIBSection(xdc
,(BITMAPINFO
*)bmihc
,0,(LPVOID
*)&bits
,0,0);
2086 if (!SUCCEEDED(IStream_Read( pstm
, bits
, bmihc
->biSizeImage
, NULL
)))
2092 int i
,nwidth
,nheight
;
2094 nwidth
= width
*(height
/cy
);
2097 if (bitsperpixel
==1)
2098 hbitmap
= CreateBitmap(nwidth
,nheight
,1,1,NULL
);
2100 hbitmap
= CreateCompatibleBitmap(xdc
,nwidth
,nheight
);
2102 /* Might be a bit excessive memory use here */
2103 bits
= (LPBYTE
)LocalAlloc(LMEM_ZEROINIT
,bmihc
->biSizeImage
);
2104 nbits
= (LPBYTE
)LocalAlloc(LMEM_ZEROINIT
,bmihc
->biSizeImage
);
2105 if (!SUCCEEDED(IStream_Read ( pstm
, bits
, bmihc
->biSizeImage
, NULL
)))
2108 /* Copy the NxM bitmap into a 1x(N*M) bitmap we need, linewise */
2109 /* Do not forget that windows bitmaps are bottom->top */
2110 bytesperline
= longsperline
*4;
2111 nbytesperline
= (height
/cy
)*bytesperline
;
2112 for (i
=0;i
<height
;i
++) {
2114 nbits
+((height
-1-i
)%cy
)*nbytesperline
+(i
/cy
)*bytesperline
,
2115 bits
+bytesperline
*(height
-1-i
),
2119 bmihc
->biWidth
= nwidth
;
2120 bmihc
->biHeight
= nheight
;
2121 if (!SetDIBits(xdc
,hbitmap
,0,nheight
,nbits
,(BITMAPINFO
*)bmihc
,0))
2123 LocalFree((HLOCAL
)nbits
);
2124 LocalFree((HLOCAL
)bits
);
2128 if (xdc
) ReleaseDC(0,xdc
);
2129 if (bmihc
) LocalFree((HLOCAL
)bmihc
);
2132 DeleteObject(hbitmap
);
2139 /*************************************************************************
2140 * ImageList_Read [COMCTL32.68]
2142 * Reads an image list from a stream.
2145 * pstm [I] pointer to a stream
2148 * Success: handle to image list
2151 * The format is like this:
2152 * ILHEAD ilheadstruct;
2154 * for the color image part:
2155 * BITMAPFILEHEADER bmfh;
2156 * BITMAPINFOHEADER bmih;
2157 * only if it has a palette:
2158 * RGBQUAD rgbs[nr_of_paletted_colors];
2160 * BYTE colorbits[imagesize];
2162 * the following only if the ILC_MASK bit is set in ILHEAD.ilFlags:
2163 * BITMAPFILEHEADER bmfh_mask;
2164 * BITMAPINFOHEADER bmih_mask;
2165 * only if it has a palette (it usually does not):
2166 * RGBQUAD rgbs[nr_of_paletted_colors];
2168 * BYTE maskbits[imagesize];
2170 * CAVEAT: Those images are within a NxM bitmap, not the 1xN we expect.
2171 * _read_bitmap needs to convert them.
2173 HIMAGELIST WINAPI
ImageList_Read (LPSTREAM pstm
)
2177 HBITMAP hbmColor
=0,hbmMask
=0;
2180 if (!SUCCEEDED(IStream_Read (pstm
, &ilHead
, sizeof(ILHEAD
), NULL
)))
2182 if (ilHead
.usMagic
!= (('L' << 8) | 'I'))
2184 if (ilHead
.usVersion
!= 0x101) /* probably version? */
2188 FIXME(" ilHead.cCurImage = %d\n",ilHead
.cCurImage
);
2189 FIXME(" ilHead.cMaxImage = %d\n",ilHead
.cMaxImage
);
2190 FIXME(" ilHead.cGrow = %d\n",ilHead
.cGrow
);
2191 FIXME(" ilHead.cx = %d\n",ilHead
.cx
);
2192 FIXME(" ilHead.cy = %d\n",ilHead
.cy
);
2193 FIXME(" ilHead.flags = %x\n",ilHead
.flags
);
2194 FIXME(" ilHead.ovls[0] = %d\n",ilHead
.ovls
[0]);
2195 FIXME(" ilHead.ovls[1] = %d\n",ilHead
.ovls
[1]);
2196 FIXME(" ilHead.ovls[2] = %d\n",ilHead
.ovls
[2]);
2197 FIXME(" ilHead.ovls[3] = %d\n",ilHead
.ovls
[3]);
2200 hbmColor
= _read_bitmap(pstm
,ilHead
.flags
& ~ILC_MASK
,ilHead
.cx
,ilHead
.cy
);
2203 if (ilHead
.flags
& ILC_MASK
) {
2204 hbmMask
= _read_bitmap(pstm
,0,ilHead
.cx
,ilHead
.cy
);
2206 DeleteObject(hbmColor
);
2211 himl
= ImageList_Create (
2219 DeleteObject(hbmColor
);
2220 DeleteObject(hbmMask
);
2223 himl
->hbmImage
= hbmColor
;
2224 himl
->hbmMask
= hbmMask
;
2225 himl
->cCurImage
= ilHead
.cCurImage
;
2226 himl
->cMaxImage
= ilHead
.cMaxImage
;
2228 ImageList_SetBkColor(himl
,ilHead
.bkcolor
);
2230 ImageList_SetOverlayImage(himl
,ilHead
.ovls
[i
],i
+1);
2235 /*************************************************************************
2236 * ImageList_Remove [COMCTL32.69] Removes an image from an image list
2239 * himl [I] image list handle
2248 ImageList_Remove (HIMAGELIST himl
, INT i
)
2250 HBITMAP hbmNewImage
, hbmNewMask
;
2255 ERR("Invalid image list handle!\n");
2259 if ((i
< -1) || (i
>= himl
->cCurImage
)) {
2260 ERR("index out of range! %d\n", i
);
2264 if (himl
->cCurImage
== 0) {
2265 ERR("image list is already empty!\n");
2271 TRACE("remove all!\n");
2273 himl
->cMaxImage
= himl
->cInitial
+ himl
->cGrow
;
2274 himl
->cCurImage
= 0;
2275 for (nCount
= 0; nCount
< MAX_OVERLAYIMAGE
; nCount
++)
2276 himl
->nOvlIdx
[nCount
] = -1;
2278 DeleteObject (himl
->hbmImage
);
2280 CreateBitmap (himl
->cMaxImage
* himl
->cx
, himl
->cy
,
2281 1, himl
->uBitsPixel
, NULL
);
2283 if (himl
->hbmMask
) {
2284 DeleteObject (himl
->hbmMask
);
2286 CreateBitmap (himl
->cMaxImage
* himl
->cx
, himl
->cy
,
2291 /* delete one image */
2292 TRACE("Remove single image! %d\n", i
);
2294 /* create new bitmap(s) */
2295 cxNew
= (himl
->cCurImage
+ himl
->cGrow
- 1) * himl
->cx
;
2297 TRACE(" - Number of images: %d / %d (Old/New)\n",
2298 himl
->cCurImage
, himl
->cCurImage
- 1);
2299 TRACE(" - Max. number of images: %d / %d (Old/New)\n",
2300 himl
->cMaxImage
, himl
->cCurImage
+ himl
->cGrow
- 1);
2303 CreateBitmap (cxNew
, himl
->cy
, 1, himl
->uBitsPixel
, NULL
);
2306 hbmNewMask
= CreateBitmap (cxNew
, himl
->cy
, 1, 1, NULL
);
2308 hbmNewMask
= 0; /* Just to keep compiler happy! */
2310 hdcSrc
= CreateCompatibleDC (0);
2311 hdcDst
= CreateCompatibleDC (0);
2313 /* copy all images and masks prior to the "removed" image */
2315 TRACE("Pre image copy: Copy %d images\n", i
);
2317 SelectObject (hdcSrc
, himl
->hbmImage
);
2318 SelectObject (hdcDst
, hbmNewImage
);
2319 BitBlt (hdcDst
, 0, 0, i
* himl
->cx
, himl
->cy
,
2320 hdcSrc
, 0, 0, SRCCOPY
);
2322 if (himl
->hbmMask
) {
2323 SelectObject (hdcSrc
, himl
->hbmMask
);
2324 SelectObject (hdcDst
, hbmNewMask
);
2325 BitBlt (hdcDst
, 0, 0, i
* himl
->cx
, himl
->cy
,
2326 hdcSrc
, 0, 0, SRCCOPY
);
2330 /* copy all images and masks behind the removed image */
2331 if (i
< himl
->cCurImage
- 1) {
2332 TRACE("Post image copy!\n");
2333 SelectObject (hdcSrc
, himl
->hbmImage
);
2334 SelectObject (hdcDst
, hbmNewImage
);
2335 BitBlt (hdcDst
, i
* himl
->cx
, 0, (himl
->cCurImage
- i
- 1) * himl
->cx
,
2336 himl
->cy
, hdcSrc
, (i
+ 1) * himl
->cx
, 0, SRCCOPY
);
2338 if (himl
->hbmMask
) {
2339 SelectObject (hdcSrc
, himl
->hbmMask
);
2340 SelectObject (hdcDst
, hbmNewMask
);
2341 BitBlt (hdcDst
, i
* himl
->cx
, 0,
2342 (himl
->cCurImage
- i
- 1) * himl
->cx
,
2343 himl
->cy
, hdcSrc
, (i
+ 1) * himl
->cx
, 0, SRCCOPY
);
2350 /* delete old images and insert new ones */
2351 DeleteObject (himl
->hbmImage
);
2352 himl
->hbmImage
= hbmNewImage
;
2353 if (himl
->hbmMask
) {
2354 DeleteObject (himl
->hbmMask
);
2355 himl
->hbmMask
= hbmNewMask
;
2359 himl
->cMaxImage
= himl
->cCurImage
+ himl
->cGrow
;
2366 /*************************************************************************
2367 * ImageList_Replace [COMCTL32.70]
2369 * Replaces an image in an image list with a new image.
2372 * himl [I] handle to image list
2374 * hbmImage [I] handle to image bitmap
2375 * hbmMask [I] handle to mask bitmap. Can be NULL.
2383 ImageList_Replace (HIMAGELIST himl
, INT i
, HBITMAP hbmImage
,
2386 HDC hdcImageList
, hdcImage
;
2390 ERR("Invalid image list handle!\n");
2394 if ((i
>= himl
->cMaxImage
) || (i
< 0)) {
2395 ERR("Invalid image index!\n");
2399 hdcImageList
= CreateCompatibleDC (0);
2400 hdcImage
= CreateCompatibleDC (0);
2401 GetObjectA (hbmImage
, sizeof(BITMAP
), (LPVOID
)&bmp
);
2404 SelectObject (hdcImageList
, himl
->hbmImage
);
2405 SelectObject (hdcImage
, hbmImage
);
2407 StretchBlt (hdcImageList
, i
* himl
->cx
, 0, himl
->cx
, himl
->cy
,
2408 hdcImage
, 0, 0, bmp
.bmWidth
, bmp
.bmHeight
, SRCCOPY
);
2413 SelectObject (hdcImageList
, himl
->hbmMask
);
2414 SelectObject (hdcImage
, hbmMask
);
2416 StretchBlt (hdcImageList
, i
* himl
->cx
, 0, himl
->cx
, himl
->cy
,
2417 hdcImage
, 0, 0, bmp
.bmWidth
, bmp
.bmHeight
, SRCCOPY
);
2420 /* Remove the background from the image
2422 SelectObject (hdcImageList
, himl
->hbmImage
);
2423 StretchBlt (hdcImageList
,
2424 i
*himl
->cx
, 0, himl
->cx
, himl
->cy
,
2426 0, 0, bmp
.bmWidth
, bmp
.bmHeight
,
2427 0x220326); /* NOTSRCAND */
2430 DeleteDC (hdcImage
);
2431 DeleteDC (hdcImageList
);
2437 /*************************************************************************
2438 * ImageList_ReplaceIcon [COMCTL32.75]
2440 * Replaces an image in an image list using an icon.
2443 * himl [I] handle to image list
2445 * hIcon [I] handle to icon
2448 * Success: index of the replaced image
2453 ImageList_ReplaceIcon (HIMAGELIST himl
, INT i
, HICON hIcon
)
2455 HDC hdcImageList
, hdcImage
;
2458 HBITMAP hbmOldSrc
, hbmOldDst
;
2462 TRACE("(0x%lx 0x%x 0x%x)\n", (DWORD
)himl
, i
, hIcon
);
2466 if ((i
>= himl
->cMaxImage
) || (i
< -1))
2469 hBestFitIcon
= CopyImage(
2472 LR_COPYFROMRESOURCE
);
2474 GetIconInfo (hBestFitIcon
, &ii
);
2475 if (ii
.hbmMask
== 0)
2477 if (ii
.hbmColor
== 0)
2479 GetObjectA (ii
.hbmMask
, sizeof(BITMAP
), (LPVOID
)&bmp
);
2482 if (himl
->cCurImage
+ 1 > himl
->cMaxImage
)
2483 IMAGELIST_InternalExpandBitmaps (himl
, 1, 0, 0);
2485 nIndex
= himl
->cCurImage
;
2491 hdcImageList
= CreateCompatibleDC (0);
2492 TRACE("hdcImageList=0x%x!\n", hdcImageList
);
2493 if (hdcImageList
== 0)
2494 ERR("invalid hdcImageList!\n");
2496 hdcImage
= CreateCompatibleDC (0);
2497 TRACE("hdcImage=0x%x!\n", hdcImage
);
2499 ERR("invalid hdcImage!\n");
2501 hbmOldDst
= SelectObject (hdcImageList
, himl
->hbmImage
);
2502 SetTextColor( hdcImageList
, RGB(0,0,0));
2503 SetBkColor( hdcImageList
, RGB(255,255,255));
2504 hbmOldSrc
= SelectObject (hdcImage
, ii
.hbmColor
);
2505 StretchBlt (hdcImageList
, nIndex
* himl
->cx
, 0, himl
->cx
, himl
->cy
,
2506 hdcImage
, 0, 0, bmp
.bmWidth
, bmp
.bmHeight
, SRCCOPY
);
2508 if (himl
->hbmMask
) {
2509 SelectObject (hdcImageList
, himl
->hbmMask
);
2510 SelectObject (hdcImage
, ii
.hbmMask
);
2511 StretchBlt (hdcImageList
, nIndex
* himl
->cx
, 0, himl
->cx
, himl
->cy
,
2512 hdcImage
, 0, 0, bmp
.bmWidth
, bmp
.bmHeight
, SRCCOPY
);
2515 SelectObject (hdcImage
, hbmOldSrc
);
2516 SelectObject (hdcImageList
, hbmOldDst
);
2519 DestroyIcon(hBestFitIcon
);
2521 DeleteDC (hdcImageList
);
2523 DeleteDC (hdcImage
);
2525 DeleteObject (ii
.hbmColor
);
2527 DeleteObject (ii
.hbmMask
);
2533 /*************************************************************************
2534 * ImageList_SetBkColor [COMCTL32.76]
2536 * Sets the background color of an image list.
2539 * himl [I] handle to image list
2540 * clrBk [I] background color
2543 * Success: previous background color
2548 ImageList_SetBkColor (HIMAGELIST himl
, COLORREF clrBk
)
2555 clrOldBk
= himl
->clrBk
;
2556 himl
->clrBk
= clrBk
;
2561 /*************************************************************************
2562 * ImageList_SetDragCursorImage [COMCTL32.77]
2564 * Combines the specified image with the current drag image
2567 * himlDrag [I] handle to drag image list
2568 * iDrag [I] drag image index
2569 * dxHotspot [I] X position of the hot spot
2570 * dyHotspot [I] Y position of the hot spot
2577 * When this function is called and the drag image is visible, a
2578 * short flickering occurs but this matches the Win9x behavior. It is
2579 * possible to fix the flickering using code like in ImageList_DragMove.
2583 ImageList_SetDragCursorImage (HIMAGELIST himlDrag
, INT iDrag
,
2584 INT dxHotspot
, INT dyHotspot
)
2586 HIMAGELIST himlTemp
;
2590 if (InternalDrag
.himl
== NULL
)
2593 TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
2594 dxHotspot
, dyHotspot
, InternalDrag
.dxHotspot
, InternalDrag
.dyHotspot
);
2596 visible
= InternalDrag
.bShow
;
2598 /* Calculate the offset between the origin of the old image and the
2599 * origin of the second image.
2600 * dxHotspot, dyHotspot is the offset of THE Hotspot (there is only one
2601 * hotspot) to the origin of the second image.
2602 * See M$DN for details */
2603 dx
= InternalDrag
.dxHotspot
- dxHotspot
;
2604 dy
= InternalDrag
.dyHotspot
- dyHotspot
;
2605 himlTemp
= ImageList_Merge (InternalDrag
.himl
, 0, himlDrag
, iDrag
, dx
, dy
);
2608 /* hide the drag image */
2609 ImageList_DragShowNolock(FALSE
);
2611 if ((InternalDrag
.himl
->cx
!= himlTemp
->cx
) ||
2612 (InternalDrag
.himl
->cy
!= himlTemp
->cy
)) {
2613 /* the size of the drag image changed, invalidate the buffer */
2614 DeleteObject(InternalDrag
.hbmBg
);
2615 InternalDrag
.hbmBg
= 0;
2618 ImageList_Destroy (InternalDrag
.himl
);
2619 InternalDrag
.himl
= himlTemp
;
2621 /* update the InternalDragOffset, if the origin of the
2622 * DragImage was changed by ImageList_Merge. */
2623 if (dx
> InternalDrag
.dxHotspot
) {
2624 InternalDrag
.dxHotspot
= dx
;
2626 if (dy
> InternalDrag
.dyHotspot
) {
2627 InternalDrag
.dyHotspot
= dy
;
2631 /* show the drag image */
2632 ImageList_DragShowNolock(TRUE
);
2639 /*************************************************************************
2640 * ImageList_SetFilter [COMCTL32.78]
2642 * Sets a filter (or does something completely different)!!???
2645 * himl [I] handle to image list
2651 * Failure: FALSE ???
2654 * This is an UNDOCUMENTED function!!!!
2659 ImageList_SetFilter (HIMAGELIST himl
, INT i
, DWORD dwFilter
)
2661 FIXME("(%p 0x%x 0x%lx):empty stub!\n",
2668 /*************************************************************************
2669 * ImageList_SetFlags [COMCTL32.79]
2676 ImageList_SetFlags(HIMAGELIST himl
, DWORD flags
)
2678 FIXME("(%p %08lx):empty stub\n", himl
, flags
);
2683 /*************************************************************************
2684 * ImageList_SetIconSize [COMCTL32.80]
2686 * Sets the image size of the bitmap and deletes all images.
2689 * himl [I] handle to image list
2690 * cx [I] image width
2691 * cy [I] image height
2699 ImageList_SetIconSize (HIMAGELIST himl
, INT cx
, INT cy
)
2706 /* remove all images */
2707 himl
->cMaxImage
= himl
->cInitial
+ himl
->cGrow
;
2708 himl
->cCurImage
= 0;
2712 /* initialize overlay mask indices */
2713 for (nCount
= 0; nCount
< MAX_OVERLAYIMAGE
; nCount
++)
2714 himl
->nOvlIdx
[nCount
] = -1;
2716 DeleteObject (himl
->hbmImage
);
2718 CreateBitmap (himl
->cMaxImage
* himl
->cx
, himl
->cy
,
2719 1, himl
->uBitsPixel
, NULL
);
2721 if (himl
->hbmMask
) {
2722 DeleteObject (himl
->hbmMask
);
2724 CreateBitmap (himl
->cMaxImage
* himl
->cx
, himl
->cy
,
2732 /*************************************************************************
2733 * ImageList_SetImageCount [COMCTL32.81]
2735 * Resizes an image list to the specified number of images.
2738 * himl [I] handle to image list
2739 * iImageCount [I] number of images in the image list
2747 ImageList_SetImageCount (HIMAGELIST himl
, INT iImageCount
)
2749 HDC hdcImageList
, hdcBitmap
;
2750 HBITMAP hbmNewBitmap
;
2751 INT nNewCount
, nCopyCount
;
2755 if (himl
->cCurImage
>= iImageCount
)
2757 if (himl
->cMaxImage
> iImageCount
)
2760 nNewCount
= iImageCount
+ himl
->cGrow
;
2761 nCopyCount
= min(himl
->cCurImage
, iImageCount
);
2763 hdcImageList
= CreateCompatibleDC (0);
2764 hdcBitmap
= CreateCompatibleDC (0);
2766 hbmNewBitmap
= CreateBitmap (nNewCount
* himl
->cx
, himl
->cy
,
2767 1, himl
->uBitsPixel
, NULL
);
2768 if (hbmNewBitmap
!= 0)
2770 SelectObject (hdcImageList
, himl
->hbmImage
);
2771 SelectObject (hdcBitmap
, hbmNewBitmap
);
2774 BitBlt (hdcBitmap
, 0, 0, nCopyCount
* himl
->cx
, himl
->cy
,
2775 hdcImageList
, 0, 0, SRCCOPY
);
2777 /* delete 'empty' image space */
2778 SetBkColor (hdcBitmap
, RGB(255, 255, 255));
2779 SetTextColor (hdcBitmap
, RGB(0, 0, 0));
2780 PatBlt (hdcBitmap
, nCopyCount
* himl
->cx
, 0,
2781 (nNewCount
- nCopyCount
) * himl
->cx
, himl
->cy
, BLACKNESS
);
2783 DeleteObject (himl
->hbmImage
);
2784 himl
->hbmImage
= hbmNewBitmap
;
2787 ERR("Could not create new image bitmap !\n");
2791 hbmNewBitmap
= CreateBitmap (nNewCount
* himl
->cx
, himl
->cy
,
2793 if (hbmNewBitmap
!= 0)
2795 SelectObject (hdcImageList
, himl
->hbmMask
);
2796 SelectObject (hdcBitmap
, hbmNewBitmap
);
2799 BitBlt (hdcBitmap
, 0, 0, nCopyCount
* himl
->cx
, himl
->cy
,
2800 hdcImageList
, 0, 0, SRCCOPY
);
2802 /* delete 'empty' image space */
2803 SetBkColor (hdcBitmap
, RGB(255, 255, 255));
2804 SetTextColor (hdcBitmap
, RGB(0, 0, 0));
2805 PatBlt (hdcBitmap
, nCopyCount
* himl
->cx
, 0,
2806 (nNewCount
- nCopyCount
) * himl
->cx
, himl
->cy
, BLACKNESS
);
2808 DeleteObject (himl
->hbmMask
);
2809 himl
->hbmMask
= hbmNewBitmap
;
2812 ERR("Could not create new mask bitmap!\n");
2815 DeleteDC (hdcImageList
);
2816 DeleteDC (hdcBitmap
);
2818 /* Update max image count and current image count */
2819 himl
->cMaxImage
= nNewCount
;
2820 if (himl
->cCurImage
> nCopyCount
)
2821 himl
->cCurImage
= nCopyCount
;
2827 /*************************************************************************
2828 * ImageList_SetOverlayImage [COMCTL32.82]
2830 * Assigns an overlay mask index to an existing image in an image list.
2833 * himl [I] handle to image list
2834 * iImage [I] image index
2835 * iOverlay [I] overlay mask index
2843 ImageList_SetOverlayImage (HIMAGELIST himl
, INT iImage
, INT iOverlay
)
2847 if ((iOverlay
< 1) || (iOverlay
> MAX_OVERLAYIMAGE
))
2849 if ((iImage
!=-1) && ((iImage
< 0) || (iImage
> himl
->cCurImage
)))
2851 himl
->nOvlIdx
[iOverlay
- 1] = iImage
;
2857 /* helper for ImageList_Write - write bitmap to pstm
2858 * currently everything is written as 24 bit RGB, except masks
2861 _write_bitmap(HBITMAP hBitmap
, LPSTREAM pstm
, int cx
, int cy
)
2863 LPBITMAPFILEHEADER bmfh
;
2864 LPBITMAPINFOHEADER bmih
;
2865 LPBYTE data
, lpBits
, lpBitsOrg
;
2867 INT bitCount
, sizeImage
, offBits
, totalSize
;
2868 INT nwidth
, nheight
, nsizeImage
, icount
;
2870 BOOL result
= FALSE
;
2874 GetObjectA(hBitmap
, sizeof(BITMAP
), (LPVOID
)&bm
);
2876 /* XXX is this always correct? */
2877 icount
= bm
.bmWidth
/ cx
;
2879 nheight
= cy
* ((icount
+3)>>2);
2881 bitCount
= bm
.bmBitsPixel
== 1 ? 1 : 24;
2882 sizeImage
= ((((bm
.bmWidth
* bitCount
)+31) & ~31) >> 3) * bm
.bmHeight
;
2883 nsizeImage
= ((((nwidth
* bitCount
)+31) & ~31) >> 3) * nheight
;
2885 totalSize
= sizeof(BITMAPFILEHEADER
) + sizeof(BITMAPINFOHEADER
);
2887 totalSize
+= (1 << bitCount
) * sizeof(RGBQUAD
);
2888 offBits
= totalSize
;
2889 totalSize
+= nsizeImage
;
2891 data
= (LPBYTE
)LocalAlloc(LMEM_ZEROINIT
, totalSize
);
2892 bmfh
= (LPBITMAPFILEHEADER
)data
;
2893 bmih
= (LPBITMAPINFOHEADER
)(data
+ sizeof(BITMAPFILEHEADER
));
2894 lpBits
= data
+ offBits
;
2896 /* setup BITMAPFILEHEADER */
2897 bmfh
->bfType
= (('M' << 8) | 'B');
2899 bmfh
->bfReserved1
= 0;
2900 bmfh
->bfReserved2
= 0;
2901 bmfh
->bfOffBits
= offBits
;
2903 /* setup BITMAPINFOHEADER */
2904 bmih
->biSize
= sizeof(BITMAPINFOHEADER
);
2905 bmih
->biWidth
= bm
.bmWidth
;
2906 bmih
->biHeight
= bm
.bmHeight
;
2908 bmih
->biBitCount
= bitCount
;
2909 bmih
->biCompression
= BI_RGB
;
2910 bmih
->biSizeImage
= nsizeImage
;
2911 bmih
->biXPelsPerMeter
= 0;
2912 bmih
->biYPelsPerMeter
= 0;
2913 bmih
->biClrUsed
= 0;
2914 bmih
->biClrImportant
= 0;
2916 lpBitsOrg
= (LPBYTE
)LocalAlloc(LMEM_ZEROINIT
, nsizeImage
);
2917 if(!GetDIBits(xdc
, hBitmap
, 0, bm
.bmHeight
, lpBitsOrg
,
2918 (BITMAPINFO
*)bmih
, DIB_RGB_COLORS
))
2922 int obpl
= (((bm
.bmWidth
*bitCount
+31) & ~31)>>3);
2923 int nbpl
= (((nwidth
*bitCount
+31) & ~31)>>3);
2925 for(i
= 0; i
< nheight
; i
++) {
2926 int ooff
= ((nheight
-1-i
)%cy
) * obpl
+ ((i
/cy
) * nbpl
);
2927 int noff
= (nbpl
* (nheight
-1-i
));
2928 memcpy(lpBits
+ noff
, lpBitsOrg
+ ooff
, nbpl
);
2932 bmih
->biWidth
= nwidth
;
2933 bmih
->biHeight
= nheight
;
2937 LPBITMAPINFO inf
= (LPBITMAPINFO
)bmih
;
2938 inf
->bmiColors
[0].rgbRed
= inf
->bmiColors
[0].rgbGreen
= inf
->bmiColors
[0].rgbBlue
= 0;
2939 inf
->bmiColors
[1].rgbRed
= inf
->bmiColors
[1].rgbGreen
= inf
->bmiColors
[1].rgbBlue
= 0xff;
2942 if(!SUCCEEDED(IStream_Write(pstm
, data
, totalSize
, NULL
)))
2949 LocalFree((HLOCAL
)lpBitsOrg
);
2955 /*************************************************************************
2956 * ImageList_Write [COMCTL32.83]
2958 * Writes an image list to a stream.
2961 * himl [I] handle to image list
2962 * pstm [O] Pointer to a stream.
2973 ImageList_Write (HIMAGELIST himl
, LPSTREAM pstm
)
2981 ilHead
.usMagic
= (('L' << 8) | 'I');
2982 ilHead
.usVersion
= 0x101;
2983 ilHead
.cCurImage
= himl
->cCurImage
;
2984 ilHead
.cMaxImage
= himl
->cMaxImage
;
2985 ilHead
.cGrow
= himl
->cGrow
;
2986 ilHead
.cx
= himl
->cx
;
2987 ilHead
.cy
= himl
->cy
;
2988 ilHead
.bkcolor
= himl
->clrBk
;
2989 ilHead
.flags
= himl
->flags
;
2990 for(i
= 0; i
< 4; i
++) {
2991 ilHead
.ovls
[i
] = himl
->nOvlIdx
[i
];
2994 if(!SUCCEEDED(IStream_Write(pstm
, &ilHead
, sizeof(ILHEAD
), NULL
)))
2997 /* write the bitmap */
2998 if(!_write_bitmap(himl
->hbmImage
, pstm
, himl
->cx
, himl
->cy
))
3001 /* write the mask if we have one */
3002 if(himl
->flags
& ILC_MASK
) {
3003 if(!_write_bitmap(himl
->hbmMask
, pstm
, himl
->cx
, himl
->cy
))