?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Use the get_clipped_rects helper in the pen functions.
[wine/multimedia.git] / dlls / comctl32 / imagelist.c
blobc1edbdf17205b5377a1ae0a143221256b63b08f4
1 /*
2 * ImageList implementation
3 *
4 * Copyright 1998 Eric Kohl
5 * Copyright 2000 Jason Mawdsley
6 * Copyright 2001, 2004 Michael Stefaniuc
7 * Copyright 2001 Charles Loep for CodeWeavers
8 * Copyright 2002 Dimitrie O. Paun
9 * Copyright 2009 Owen Rudge for CodeWeavers
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 * NOTE
26 *
27 * This code was audited for completeness against the documented features
28 * of Comctl32.dll version 6.0 on Sep. 12, 2002, by Dimitrie O. Paun.
29 *
30 * Unless otherwise noted, we believe this code to be complete, as per
31 * the specification mentioned above.
32 * If you discover missing features, or bugs, please note them below.
33 *
34 * TODO:
35 * - Add support for ILD_PRESERVEALPHA, ILD_SCALE, ILD_DPISCALE
36 * - Add support for ILS_GLOW, ILS_SHADOW, ILS_SATURATE
37 * - Thread-safe locking
38 */
39
40 #include <stdarg.h>
41 #include <stdlib.h>
42 #include <string.h>
43
44 #define COBJMACROS
45
46 #include "winerror.h"
47 #include "windef.h"
48 #include "winbase.h"
49 #include "objbase.h"
50 #include "wingdi.h"
51 #include "winuser.h"
52 #include "commctrl.h"
53 #include "comctl32.h"
54 #include "commoncontrols.h"
55 #include "wine/debug.h"
56 #include "wine/exception.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(imagelist);
59
60 #define MAX_OVERLAYIMAGE 15
61
62 struct _IMAGELIST
63 {
64 const struct IImageListVtbl *lpVtbl; /* 00: IImageList vtable */
65
66 INT cCurImage; /* 04: ImageCount */
67 INT cMaxImage; /* 08: maximages */
68 INT cGrow; /* 0C: cGrow */
69 INT cx; /* 10: cx */
70 INT cy; /* 14: cy */
71 DWORD x4;
72 UINT flags; /* 1C: flags */
73 COLORREF clrFg; /* 20: foreground color */
74 COLORREF clrBk; /* 24: background color */
75
76
77 HBITMAP hbmImage; /* 28: images Bitmap */
78 HBITMAP hbmMask; /* 2C: masks Bitmap */
79 HDC hdcImage; /* 30: images MemDC */
80 HDC hdcMask; /* 34: masks MemDC */
81 INT nOvlIdx[MAX_OVERLAYIMAGE]; /* 38: overlay images index */
82
83 /* not yet found out */
84 HBRUSH hbrBlend25;
85 HBRUSH hbrBlend50;
86 INT cInitial;
87 UINT uBitsPixel;
88 char *has_alpha;
89
90 LONG ref; /* reference count */
91 };
92
93 #define IMAGELIST_MAGIC 0x53414D58
94
95 /* Header used by ImageList_Read() and ImageList_Write() */
96 #include "pshpack2.h"
97 typedef struct _ILHEAD
98 {
99 USHORT usMagic;
100 USHORT usVersion;
101 WORD cCurImage;
102 WORD cMaxImage;
103 WORD cGrow;
104 WORD cx;
105 WORD cy;
106 COLORREF bkcolor;
107 WORD flags;
108 SHORT ovls[4];
109 } ILHEAD;
110 #include "poppack.h"
111
112 /* internal image list data used for Drag & Drop operations */
113 typedef struct
114 {
115 HWND hwnd;
116 HIMAGELIST himl;
117 /* position of the drag image relative to the window */
118 INT x;
119 INT y;
120 /* offset of the hotspot relative to the origin of the image */
121 INT dxHotspot;
122 INT dyHotspot;
123 /* is the drag image visible */
124 BOOL bShow;
125 /* saved background */
126 HBITMAP hbmBg;
127 } INTERNALDRAG;
128
129 static INTERNALDRAG InternalDrag = { 0, 0, 0, 0, 0, 0, FALSE, 0 };
130
131 static HBITMAP ImageList_CreateImage(HDC hdc, HIMAGELIST himl, UINT count);
132 static HRESULT ImageListImpl_CreateInstance(const IUnknown *pUnkOuter, REFIID iid, void** ppv);
133 static inline BOOL is_valid(HIMAGELIST himl);
134
135 /*
136 * An imagelist with N images is tiled like this:
137 *
138 * N/4 ->
139 *
140 * 4 048C..
141 * 159D..
142 * | 26AE.N
143 * V 37BF.
144 */
145
146 #define TILE_COUNT 4
147
148 static inline UINT imagelist_height( UINT count )
149 {
150 return ((count + TILE_COUNT - 1)/TILE_COUNT);
151 }
152
153 static inline void imagelist_point_from_index( HIMAGELIST himl, UINT index, LPPOINT pt )
154 {
155 pt->x = (index%TILE_COUNT) * himl->cx;
156 pt->y = (index/TILE_COUNT) * himl->cy;
157 }
158
159 static inline void imagelist_get_bitmap_size( HIMAGELIST himl, UINT count, SIZE *sz )
160 {
161 sz->cx = himl->cx * TILE_COUNT;
162 sz->cy = imagelist_height( count ) * himl->cy;
163 }
164
165 static inline int get_dib_stride( int width, int bpp )
166 {
167 return ((width * bpp + 31) >> 3) & ~3;
168 }
169
170 static inline int get_dib_image_size( const BITMAPINFO *info )
171 {
172 return get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount )
173 * abs( info->bmiHeader.biHeight );
174 }
175
176 /*
177 * imagelist_copy_images()
178 *
179 * Copies a block of count images from offset src in the list to offset dest.
180 * Images are copied a row at at time. Assumes hdcSrc and hdcDest are different.
181 */
182 static inline void imagelist_copy_images( HIMAGELIST himl, HDC hdcSrc, HDC hdcDest,
183 UINT src, UINT count, UINT dest )
184 {
185 POINT ptSrc, ptDest;
186 SIZE sz;
187 UINT i;
188
189 for ( i=0; i<TILE_COUNT; i++ )
190 {
191 imagelist_point_from_index( himl, src+i, &ptSrc );
192 imagelist_point_from_index( himl, dest+i, &ptDest );
193 sz.cx = himl->cx;
194 sz.cy = himl->cy * imagelist_height( count - i );
195
196 BitBlt( hdcDest, ptDest.x, ptDest.y, sz.cx, sz.cy,
197 hdcSrc, ptSrc.x, ptSrc.y, SRCCOPY );
198 }
199 }
200
201 static void add_dib_bits( HIMAGELIST himl, int pos, int count, int width, int height,
202 BITMAPINFO *info, BITMAPINFO *mask_info, DWORD *bits, BYTE *mask_bits )
203 {
204 int i, j, n;
205 POINT pt;
206 int stride = info->bmiHeader.biWidth;
207 int mask_stride = (info->bmiHeader.biWidth + 31) / 32 * 4;
208
209 for (n = 0; n < count; n++)
210 {
211 int has_alpha = 0;
212
213 imagelist_point_from_index( himl, pos + n, &pt );
214
215 /* check if bitmap has an alpha channel */
216 for (i = 0; i < height && !has_alpha; i++)
217 for (j = n * width; j < (n + 1) * width; j++)
218 if ((has_alpha = ((bits[i * stride + j] & 0xff000000) != 0))) break;
219
220 if (!has_alpha) /* generate alpha channel from the mask */
221 {
222 for (i = 0; i < height; i++)
223 for (j = n * width; j < (n + 1) * width; j++)
224 if (!mask_info || !((mask_bits[i * mask_stride + j / 8] << (j % 8)) & 0x80))
225 bits[i * stride + j] |= 0xff000000;
226 else
227 bits[i * stride + j] = 0;
228 }
229 else
230 {
231 himl->has_alpha[pos + n] = 1;
232
233 if (mask_info && himl->hbmMask) /* generate the mask from the alpha channel */
234 {
235 for (i = 0; i < height; i++)
236 for (j = n * width; j < (n + 1) * width; j++)
237 if ((bits[i * stride + j] >> 24) > 25) /* more than 10% alpha */
238 mask_bits[i * mask_stride + j / 8] &= ~(0x80 >> (j % 8));
239 else
240 mask_bits[i * mask_stride + j / 8] |= 0x80 >> (j % 8);
241 }
242 }
243 StretchDIBits( himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
244 n * width, 0, width, height, bits, info, DIB_RGB_COLORS, SRCCOPY );
245 if (mask_info)
246 StretchDIBits( himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
247 n * width, 0, width, height, mask_bits, mask_info, DIB_RGB_COLORS, SRCCOPY );
248 }
249 }
250
251 /* add images with an alpha channel when the image list is 32 bpp */
252 static BOOL add_with_alpha( HIMAGELIST himl, HDC hdc, int pos, int count,
253 int width, int height, HBITMAP hbmImage, HBITMAP hbmMask )
254 {
255 BOOL ret = FALSE;
256 BITMAP bm;
257 BITMAPINFO *info, *mask_info = NULL;
258 DWORD *bits = NULL;
259 BYTE *mask_bits = NULL;
260 DWORD mask_width;
261
262 if (!GetObjectW( hbmImage, sizeof(bm), &bm )) return FALSE;
263
264 /* if either the imagelist or the source bitmap don't have an alpha channel, bail out now */
265 if (!himl->has_alpha) return FALSE;
266 if (bm.bmBitsPixel != 32) return FALSE;
267
268 SelectObject( hdc, hbmImage );
269 mask_width = (bm.bmWidth + 31) / 32 * 4;
270
271 if (!(info = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] )))) goto done;
272 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
273 info->bmiHeader.biWidth = bm.bmWidth;
274 info->bmiHeader.biHeight = -height;
275 info->bmiHeader.biPlanes = 1;
276 info->bmiHeader.biBitCount = 32;
277 info->bmiHeader.biCompression = BI_RGB;
278 info->bmiHeader.biSizeImage = bm.bmWidth * height * 4;
279 info->bmiHeader.biXPelsPerMeter = 0;
280 info->bmiHeader.biYPelsPerMeter = 0;
281 info->bmiHeader.biClrUsed = 0;
282 info->bmiHeader.biClrImportant = 0;
283 if (!(bits = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto done;
284 if (!GetDIBits( hdc, hbmImage, 0, height, bits, info, DIB_RGB_COLORS )) goto done;
285
286 if (hbmMask)
287 {
288 if (!(mask_info = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[2] ))))
289 goto done;
290 mask_info->bmiHeader = info->bmiHeader;
291 mask_info->bmiHeader.biBitCount = 1;
292 mask_info->bmiHeader.biSizeImage = mask_width * height;
293 if (!(mask_bits = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage )))
294 goto done;
295 if (!GetDIBits( hdc, hbmMask, 0, height, mask_bits, mask_info, DIB_RGB_COLORS )) goto done;
296 }
297
298 add_dib_bits( himl, pos, count, width, height, info, mask_info, bits, mask_bits );
299 ret = TRUE;
300
301 done:
302 HeapFree( GetProcessHeap(), 0, info );
303 HeapFree( GetProcessHeap(), 0, mask_info );
304 HeapFree( GetProcessHeap(), 0, bits );
305 HeapFree( GetProcessHeap(), 0, mask_bits );
306 return ret;
307 }
308
309 /*************************************************************************
310 * IMAGELIST_InternalExpandBitmaps [Internal]
311 *
312 * Expands the bitmaps of an image list by the given number of images.
313 *
314 * PARAMS
315 * himl [I] handle to image list
316 * nImageCount [I] number of images to add
317 *
318 * RETURNS
319 * nothing
320 *
321 * NOTES
322 * This function CANNOT be used to reduce the number of images.
323 */
324 static void
325 IMAGELIST_InternalExpandBitmaps(HIMAGELIST himl, INT nImageCount)
326 {
327 HDC hdcBitmap;
328 HBITMAP hbmNewBitmap, hbmNull;
329 INT nNewCount;
330 SIZE sz;
331
332 TRACE("%p has allocated %d, max %d, grow %d images\n", himl, himl->cCurImage, himl->cMaxImage, himl->cGrow);
333
334 if (himl->cCurImage + nImageCount < himl->cMaxImage)
335 return;
336
337 nNewCount = himl->cMaxImage + max(nImageCount, himl->cGrow) + 1;
338
339 imagelist_get_bitmap_size(himl, nNewCount, &sz);
340
341 TRACE("Create expanded bitmaps : himl=%p x=%d y=%d count=%d\n", himl, sz.cx, sz.cy, nNewCount);
342 hdcBitmap = CreateCompatibleDC (0);
343
344 hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount);
345
346 if (hbmNewBitmap == 0)
347 ERR("creating new image bitmap (x=%d y=%d)!\n", sz.cx, sz.cy);
348
349 if (himl->cCurImage)
350 {
351 hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
352 BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
353 himl->hdcImage, 0, 0, SRCCOPY);
354 SelectObject (hdcBitmap, hbmNull);
355 }
356 SelectObject (himl->hdcImage, hbmNewBitmap);
357 DeleteObject (himl->hbmImage);
358 himl->hbmImage = hbmNewBitmap;
359
360 if (himl->flags & ILC_MASK)
361 {
362 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
363
364 if (hbmNewBitmap == 0)
365 ERR("creating new mask bitmap!\n");
366
367 if(himl->cCurImage)
368 {
369 hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
370 BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
371 himl->hdcMask, 0, 0, SRCCOPY);
372 SelectObject (hdcBitmap, hbmNull);
373 }
374 SelectObject (himl->hdcMask, hbmNewBitmap);
375 DeleteObject (himl->hbmMask);
376 himl->hbmMask = hbmNewBitmap;
377 }
378
379 if (himl->has_alpha)
380 {
381 char *new_alpha = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, himl->has_alpha, nNewCount );
382 if (new_alpha) himl->has_alpha = new_alpha;
383 else
384 {
385 HeapFree( GetProcessHeap(), 0, himl->has_alpha );
386 himl->has_alpha = NULL;
387 }
388 }
389
390 himl->cMaxImage = nNewCount;
391
392 DeleteDC (hdcBitmap);
393 }
394
395
396 /*************************************************************************
397 * ImageList_Add [COMCTL32.@]
398 *
399 * Add an image or images to an image list.
400 *
401 * PARAMS
402 * himl [I] handle to image list
403 * hbmImage [I] handle to image bitmap
404 * hbmMask [I] handle to mask bitmap
405 *
406 * RETURNS
407 * Success: Index of the first new image.
408 * Failure: -1
409 */
410
411 INT WINAPI
412 ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
413 {
414 HDC hdcBitmap, hdcTemp = 0;
415 INT nFirstIndex, nImageCount, i;
416 BITMAP bmp;
417 POINT pt;
418
419 TRACE("himl=%p hbmimage=%p hbmmask=%p\n", himl, hbmImage, hbmMask);
420 if (!is_valid(himl))
421 return -1;
422
423 if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
424 return -1;
425
426 TRACE("himl %p, cCurImage %d, cMaxImage %d, cGrow %d, cx %d, cy %d\n",
427 himl, himl->cCurImage, himl->cMaxImage, himl->cGrow, himl->cx, himl->cy);
428
429 nImageCount = bmp.bmWidth / himl->cx;
430
431 TRACE("%p has %d images (%d x %d)\n", hbmImage, nImageCount, bmp.bmWidth, bmp.bmHeight);
432
433 IMAGELIST_InternalExpandBitmaps(himl, nImageCount);
434
435 hdcBitmap = CreateCompatibleDC(0);
436
437 SelectObject(hdcBitmap, hbmImage);
438
439 if (add_with_alpha( himl, hdcBitmap, himl->cCurImage, nImageCount,
440 himl->cx, min( himl->cy, bmp.bmHeight), hbmImage, hbmMask ))
441 goto done;
442
443 if (himl->hbmMask)
444 {
445 hdcTemp = CreateCompatibleDC(0);
446 SelectObject(hdcTemp, hbmMask);
447 }
448
449 for (i=0; i<nImageCount; i++)
450 {
451 imagelist_point_from_index( himl, himl->cCurImage + i, &pt );
452
453 /* Copy result to the imagelist
454 */
455 BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
456 hdcBitmap, i*himl->cx, 0, SRCCOPY );
457
458 if (!himl->hbmMask)
459 continue;
460
461 BitBlt( himl->hdcMask, pt.x, pt.y, himl->cx, bmp.bmHeight,
462 hdcTemp, i*himl->cx, 0, SRCCOPY );
463
464 /* Remove the background from the image
465 */
466 BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
467 himl->hdcMask, pt.x, pt.y, 0x220326 ); /* NOTSRCAND */
468 }
469 if (hdcTemp) DeleteDC(hdcTemp);
470
471 done:
472 DeleteDC(hdcBitmap);
473
474 nFirstIndex = himl->cCurImage;
475 himl->cCurImage += nImageCount;
476
477 return nFirstIndex;
478 }
479
480
481 /*************************************************************************
482 * ImageList_AddIcon [COMCTL32.@]
483 *
484 * Adds an icon to an image list.
485 *
486 * PARAMS
487 * himl [I] handle to image list
488 * hIcon [I] handle to icon
489 *
490 * RETURNS
491 * Success: index of the new image
492 * Failure: -1
493 */
494 #undef ImageList_AddIcon
495 INT WINAPI ImageList_AddIcon (HIMAGELIST himl, HICON hIcon)
496 {
497 return ImageList_ReplaceIcon (himl, -1, hIcon);
498 }
499
500
501 /*************************************************************************
502 * ImageList_AddMasked [COMCTL32.@]
503 *
504 * Adds an image or images to an image list and creates a mask from the
505 * specified bitmap using the mask color.
506 *
507 * PARAMS
508 * himl [I] handle to image list.
509 * hBitmap [I] handle to bitmap
510 * clrMask [I] mask color.
511 *
512 * RETURNS
513 * Success: Index of the first new image.
514 * Failure: -1
515 */
516
517 INT WINAPI
518 ImageList_AddMasked (HIMAGELIST himl, HBITMAP hBitmap, COLORREF clrMask)
519 {
520 HDC hdcMask, hdcBitmap;
521 INT ret;
522 BITMAP bmp;
523 HBITMAP hMaskBitmap;
524 COLORREF bkColor;
525
526 TRACE("himl=%p hbitmap=%p clrmask=%x\n", himl, hBitmap, clrMask);
527 if (!is_valid(himl))
528 return -1;
529
530 if (!GetObjectW(hBitmap, sizeof(BITMAP), &bmp))
531 return -1;
532
533 hdcBitmap = CreateCompatibleDC(0);
534 SelectObject(hdcBitmap, hBitmap);
535
536 /* Create a temp Mask so we can remove the background of the Image */
537 hdcMask = CreateCompatibleDC(0);
538 hMaskBitmap = CreateBitmap(bmp.bmWidth, bmp.bmHeight, 1, 1, NULL);
539 SelectObject(hdcMask, hMaskBitmap);
540
541 /* create monochrome image to the mask bitmap */
542 bkColor = (clrMask != CLR_DEFAULT) ? clrMask : GetPixel (hdcBitmap, 0, 0);
543 SetBkColor (hdcBitmap, bkColor);
544 BitBlt (hdcMask, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcBitmap, 0, 0, SRCCOPY);
545
546 /*
547 * Remove the background from the image
548 *
549 * WINDOWS BUG ALERT!!!!!!
550 * The statement below should not be done in common practice
551 * but this is how ImageList_AddMasked works in Windows.
552 * It overwrites the original bitmap passed, this was discovered
553 * by using the same bitmap to iterate the different styles
554 * on windows where it failed (BUT ImageList_Add is OK)
555 * This is here in case some apps rely on this bug
556 *
557 * Blt mode 0x220326 is NOTSRCAND
558 */
559 if (bmp.bmBitsPixel > 8) /* NOTSRCAND can't work with palettes */
560 {
561 SetBkColor(hdcBitmap, RGB(255,255,255));
562 BitBlt(hdcBitmap, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcMask, 0, 0, 0x220326);
563 }
564
565 DeleteDC(hdcBitmap);
566 DeleteDC(hdcMask);
567
568 ret = ImageList_Add( himl, hBitmap, hMaskBitmap );
569
570 DeleteObject(hMaskBitmap);
571 return ret;
572 }
573
574
575 /*************************************************************************
576 * ImageList_BeginDrag [COMCTL32.@]
577 *
578 * Creates a temporary image list that contains one image. It will be used
579 * as a drag image.
580 *
581 * PARAMS
582 * himlTrack [I] handle to the source image list
583 * iTrack [I] index of the drag image in the source image list
584 * dxHotspot [I] X position of the hot spot of the drag image
585 * dyHotspot [I] Y position of the hot spot of the drag image
586 *
587 * RETURNS
588 * Success: TRUE
589 * Failure: FALSE
590 */
591
592 BOOL WINAPI
593 ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack,
594 INT dxHotspot, INT dyHotspot)
595 {
596 INT cx, cy;
597
598 TRACE("(himlTrack=%p iTrack=%d dx=%d dy=%d)\n", himlTrack, iTrack,
599 dxHotspot, dyHotspot);
600
601 if (!is_valid(himlTrack))
602 return FALSE;
603
604 if (InternalDrag.himl)
605 ImageList_EndDrag ();
606
607 cx = himlTrack->cx;
608 cy = himlTrack->cy;
609
610 InternalDrag.himl = ImageList_Create (cx, cy, himlTrack->flags, 1, 1);
611 if (InternalDrag.himl == NULL) {
612 WARN("Error creating drag image list!\n");
613 return FALSE;
614 }
615
616 InternalDrag.dxHotspot = dxHotspot;
617 InternalDrag.dyHotspot = dyHotspot;
618
619 /* copy image */
620 BitBlt (InternalDrag.himl->hdcImage, 0, 0, cx, cy, himlTrack->hdcImage, iTrack * cx, 0, SRCCOPY);
621
622 /* copy mask */
623 BitBlt (InternalDrag.himl->hdcMask, 0, 0, cx, cy, himlTrack->hdcMask, iTrack * cx, 0, SRCCOPY);
624
625 InternalDrag.himl->cCurImage = 1;
626
627 return TRUE;
628 }
629
630
631 /*************************************************************************
632 * ImageList_Copy [COMCTL32.@]
633 *
634 * Copies an image of the source image list to an image of the
635 * destination image list. Images can be copied or swapped.
636 *
637 * PARAMS
638 * himlDst [I] handle to the destination image list
639 * iDst [I] destination image index.
640 * himlSrc [I] handle to the source image list
641 * iSrc [I] source image index
642 * uFlags [I] flags for the copy operation
643 *
644 * RETURNS
645 * Success: TRUE
646 * Failure: FALSE
647 *
648 * NOTES
649 * Copying from one image list to another is possible. The original
650 * implementation just copies or swaps within one image list.
651 * Could this feature become a bug??? ;-)
652 */
653
654 BOOL WINAPI
655 ImageList_Copy (HIMAGELIST himlDst, INT iDst, HIMAGELIST himlSrc,
656 INT iSrc, UINT uFlags)
657 {
658 POINT ptSrc, ptDst;
659
660 TRACE("himlDst=%p iDst=%d himlSrc=%p iSrc=%d\n", himlDst, iDst, himlSrc, iSrc);
661
662 if (!is_valid(himlSrc) || !is_valid(himlDst))
663 return FALSE;
664 if ((iDst < 0) || (iDst >= himlDst->cCurImage))
665 return FALSE;
666 if ((iSrc < 0) || (iSrc >= himlSrc->cCurImage))
667 return FALSE;
668
669 imagelist_point_from_index( himlDst, iDst, &ptDst );
670 imagelist_point_from_index( himlSrc, iSrc, &ptSrc );
671
672 if (uFlags & ILCF_SWAP) {
673 /* swap */
674 HDC hdcBmp;
675 HBITMAP hbmTempImage, hbmTempMask;
676
677 hdcBmp = CreateCompatibleDC (0);
678
679 /* create temporary bitmaps */
680 hbmTempImage = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
681 himlSrc->uBitsPixel, NULL);
682 hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
683 1, NULL);
684
685 /* copy (and stretch) destination to temporary bitmaps.(save) */
686 /* image */
687 SelectObject (hdcBmp, hbmTempImage);
688 StretchBlt (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
689 himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
690 SRCCOPY);
691 /* mask */
692 SelectObject (hdcBmp, hbmTempMask);
693 StretchBlt (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
694 himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
695 SRCCOPY);
696
697 /* copy (and stretch) source to destination */
698 /* image */
699 StretchBlt (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
700 himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
701 SRCCOPY);
702 /* mask */
703 StretchBlt (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
704 himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
705 SRCCOPY);
706
707 /* copy (without stretching) temporary bitmaps to source (restore) */
708 /* mask */
709 BitBlt (himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
710 hdcBmp, 0, 0, SRCCOPY);
711
712 /* image */
713 BitBlt (himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
714 hdcBmp, 0, 0, SRCCOPY);
715 /* delete temporary bitmaps */
716 DeleteObject (hbmTempMask);
717 DeleteObject (hbmTempImage);
718 DeleteDC(hdcBmp);
719 }
720 else {
721 /* copy image */
722 StretchBlt (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
723 himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
724 SRCCOPY);
725
726 /* copy mask */
727 StretchBlt (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
728 himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
729 SRCCOPY);
730 }
731
732 return TRUE;
733 }
734
735
736 /*************************************************************************
737 * ImageList_Create [COMCTL32.@]
738 *
739 * Creates a new image list.
740 *
741 * PARAMS
742 * cx [I] image height
743 * cy [I] image width
744 * flags [I] creation flags
745 * cInitial [I] initial number of images in the image list
746 * cGrow [I] number of images by which image list grows
747 *
748 * RETURNS
749 * Success: Handle to the created image list
750 * Failure: NULL
751 */
752 HIMAGELIST WINAPI
753 ImageList_Create (INT cx, INT cy, UINT flags,
754 INT cInitial, INT cGrow)
755 {
756 HIMAGELIST himl;
757 INT nCount;
758 HBITMAP hbmTemp;
759 UINT ilc = (flags & 0xFE);
760 static const WORD aBitBlend25[] =
761 {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
762
763 static const WORD aBitBlend50[] =
764 {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
765
766 TRACE("(%d %d 0x%x %d %d)\n", cx, cy, flags, cInitial, cGrow);
767
768 if (cx <= 0 || cy <= 0) return NULL;
769
770 /* Create the IImageList interface for the image list */
771 if (FAILED(ImageListImpl_CreateInstance(NULL, &IID_IImageList, (void **)&himl)))
772 return NULL;
773
774 cGrow = (cGrow < 4) ? 4 : (cGrow + 3) & ~3;
775
776 himl->cx = cx;
777 himl->cy = cy;
778 himl->flags = flags;
779 himl->cMaxImage = cInitial + 1;
780 himl->cInitial = cInitial;
781 himl->cGrow = cGrow;
782 himl->clrFg = CLR_DEFAULT;
783 himl->clrBk = CLR_NONE;
784
785 /* initialize overlay mask indices */
786 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
787 himl->nOvlIdx[nCount] = -1;
788
789 /* Create Image & Mask DCs */
790 himl->hdcImage = CreateCompatibleDC (0);
791 if (!himl->hdcImage)
792 goto cleanup;
793 if (himl->flags & ILC_MASK){
794 himl->hdcMask = CreateCompatibleDC(0);
795 if (!himl->hdcMask)
796 goto cleanup;
797 }
798
799 /* Default to ILC_COLOR4 if none of the ILC_COLOR* flags are specified */
800 if (ilc == ILC_COLOR)
801 {
802 ilc = ILC_COLOR4;
803 himl->flags |= ILC_COLOR4;
804 }
805
806 if (ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32)
807 himl->uBitsPixel = ilc;
808 else
809 himl->uBitsPixel = (UINT)GetDeviceCaps (himl->hdcImage, BITSPIXEL);
810
811 if (himl->cMaxImage > 0) {
812 himl->hbmImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
813 SelectObject(himl->hdcImage, himl->hbmImage);
814 } else
815 himl->hbmImage = 0;
816
817 if ((himl->cMaxImage > 0) && (himl->flags & ILC_MASK)) {
818 SIZE sz;
819
820 imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
821 himl->hbmMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
822 if (himl->hbmMask == 0) {
823 ERR("Error creating mask bitmap!\n");
824 goto cleanup;
825 }
826 SelectObject(himl->hdcMask, himl->hbmMask);
827 }
828 else
829 himl->hbmMask = 0;
830
831 if (ilc == ILC_COLOR32)
832 himl->has_alpha = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, himl->cMaxImage );
833 else
834 himl->has_alpha = NULL;
835
836 /* create blending brushes */
837 hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend25);
838 himl->hbrBlend25 = CreatePatternBrush (hbmTemp);
839 DeleteObject (hbmTemp);
840
841 hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend50);
842 himl->hbrBlend50 = CreatePatternBrush (hbmTemp);
843 DeleteObject (hbmTemp);
844
845 TRACE("created imagelist %p\n", himl);
846 return himl;
847
848 cleanup:
849 ImageList_Destroy(himl);
850 return NULL;
851 }
852
853
854 /*************************************************************************
855 * ImageList_Destroy [COMCTL32.@]
856 *
857 * Destroys an image list.
858 *
859 * PARAMS
860 * himl [I] handle to image list
861 *
862 * RETURNS
863 * Success: TRUE
864 * Failure: FALSE
865 */
866
867 BOOL WINAPI
868 ImageList_Destroy (HIMAGELIST himl)
869 {
870 if (!is_valid(himl))
871 return FALSE;
872
873 IImageList_Release((IImageList *) himl);
874 return TRUE;
875 }
876
877
878 /*************************************************************************
879 * ImageList_DragEnter [COMCTL32.@]
880 *
881 * Locks window update and displays the drag image at the given position.
882 *
883 * PARAMS
884 * hwndLock [I] handle of the window that owns the drag image.
885 * x [I] X position of the drag image.
886 * y [I] Y position of the drag image.
887 *
888 * RETURNS
889 * Success: TRUE
890 * Failure: FALSE
891 *
892 * NOTES
893 * The position of the drag image is relative to the window, not
894 * the client area.
895 */
896
897 BOOL WINAPI
898 ImageList_DragEnter (HWND hwndLock, INT x, INT y)
899 {
900 TRACE("(hwnd=%p x=%d y=%d)\n", hwndLock, x, y);
901
902 if (!is_valid(InternalDrag.himl))
903 return FALSE;
904
905 if (hwndLock)
906 InternalDrag.hwnd = hwndLock;
907 else
908 InternalDrag.hwnd = GetDesktopWindow ();
909
910 InternalDrag.x = x;
911 InternalDrag.y = y;
912
913 /* draw the drag image and save the background */
914 if (!ImageList_DragShowNolock(TRUE)) {
915 return FALSE;
916 }
917
918 return TRUE;
919 }
920
921
922 /*************************************************************************
923 * ImageList_DragLeave [COMCTL32.@]
924 *
925 * Unlocks window update and hides the drag image.
926 *
927 * PARAMS
928 * hwndLock [I] handle of the window that owns the drag image.
929 *
930 * RETURNS
931 * Success: TRUE
932 * Failure: FALSE
933 */
934
935 BOOL WINAPI
936 ImageList_DragLeave (HWND hwndLock)
937 {
938 /* As we don't save drag info in the window this can lead to problems if
939 an app does not supply the same window as DragEnter */
940 /* if (hwndLock)
941 InternalDrag.hwnd = hwndLock;
942 else
943 InternalDrag.hwnd = GetDesktopWindow (); */
944 if(!hwndLock)
945 hwndLock = GetDesktopWindow();
946 if(InternalDrag.hwnd != hwndLock)
947 FIXME("DragLeave hWnd != DragEnter hWnd\n");
948
949 ImageList_DragShowNolock (FALSE);
950
951 return TRUE;
952 }
953
954
955 /*************************************************************************
956 * ImageList_InternalDragDraw [Internal]
957 *
958 * Draws the drag image.
959 *
960 * PARAMS
961 * hdc [I] device context to draw into.
962 * x [I] X position of the drag image.
963 * y [I] Y position of the drag image.
964 *
965 * RETURNS
966 * Success: TRUE
967 * Failure: FALSE
968 *
969 * NOTES
970 * The position of the drag image is relative to the window, not
971 * the client area.
972 *
973 */
974
975 static inline void
976 ImageList_InternalDragDraw (HDC hdc, INT x, INT y)
977 {
978 IMAGELISTDRAWPARAMS imldp;
979
980 ZeroMemory (&imldp, sizeof(imldp));
981 imldp.cbSize = sizeof(imldp);
982 imldp.himl = InternalDrag.himl;
983 imldp.i = 0;
984 imldp.hdcDst = hdc,
985 imldp.x = x;
986 imldp.y = y;
987 imldp.rgbBk = CLR_DEFAULT;
988 imldp.rgbFg = CLR_DEFAULT;
989 imldp.fStyle = ILD_NORMAL;
990 imldp.fState = ILS_ALPHA;
991 imldp.Frame = 192;
992 ImageList_DrawIndirect (&imldp);
993 }
994
995 /*************************************************************************
996 * ImageList_DragMove [COMCTL32.@]
997 *
998 * Moves the drag image.
999 *
1000 * PARAMS
1001 * x [I] X position of the drag image.
1002 * y [I] Y position of the drag image.
1003 *
1004 * RETURNS
1005 * Success: TRUE
1006 * Failure: FALSE
1007 *
1008 * NOTES
1009 * The position of the drag image is relative to the window, not
1010 * the client area.
1011 */
1012
1013 BOOL WINAPI
1014 ImageList_DragMove (INT x, INT y)
1015 {
1016 TRACE("(x=%d y=%d)\n", x, y);
1017
1018 if (!is_valid(InternalDrag.himl))
1019 return FALSE;
1020
1021 /* draw/update the drag image */
1022 if (InternalDrag.bShow) {
1023 HDC hdcDrag;
1024 HDC hdcOffScreen;
1025 HDC hdcBg;
1026 HBITMAP hbmOffScreen;
1027 INT origNewX, origNewY;
1028 INT origOldX, origOldY;
1029 INT origRegX, origRegY;
1030 INT sizeRegX, sizeRegY;
1031
1032
1033 /* calculate the update region */
1034 origNewX = x - InternalDrag.dxHotspot;
1035 origNewY = y - InternalDrag.dyHotspot;
1036 origOldX = InternalDrag.x - InternalDrag.dxHotspot;
1037 origOldY = InternalDrag.y - InternalDrag.dyHotspot;
1038 origRegX = min(origNewX, origOldX);
1039 origRegY = min(origNewY, origOldY);
1040 sizeRegX = InternalDrag.himl->cx + abs(x - InternalDrag.x);
1041 sizeRegY = InternalDrag.himl->cy + abs(y - InternalDrag.y);
1042
1043 hdcDrag = GetDCEx(InternalDrag.hwnd, 0,
1044 DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
1045 hdcOffScreen = CreateCompatibleDC(hdcDrag);
1046 hdcBg = CreateCompatibleDC(hdcDrag);
1047
1048 hbmOffScreen = CreateCompatibleBitmap(hdcDrag, sizeRegX, sizeRegY);
1049 SelectObject(hdcOffScreen, hbmOffScreen);
1050 SelectObject(hdcBg, InternalDrag.hbmBg);
1051
1052 /* get the actual background of the update region */
1053 BitBlt(hdcOffScreen, 0, 0, sizeRegX, sizeRegY, hdcDrag,
1054 origRegX, origRegY, SRCCOPY);
1055 /* erase the old image */
1056 BitBlt(hdcOffScreen, origOldX - origRegX, origOldY - origRegY,
1057 InternalDrag.himl->cx, InternalDrag.himl->cy, hdcBg, 0, 0,
1058 SRCCOPY);
1059 /* save the background */
1060 BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
1061 hdcOffScreen, origNewX - origRegX, origNewY - origRegY, SRCCOPY);
1062 /* draw the image */
1063 ImageList_InternalDragDraw(hdcOffScreen, origNewX - origRegX,
1064 origNewY - origRegY);
1065 /* draw the update region to the screen */
1066 BitBlt(hdcDrag, origRegX, origRegY, sizeRegX, sizeRegY,
1067 hdcOffScreen, 0, 0, SRCCOPY);
1068
1069 DeleteDC(hdcBg);
1070 DeleteDC(hdcOffScreen);
1071 DeleteObject(hbmOffScreen);
1072 ReleaseDC(InternalDrag.hwnd, hdcDrag);
1073 }
1074
1075 /* update the image position */
1076 InternalDrag.x = x;
1077 InternalDrag.y = y;
1078
1079 return TRUE;
1080 }
1081
1082
1083 /*************************************************************************
1084 * ImageList_DragShowNolock [COMCTL32.@]
1085 *
1086 * Shows or hides the drag image.
1087 *
1088 * PARAMS
1089 * bShow [I] TRUE shows the drag image, FALSE hides it.
1090 *
1091 * RETURNS
1092 * Success: TRUE
1093 * Failure: FALSE
1094 */
1095
1096 BOOL WINAPI
1097 ImageList_DragShowNolock (BOOL bShow)
1098 {
1099 HDC hdcDrag;
1100 HDC hdcBg;
1101 INT x, y;
1102
1103 if (!is_valid(InternalDrag.himl))
1104 return FALSE;
1105
1106 TRACE("bShow=0x%X!\n", bShow);
1107
1108 /* DragImage is already visible/hidden */
1109 if ((InternalDrag.bShow && bShow) || (!InternalDrag.bShow && !bShow)) {
1110 return FALSE;
1111 }
1112
1113 /* position of the origin of the DragImage */
1114 x = InternalDrag.x - InternalDrag.dxHotspot;
1115 y = InternalDrag.y - InternalDrag.dyHotspot;
1116
1117 hdcDrag = GetDCEx (InternalDrag.hwnd, 0,
1118 DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
1119 if (!hdcDrag) {
1120 return FALSE;
1121 }
1122
1123 hdcBg = CreateCompatibleDC(hdcDrag);
1124 if (!InternalDrag.hbmBg) {
1125 InternalDrag.hbmBg = CreateCompatibleBitmap(hdcDrag,
1126 InternalDrag.himl->cx, InternalDrag.himl->cy);
1127 }
1128 SelectObject(hdcBg, InternalDrag.hbmBg);
1129
1130 if (bShow) {
1131 /* save the background */
1132 BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
1133 hdcDrag, x, y, SRCCOPY);
1134 /* show the image */
1135 ImageList_InternalDragDraw(hdcDrag, x, y);
1136 } else {
1137 /* hide the image */
1138 BitBlt(hdcDrag, x, y, InternalDrag.himl->cx, InternalDrag.himl->cy,
1139 hdcBg, 0, 0, SRCCOPY);
1140 }
1141
1142 InternalDrag.bShow = !InternalDrag.bShow;
1143
1144 DeleteDC(hdcBg);
1145 ReleaseDC (InternalDrag.hwnd, hdcDrag);
1146 return TRUE;
1147 }
1148
1149
1150 /*************************************************************************
1151 * ImageList_Draw [COMCTL32.@]
1152 *
1153 * Draws an image.
1154 *
1155 * PARAMS
1156 * himl [I] handle to image list
1157 * i [I] image index
1158 * hdc [I] handle to device context
1159 * x [I] x position
1160 * y [I] y position
1161 * fStyle [I] drawing flags
1162 *
1163 * RETURNS
1164 * Success: TRUE
1165 * Failure: FALSE
1166 *
1167 * SEE
1168 * ImageList_DrawEx.
1169 */
1170
1171 BOOL WINAPI
1172 ImageList_Draw (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
1173 {
1174 return ImageList_DrawEx (himl, i, hdc, x, y, 0, 0,
1175 CLR_DEFAULT, CLR_DEFAULT, fStyle);
1176 }
1177
1178
1179 /*************************************************************************
1180 * ImageList_DrawEx [COMCTL32.@]
1181 *
1182 * Draws an image and allows to use extended drawing features.
1183 *
1184 * PARAMS
1185 * himl [I] handle to image list
1186 * i [I] image index
1187 * hdc [I] handle to device context
1188 * x [I] X position
1189 * y [I] Y position
1190 * dx [I] X offset
1191 * dy [I] Y offset
1192 * rgbBk [I] background color
1193 * rgbFg [I] foreground color
1194 * fStyle [I] drawing flags
1195 *
1196 * RETURNS
1197 * Success: TRUE
1198 * Failure: FALSE
1199 *
1200 * NOTES
1201 * Calls ImageList_DrawIndirect.
1202 *
1203 * SEE
1204 * ImageList_DrawIndirect.
1205 */
1206
1207 BOOL WINAPI
1208 ImageList_DrawEx (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y,
1209 INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg,
1210 UINT fStyle)
1211 {
1212 IMAGELISTDRAWPARAMS imldp;
1213
1214 ZeroMemory (&imldp, sizeof(imldp));
1215 imldp.cbSize = sizeof(imldp);
1216 imldp.himl = himl;
1217 imldp.i = i;
1218 imldp.hdcDst = hdc,
1219 imldp.x = x;
1220 imldp.y = y;
1221 imldp.cx = dx;
1222 imldp.cy = dy;
1223 imldp.rgbBk = rgbBk;
1224 imldp.rgbFg = rgbFg;
1225 imldp.fStyle = fStyle;
1226
1227 return ImageList_DrawIndirect (&imldp);
1228 }
1229
1230
1231 static BOOL alpha_blend_image( HIMAGELIST himl, HDC dest_dc, int dest_x, int dest_y,
1232 int src_x, int src_y, int cx, int cy, BLENDFUNCTION func,
1233 UINT style, COLORREF blend_col )
1234 {
1235 BOOL ret = FALSE;
1236 HDC hdc;
1237 HBITMAP bmp = 0, mask = 0;
1238 BITMAPINFO *info;
1239 void *bits, *mask_bits;
1240 unsigned int *ptr;
1241 int i, j;
1242
1243 if (!(hdc = CreateCompatibleDC( 0 ))) return FALSE;
1244 if (!(info = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] )))) goto done;
1245 info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1246 info->bmiHeader.biWidth = cx;
1247 info->bmiHeader.biHeight = cy;
1248 info->bmiHeader.biPlanes = 1;
1249 info->bmiHeader.biBitCount = 32;
1250 info->bmiHeader.biCompression = BI_RGB;
1251 info->bmiHeader.biSizeImage = cx * cy * 4;
1252 info->bmiHeader.biXPelsPerMeter = 0;
1253 info->bmiHeader.biYPelsPerMeter = 0;
1254 info->bmiHeader.biClrUsed = 0;
1255 info->bmiHeader.biClrImportant = 0;
1256 if (!(bmp = CreateDIBSection( himl->hdcImage, info, DIB_RGB_COLORS, &bits, 0, 0 ))) goto done;
1257 SelectObject( hdc, bmp );
1258 BitBlt( hdc, 0, 0, cx, cy, himl->hdcImage, src_x, src_y, SRCCOPY );
1259
1260 if (blend_col != CLR_NONE)
1261 {
1262 BYTE r = GetRValue( blend_col );
1263 BYTE g = GetGValue( blend_col );
1264 BYTE b = GetBValue( blend_col );
1265
1266 if (style & ILD_BLEND25)
1267 {
1268 for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
1269 *ptr = ((*ptr & 0xff000000) |
1270 ((((*ptr & 0x00ff0000) * 3 + (r << 16)) / 4) & 0x00ff0000) |
1271 ((((*ptr & 0x0000ff00) * 3 + (g << 8)) / 4) & 0x0000ff00) |
1272 ((((*ptr & 0x000000ff) * 3 + (b << 0)) / 4) & 0x000000ff));
1273 }
1274 else if (style & ILD_BLEND50)
1275 {
1276 for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
1277 *ptr = ((*ptr & 0xff000000) |
1278 ((((*ptr & 0x00ff0000) + (r << 16)) / 2) & 0x00ff0000) |
1279 ((((*ptr & 0x0000ff00) + (g << 8)) / 2) & 0x0000ff00) |
1280 ((((*ptr & 0x000000ff) + (b << 0)) / 2) & 0x000000ff));
1281 }
1282 }
1283
1284 if (himl->has_alpha) /* we already have an alpha channel in this case */
1285 {
1286 /* pre-multiply by the alpha channel */
1287 for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
1288 {
1289 DWORD alpha = *ptr >> 24;
1290 *ptr = ((*ptr & 0xff000000) |
1291 (((*ptr & 0x00ff0000) * alpha / 255) & 0x00ff0000) |
1292 (((*ptr & 0x0000ff00) * alpha / 255) & 0x0000ff00) |
1293 (((*ptr & 0x000000ff) * alpha / 255)));
1294 }
1295 }
1296 else if (himl->hbmMask)
1297 {
1298 unsigned int width_bytes = (cx + 31) / 32 * 4;
1299 /* generate alpha channel from the mask */
1300 info->bmiHeader.biBitCount = 1;
1301 info->bmiHeader.biSizeImage = width_bytes * cy;
1302 info->bmiColors[0].rgbRed = 0;
1303 info->bmiColors[0].rgbGreen = 0;
1304 info->bmiColors[0].rgbBlue = 0;
1305 info->bmiColors[0].rgbReserved = 0;
1306 info->bmiColors[1].rgbRed = 0xff;
1307 info->bmiColors[1].rgbGreen = 0xff;
1308 info->bmiColors[1].rgbBlue = 0xff;
1309 info->bmiColors[1].rgbReserved = 0;
1310 if (!(mask = CreateDIBSection( himl->hdcMask, info, DIB_RGB_COLORS, &mask_bits, 0, 0 )))
1311 goto done;
1312 SelectObject( hdc, mask );
1313 BitBlt( hdc, 0, 0, cx, cy, himl->hdcMask, src_x, src_y, SRCCOPY );
1314 SelectObject( hdc, bmp );
1315 for (i = 0, ptr = bits; i < cy; i++)
1316 for (j = 0; j < cx; j++, ptr++)
1317 if ((((BYTE *)mask_bits)[i * width_bytes + j / 8] << (j % 8)) & 0x80) *ptr = 0;
1318 else *ptr |= 0xff000000;
1319 }
1320
1321 ret = GdiAlphaBlend( dest_dc, dest_x, dest_y, cx, cy, hdc, 0, 0, cx, cy, func );
1322
1323 done:
1324 DeleteDC( hdc );
1325 if (bmp) DeleteObject( bmp );
1326 if (mask) DeleteObject( mask );
1327 HeapFree( GetProcessHeap(), 0, info );
1328 return ret;
1329 }
1330
1331 /*************************************************************************
1332 * ImageList_DrawIndirect [COMCTL32.@]
1333 *
1334 * Draws an image using various parameters specified in pimldp.
1335 *
1336 * PARAMS
1337 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
1338 *
1339 * RETURNS
1340 * Success: TRUE
1341 * Failure: FALSE
1342 */
1343
1344 BOOL WINAPI
1345 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
1346 {
1347 INT cx, cy, nOvlIdx;
1348 DWORD fState, dwRop;
1349 UINT fStyle;
1350 COLORREF oldImageBk, oldImageFg;
1351 HDC hImageDC, hImageListDC, hMaskListDC;
1352 HBITMAP hImageBmp, hOldImageBmp, hBlendMaskBmp;
1353 BOOL bIsTransparent, bBlend, bResult = FALSE, bMask;
1354 HIMAGELIST himl;
1355 HBRUSH hOldBrush;
1356 POINT pt;
1357 BOOL has_alpha;
1358
1359 if (!pimldp || !(himl = pimldp->himl)) return FALSE;
1360 if (!is_valid(himl)) return FALSE;
1361 if ((pimldp->i < 0) || (pimldp->i >= himl->cCurImage)) return FALSE;
1362
1363 imagelist_point_from_index( himl, pimldp->i, &pt );
1364 pt.x += pimldp->xBitmap;
1365 pt.y += pimldp->yBitmap;
1366
1367 fState = pimldp->cbSize < sizeof(IMAGELISTDRAWPARAMS) ? ILS_NORMAL : pimldp->fState;
1368 fStyle = pimldp->fStyle & ~ILD_OVERLAYMASK;
1369 cx = (pimldp->cx == 0) ? himl->cx : pimldp->cx;
1370 cy = (pimldp->cy == 0) ? himl->cy : pimldp->cy;
1371
1372 bIsTransparent = (fStyle & ILD_TRANSPARENT);
1373 if( pimldp->rgbBk == CLR_NONE )
1374 bIsTransparent = TRUE;
1375 if( ( pimldp->rgbBk == CLR_DEFAULT ) && ( himl->clrBk == CLR_NONE ) )
1376 bIsTransparent = TRUE;
1377 bMask = (himl->flags & ILC_MASK) && (fStyle & ILD_MASK) ;
1378 bBlend = (fStyle & (ILD_BLEND25 | ILD_BLEND50) ) && !bMask;
1379
1380 TRACE("himl(%p) hbmMask(%p) iImage(%d) x(%d) y(%d) cx(%d) cy(%d)\n",
1381 himl, himl->hbmMask, pimldp->i, pimldp->x, pimldp->y, cx, cy);
1382
1383 /* we will use these DCs to access the images and masks in the ImageList */
1384 hImageListDC = himl->hdcImage;
1385 hMaskListDC = himl->hdcMask;
1386
1387 /* these will accumulate the image and mask for the image we're drawing */
1388 hImageDC = CreateCompatibleDC( pimldp->hdcDst );
1389 hImageBmp = CreateCompatibleBitmap( pimldp->hdcDst, cx, cy );
1390 hBlendMaskBmp = bBlend ? CreateBitmap(cx, cy, 1, 1, NULL) : 0;
1391
1392 /* Create a compatible DC. */
1393 if (!hImageListDC || !hImageDC || !hImageBmp ||
1394 (bBlend && !hBlendMaskBmp) || (himl->hbmMask && !hMaskListDC))
1395 goto cleanup;
1396
1397 hOldImageBmp = SelectObject(hImageDC, hImageBmp);
1398
1399 /*
1400 * To obtain a transparent look, background color should be set
1401 * to white and foreground color to black when blitting the
1402 * monochrome mask.
1403 */
1404 oldImageFg = SetTextColor( hImageDC, RGB( 0, 0, 0 ) );
1405 oldImageBk = SetBkColor( hImageDC, RGB( 0xff, 0xff, 0xff ) );
1406
1407 has_alpha = (himl->has_alpha && himl->has_alpha[pimldp->i]);
1408 if (!bMask && (has_alpha || (fState & ILS_ALPHA)))
1409 {
1410 COLORREF colour, blend_col = CLR_NONE;
1411 BLENDFUNCTION func;
1412
1413 if (bBlend)
1414 {
1415 blend_col = pimldp->rgbFg;
1416 if (blend_col == CLR_DEFAULT) blend_col = GetSysColor( COLOR_HIGHLIGHT );
1417 else if (blend_col == CLR_NONE) blend_col = GetTextColor( pimldp->hdcDst );
1418 }
1419
1420 func.BlendOp = AC_SRC_OVER;
1421 func.BlendFlags = 0;
1422 func.SourceConstantAlpha = (fState & ILS_ALPHA) ? pimldp->Frame : 255;
1423 func.AlphaFormat = AC_SRC_ALPHA;
1424
1425 if (bIsTransparent)
1426 {
1427 bResult = alpha_blend_image( himl, pimldp->hdcDst, pimldp->x, pimldp->y,
1428 pt.x, pt.y, cx, cy, func, fStyle, blend_col );
1429 goto end;
1430 }
1431 colour = pimldp->rgbBk;
1432 if (colour == CLR_DEFAULT) colour = himl->clrBk;
1433 if (colour == CLR_NONE) colour = GetBkColor( pimldp->hdcDst );
1434
1435 hOldBrush = SelectObject (hImageDC, CreateSolidBrush (colour));
1436 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
1437 alpha_blend_image( himl, hImageDC, 0, 0, pt.x, pt.y, cx, cy, func, fStyle, blend_col );
1438 DeleteObject (SelectObject (hImageDC, hOldBrush));
1439 bResult = BitBlt( pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hImageDC, 0, 0, SRCCOPY );
1440 goto end;
1441 }
1442
1443 /*
1444 * Draw the initial image
1445 */
1446 if( bMask ) {
1447 if (himl->hbmMask) {
1448 hOldBrush = SelectObject (hImageDC, CreateSolidBrush (GetTextColor(pimldp->hdcDst)));
1449 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
1450 BitBlt(hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCPAINT);
1451 DeleteObject (SelectObject (hImageDC, hOldBrush));
1452 if( bIsTransparent )
1453 {
1454 BitBlt ( pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hImageDC, 0, 0, SRCAND);
1455 bResult = TRUE;
1456 goto end;
1457 }
1458 } else {
1459 hOldBrush = SelectObject (hImageDC, GetStockObject(BLACK_BRUSH));
1460 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY);
1461 SelectObject(hImageDC, hOldBrush);
1462 }
1463 } else {
1464 /* blend the image with the needed solid background */
1465 COLORREF colour = RGB(0,0,0);
1466
1467 if( !bIsTransparent )
1468 {
1469 colour = pimldp->rgbBk;
1470 if( colour == CLR_DEFAULT )
1471 colour = himl->clrBk;
1472 if( colour == CLR_NONE )
1473 colour = GetBkColor(pimldp->hdcDst);
1474 }
1475
1476 hOldBrush = SelectObject (hImageDC, CreateSolidBrush (colour));
1477 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
1478 if (himl->hbmMask)
1479 {
1480 BitBlt( hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND );
1481 BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCPAINT );
1482 }
1483 else
1484 BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCCOPY);
1485 DeleteObject (SelectObject (hImageDC, hOldBrush));
1486 }
1487
1488 /* Time for blending, if required */
1489 if (bBlend) {
1490 HBRUSH hBlendBrush;
1491 COLORREF clrBlend = pimldp->rgbFg;
1492 HDC hBlendMaskDC = hImageListDC;
1493 HBITMAP hOldBitmap;
1494
1495 /* Create the blend Mask */
1496 hOldBitmap = SelectObject(hBlendMaskDC, hBlendMaskBmp);
1497 hBlendBrush = fStyle & ILD_BLEND50 ? himl->hbrBlend50 : himl->hbrBlend25;
1498 hOldBrush = SelectObject(hBlendMaskDC, hBlendBrush);
1499 PatBlt(hBlendMaskDC, 0, 0, cx, cy, PATCOPY);
1500 SelectObject(hBlendMaskDC, hOldBrush);
1501
1502 /* Modify the blend mask if an Image Mask exist */
1503 if(himl->hbmMask) {
1504 BitBlt(hBlendMaskDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, 0x220326); /* NOTSRCAND */
1505 BitBlt(hBlendMaskDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, NOTSRCCOPY);
1506 }
1507
1508 /* now apply blend to the current image given the BlendMask */
1509 if (clrBlend == CLR_DEFAULT) clrBlend = GetSysColor (COLOR_HIGHLIGHT);
1510 else if (clrBlend == CLR_NONE) clrBlend = GetTextColor (pimldp->hdcDst);
1511 hOldBrush = SelectObject (hImageDC, CreateSolidBrush(clrBlend));
1512 BitBlt (hImageDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, 0xB8074A); /* PSDPxax */
1513 DeleteObject(SelectObject(hImageDC, hOldBrush));
1514 SelectObject(hBlendMaskDC, hOldBitmap);
1515 }
1516
1517 /* Now do the overlay image, if any */
1518 nOvlIdx = (pimldp->fStyle & ILD_OVERLAYMASK) >> 8;
1519 if ( (nOvlIdx >= 1) && (nOvlIdx <= MAX_OVERLAYIMAGE)) {
1520 nOvlIdx = himl->nOvlIdx[nOvlIdx - 1];
1521 if ((nOvlIdx >= 0) && (nOvlIdx < himl->cCurImage)) {
1522 POINT ptOvl;
1523 imagelist_point_from_index( himl, nOvlIdx, &ptOvl );
1524 ptOvl.x += pimldp->xBitmap;
1525 if (himl->hbmMask && !(fStyle & ILD_IMAGE))
1526 BitBlt (hImageDC, 0, 0, cx, cy, hMaskListDC, ptOvl.x, ptOvl.y, SRCAND);
1527 BitBlt (hImageDC, 0, 0, cx, cy, hImageListDC, ptOvl.x, ptOvl.y, SRCPAINT);
1528 }
1529 }
1530
1531 if (fState & ILS_SATURATE) FIXME("ILS_SATURATE: unimplemented!\n");
1532 if (fState & ILS_GLOW) FIXME("ILS_GLOW: unimplemented!\n");
1533 if (fState & ILS_SHADOW) FIXME("ILS_SHADOW: unimplemented!\n");
1534
1535 if (fStyle & ILD_PRESERVEALPHA) FIXME("ILD_PRESERVEALPHA: unimplemented!\n");
1536 if (fStyle & ILD_SCALE) FIXME("ILD_SCALE: unimplemented!\n");
1537 if (fStyle & ILD_DPISCALE) FIXME("ILD_DPISCALE: unimplemented!\n");
1538
1539 /* now copy the image to the screen */
1540 dwRop = SRCCOPY;
1541 if (himl->hbmMask && bIsTransparent ) {
1542 COLORREF oldDstFg = SetTextColor(pimldp->hdcDst, RGB( 0, 0, 0 ) );
1543 COLORREF oldDstBk = SetBkColor(pimldp->hdcDst, RGB( 0xff, 0xff, 0xff ));
1544 BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND);
1545 SetBkColor(pimldp->hdcDst, oldDstBk);
1546 SetTextColor(pimldp->hdcDst, oldDstFg);
1547 dwRop = SRCPAINT;
1548 }
1549 if (fStyle & ILD_ROP) dwRop = pimldp->dwRop;
1550 BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hImageDC, 0, 0, dwRop);
1551
1552 bResult = TRUE;
1553 end:
1554 /* cleanup the mess */
1555 SetBkColor(hImageDC, oldImageBk);
1556 SetTextColor(hImageDC, oldImageFg);
1557 SelectObject(hImageDC, hOldImageBmp);
1558 cleanup:
1559 DeleteObject(hBlendMaskBmp);
1560 DeleteObject(hImageBmp);
1561 DeleteDC(hImageDC);
1562
1563 return bResult;
1564 }
1565
1566
1567 /*************************************************************************
1568 * ImageList_Duplicate [COMCTL32.@]
1569 *
1570 * Duplicates an image list.
1571 *
1572 * PARAMS
1573 * himlSrc [I] source image list handle
1574 *
1575 * RETURNS
1576 * Success: Handle of duplicated image list.
1577 * Failure: NULL
1578 */
1579
1580 HIMAGELIST WINAPI
1581 ImageList_Duplicate (HIMAGELIST himlSrc)
1582 {
1583 HIMAGELIST himlDst;
1584
1585 if (!is_valid(himlSrc)) {
1586 ERR("Invalid image list handle!\n");
1587 return NULL;
1588 }
1589
1590 himlDst = ImageList_Create (himlSrc->cx, himlSrc->cy, himlSrc->flags,
1591 himlSrc->cCurImage, himlSrc->cGrow);
1592
1593 if (himlDst)
1594 {
1595 SIZE sz;
1596
1597 imagelist_get_bitmap_size(himlSrc, himlSrc->cCurImage, &sz);
1598 BitBlt (himlDst->hdcImage, 0, 0, sz.cx, sz.cy,
1599 himlSrc->hdcImage, 0, 0, SRCCOPY);
1600
1601 if (himlDst->hbmMask)
1602 BitBlt (himlDst->hdcMask, 0, 0, sz.cx, sz.cy,
1603 himlSrc->hdcMask, 0, 0, SRCCOPY);
1604
1605 himlDst->cCurImage = himlSrc->cCurImage;
1606 if (himlSrc->has_alpha && himlDst->has_alpha)
1607 memcpy( himlDst->has_alpha, himlSrc->has_alpha, himlDst->cCurImage );
1608 }
1609 return himlDst;
1610 }
1611
1612
1613 /*************************************************************************
1614 * ImageList_EndDrag [COMCTL32.@]
1615 *
1616 * Finishes a drag operation.
1617 *
1618 * PARAMS
1619 * no Parameters
1620 *
1621 * RETURNS
1622 * Success: TRUE
1623 * Failure: FALSE
1624 */
1625
1626 VOID WINAPI
1627 ImageList_EndDrag (void)
1628 {
1629 /* cleanup the InternalDrag struct */
1630 InternalDrag.hwnd = 0;
1631 ImageList_Destroy (InternalDrag.himl);
1632 InternalDrag.himl = 0;
1633 InternalDrag.x= 0;
1634 InternalDrag.y= 0;
1635 InternalDrag.dxHotspot = 0;
1636 InternalDrag.dyHotspot = 0;
1637 InternalDrag.bShow = FALSE;
1638 DeleteObject(InternalDrag.hbmBg);
1639 InternalDrag.hbmBg = 0;
1640 }
1641
1642
1643 /*************************************************************************
1644 * ImageList_GetBkColor [COMCTL32.@]
1645 *
1646 * Returns the background color of an image list.
1647 *
1648 * PARAMS
1649 * himl [I] Image list handle.
1650 *
1651 * RETURNS
1652 * Success: background color
1653 * Failure: CLR_NONE
1654 */
1655
1656 COLORREF WINAPI
1657 ImageList_GetBkColor (HIMAGELIST himl)
1658 {
1659 return himl ? himl->clrBk : CLR_NONE;
1660 }
1661
1662
1663 /*************************************************************************
1664 * ImageList_GetDragImage [COMCTL32.@]
1665 *
1666 * Returns the handle to the internal drag image list.
1667 *
1668 * PARAMS
1669 * ppt [O] Pointer to the drag position. Can be NULL.
1670 * pptHotspot [O] Pointer to the position of the hot spot. Can be NULL.
1671 *
1672 * RETURNS
1673 * Success: Handle of the drag image list.
1674 * Failure: NULL.
1675 */
1676
1677 HIMAGELIST WINAPI
1678 ImageList_GetDragImage (POINT *ppt, POINT *pptHotspot)
1679 {
1680 if (is_valid(InternalDrag.himl)) {
1681 if (ppt) {
1682 ppt->x = InternalDrag.x;
1683 ppt->y = InternalDrag.y;
1684 }
1685 if (pptHotspot) {
1686 pptHotspot->x = InternalDrag.dxHotspot;
1687 pptHotspot->y = InternalDrag.dyHotspot;
1688 }
1689 return (InternalDrag.himl);
1690 }
1691
1692 return NULL;
1693 }
1694
1695
1696 /*************************************************************************
1697 * ImageList_GetFlags [COMCTL32.@]
1698 *
1699 * Gets the flags of the specified image list.
1700 *
1701 * PARAMS
1702 * himl [I] Handle to image list
1703 *
1704 * RETURNS
1705 * Image list flags.
1706 *
1707 * BUGS
1708 * Stub.
1709 */
1710
1711 DWORD WINAPI
1712 ImageList_GetFlags(HIMAGELIST himl)
1713 {
1714 TRACE("%p\n", himl);
1715
1716 return is_valid(himl) ? himl->flags : 0;
1717 }
1718
1719
1720 /*************************************************************************
1721 * ImageList_GetIcon [COMCTL32.@]
1722 *
1723 * Creates an icon from a masked image of an image list.
1724 *
1725 * PARAMS
1726 * himl [I] handle to image list
1727 * i [I] image index
1728 * flags [I] drawing style flags
1729 *
1730 * RETURNS
1731 * Success: icon handle
1732 * Failure: NULL
1733 */
1734
1735 HICON WINAPI
1736 ImageList_GetIcon (HIMAGELIST himl, INT i, UINT fStyle)
1737 {
1738 ICONINFO ii;
1739 HICON hIcon;
1740 HBITMAP hOldDstBitmap;
1741 HDC hdcDst;
1742 POINT pt;
1743
1744 TRACE("%p %d %d\n", himl, i, fStyle);
1745 if (!is_valid(himl) || (i < 0) || (i >= himl->cCurImage)) return NULL;
1746
1747 ii.fIcon = TRUE;
1748 ii.xHotspot = 0;
1749 ii.yHotspot = 0;
1750
1751 /* create colour bitmap */
1752 hdcDst = GetDC(0);
1753 ii.hbmColor = CreateCompatibleBitmap(hdcDst, himl->cx, himl->cy);
1754 ReleaseDC(0, hdcDst);
1755
1756 hdcDst = CreateCompatibleDC(0);
1757
1758 imagelist_point_from_index( himl, i, &pt );
1759
1760 /* draw mask*/
1761 ii.hbmMask = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
1762 hOldDstBitmap = SelectObject (hdcDst, ii.hbmMask);
1763 if (himl->hbmMask) {
1764 BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1765 himl->hdcMask, pt.x, pt.y, SRCCOPY);
1766 }
1767 else
1768 PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
1769
1770 /* draw image*/
1771 SelectObject (hdcDst, ii.hbmColor);
1772 BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1773 himl->hdcImage, pt.x, pt.y, SRCCOPY);
1774
1775 /*
1776 * CreateIconIndirect requires us to deselect the bitmaps from
1777 * the DCs before calling
1778 */
1779 SelectObject(hdcDst, hOldDstBitmap);
1780
1781 hIcon = CreateIconIndirect (&ii);
1782
1783 DeleteObject (ii.hbmMask);
1784 DeleteObject (ii.hbmColor);
1785 DeleteDC (hdcDst);
1786
1787 return hIcon;
1788 }
1789
1790
1791 /*************************************************************************
1792 * ImageList_GetIconSize [COMCTL32.@]
1793 *
1794 * Retrieves the size of an image in an image list.
1795 *
1796 * PARAMS
1797 * himl [I] handle to image list
1798 * cx [O] pointer to the image width.
1799 * cy [O] pointer to the image height.
1800 *
1801 * RETURNS
1802 * Success: TRUE
1803 * Failure: FALSE
1804 *
1805 * NOTES
1806 * All images in an image list have the same size.
1807 */
1808
1809 BOOL WINAPI
1810 ImageList_GetIconSize (HIMAGELIST himl, INT *cx, INT *cy)
1811 {
1812 if (!is_valid(himl) || !cx || !cy)
1813 return FALSE;
1814 if ((himl->cx <= 0) || (himl->cy <= 0))
1815 return FALSE;
1816
1817 *cx = himl->cx;
1818 *cy = himl->cy;
1819
1820 return TRUE;
1821 }
1822
1823
1824 /*************************************************************************
1825 * ImageList_GetImageCount [COMCTL32.@]
1826 *
1827 * Returns the number of images in an image list.
1828 *
1829 * PARAMS
1830 * himl [I] handle to image list
1831 *
1832 * RETURNS
1833 * Success: Number of images.
1834 * Failure: 0
1835 */
1836
1837 INT WINAPI
1838 ImageList_GetImageCount (HIMAGELIST himl)
1839 {
1840 if (!is_valid(himl))
1841 return 0;
1842
1843 return himl->cCurImage;
1844 }
1845
1846
1847 /*************************************************************************
1848 * ImageList_GetImageInfo [COMCTL32.@]
1849 *
1850 * Returns information about an image in an image list.
1851 *
1852 * PARAMS
1853 * himl [I] handle to image list
1854 * i [I] image index
1855 * pImageInfo [O] pointer to the image information
1856 *
1857 * RETURNS
1858 * Success: TRUE
1859 * Failure: FALSE
1860 */
1861
1862 BOOL WINAPI
1863 ImageList_GetImageInfo (HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
1864 {
1865 POINT pt;
1866
1867 if (!is_valid(himl) || (pImageInfo == NULL))
1868 return FALSE;
1869 if ((i < 0) || (i >= himl->cCurImage))
1870 return FALSE;
1871
1872 pImageInfo->hbmImage = himl->hbmImage;
1873 pImageInfo->hbmMask = himl->hbmMask;
1874
1875 imagelist_point_from_index( himl, i, &pt );
1876 pImageInfo->rcImage.top = pt.y;
1877 pImageInfo->rcImage.bottom = pt.y + himl->cy;
1878 pImageInfo->rcImage.left = pt.x;
1879 pImageInfo->rcImage.right = pt.x + himl->cx;
1880
1881 return TRUE;
1882 }
1883
1884
1885 /*************************************************************************
1886 * ImageList_GetImageRect [COMCTL32.@]
1887 *
1888 * Retrieves the rectangle of the specified image in an image list.
1889 *
1890 * PARAMS
1891 * himl [I] handle to image list
1892 * i [I] image index
1893 * lpRect [O] pointer to the image rectangle
1894 *
1895 * RETURNS
1896 * Success: TRUE
1897 * Failure: FALSE
1898 *
1899 * NOTES
1900 * This is an UNDOCUMENTED function!!!
1901 */
1902
1903 BOOL WINAPI
1904 ImageList_GetImageRect (HIMAGELIST himl, INT i, LPRECT lpRect)
1905 {
1906 POINT pt;
1907
1908 if (!is_valid(himl) || (lpRect == NULL))
1909 return FALSE;
1910 if ((i < 0) || (i >= himl->cCurImage))
1911 return FALSE;
1912
1913 imagelist_point_from_index( himl, i, &pt );
1914 lpRect->left = pt.x;
1915 lpRect->top = pt.y;
1916 lpRect->right = pt.x + himl->cx;
1917 lpRect->bottom = pt.y + himl->cy;
1918
1919 return TRUE;
1920 }
1921
1922
1923 /*************************************************************************
1924 * ImageList_LoadImage [COMCTL32.@]
1925 * ImageList_LoadImageA [COMCTL32.@]
1926 *
1927 * Creates an image list from a bitmap, icon or cursor.
1928 *
1929 * See ImageList_LoadImageW.
1930 */
1931
1932 HIMAGELIST WINAPI
1933 ImageList_LoadImageA (HINSTANCE hi, LPCSTR lpbmp, INT cx, INT cGrow,
1934 COLORREF clrMask, UINT uType, UINT uFlags)
1935 {
1936 HIMAGELIST himl;
1937 LPWSTR lpbmpW;
1938 DWORD len;
1939
1940 if (IS_INTRESOURCE(lpbmp))
1941 return ImageList_LoadImageW(hi, (LPCWSTR)lpbmp, cx, cGrow, clrMask,
1942 uType, uFlags);
1943
1944 len = MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, NULL, 0);
1945 lpbmpW = Alloc(len * sizeof(WCHAR));
1946 MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, lpbmpW, len);
1947
1948 himl = ImageList_LoadImageW(hi, lpbmpW, cx, cGrow, clrMask, uType, uFlags);
1949 Free (lpbmpW);
1950 return himl;
1951 }
1952
1953
1954 /*************************************************************************
1955 * ImageList_LoadImageW [COMCTL32.@]
1956 *
1957 * Creates an image list from a bitmap, icon or cursor.
1958 *
1959 * PARAMS
1960 * hi [I] instance handle
1961 * lpbmp [I] name or id of the image
1962 * cx [I] width of each image
1963 * cGrow [I] number of images to expand
1964 * clrMask [I] mask color
1965 * uType [I] type of image to load
1966 * uFlags [I] loading flags
1967 *
1968 * RETURNS
1969 * Success: handle to the loaded image list
1970 * Failure: NULL
1971 *
1972 * SEE
1973 * LoadImage ()
1974 */
1975
1976 HIMAGELIST WINAPI
1977 ImageList_LoadImageW (HINSTANCE hi, LPCWSTR lpbmp, INT cx, INT cGrow,
1978 COLORREF clrMask, UINT uType, UINT uFlags)
1979 {
1980 HIMAGELIST himl = NULL;
1981 HANDLE handle;
1982 INT nImageCount;
1983
1984 handle = LoadImageW (hi, lpbmp, uType, 0, 0, uFlags);
1985 if (!handle) {
1986 WARN("Couldn't load image\n");
1987 return NULL;
1988 }
1989
1990 if (uType == IMAGE_BITMAP) {
1991 DIBSECTION dib;
1992 UINT color;
1993
1994 if (GetObjectW (handle, sizeof(dib), &dib) == sizeof(BITMAP)) color = ILC_COLOR;
1995 else color = dib.dsBm.bmBitsPixel;
1996
1997 /* To match windows behavior, if cx is set to zero and
1998 the flag DI_DEFAULTSIZE is specified, cx becomes the
1999 system metric value for icons. If the flag is not specified
2000 the function sets the size to the height of the bitmap */
2001 if (cx == 0)
2002 {
2003 if (uFlags & DI_DEFAULTSIZE)
2004 cx = GetSystemMetrics (SM_CXICON);
2005 else
2006 cx = dib.dsBm.bmHeight;
2007 }
2008
2009 nImageCount = dib.dsBm.bmWidth / cx;
2010
2011 himl = ImageList_Create (cx, dib.dsBm.bmHeight, ILC_MASK | color, nImageCount, cGrow);
2012 if (!himl) {
2013 DeleteObject (handle);
2014 return NULL;
2015 }
2016 ImageList_AddMasked (himl, handle, clrMask);
2017 }
2018 else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
2019 ICONINFO ii;
2020 BITMAP bmp;
2021
2022 GetIconInfo (handle, &ii);
2023 GetObjectW (ii.hbmColor, sizeof(BITMAP), &bmp);
2024 himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
2025 ILC_MASK | ILC_COLOR, 1, cGrow);
2026 if (!himl) {
2027 DeleteObject (ii.hbmColor);
2028 DeleteObject (ii.hbmMask);
2029 DeleteObject (handle);
2030 return NULL;
2031 }
2032 ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
2033 DeleteObject (ii.hbmColor);
2034 DeleteObject (ii.hbmMask);
2035 }
2036
2037 DeleteObject (handle);
2038
2039 return himl;
2040 }
2041
2042
2043 /*************************************************************************
2044 * ImageList_Merge [COMCTL32.@]
2045 *
2046 * Create an image list containing a merged image from two image lists.
2047 *
2048 * PARAMS
2049 * himl1 [I] handle to first image list
2050 * i1 [I] first image index
2051 * himl2 [I] handle to second image list
2052 * i2 [I] second image index
2053 * dx [I] X offset of the second image relative to the first.
2054 * dy [I] Y offset of the second image relative to the first.
2055 *
2056 * RETURNS
2057 * Success: The newly created image list. It contains a single image
2058 * consisting of the second image merged with the first.
2059 * Failure: NULL, if either himl1 or himl2 are invalid.
2060 *
2061 * NOTES
2062 * - The returned image list should be deleted by the caller using
2063 * ImageList_Destroy() when it is no longer required.
2064 * - If either i1 or i2 are not valid image indices they will be treated
2065 * as a blank image.
2066 */
2067 HIMAGELIST WINAPI
2068 ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2,
2069 INT dx, INT dy)
2070 {
2071 HIMAGELIST himlDst = NULL;
2072 INT cxDst, cyDst;
2073 INT xOff1, yOff1, xOff2, yOff2;
2074 POINT pt1, pt2;
2075
2076 TRACE("(himl1=%p i1=%d himl2=%p i2=%d dx=%d dy=%d)\n", himl1, i1, himl2,
2077 i2, dx, dy);
2078
2079 if (!is_valid(himl1) || !is_valid(himl2))
2080 return NULL;
2081
2082 if (dx > 0) {
2083 cxDst = max (himl1->cx, dx + himl2->cx);
2084 xOff1 = 0;
2085 xOff2 = dx;
2086 }
2087 else if (dx < 0) {
2088 cxDst = max (himl2->cx, himl1->cx - dx);
2089 xOff1 = -dx;
2090 xOff2 = 0;
2091 }
2092 else {
2093 cxDst = max (himl1->cx, himl2->cx);
2094 xOff1 = 0;
2095 xOff2 = 0;
2096 }
2097
2098 if (dy > 0) {
2099 cyDst = max (himl1->cy, dy + himl2->cy);
2100 yOff1 = 0;
2101 yOff2 = dy;
2102 }
2103 else if (dy < 0) {
2104 cyDst = max (himl2->cy, himl1->cy - dy);
2105 yOff1 = -dy;
2106 yOff2 = 0;
2107 }
2108 else {
2109 cyDst = max (himl1->cy, himl2->cy);
2110 yOff1 = 0;
2111 yOff2 = 0;
2112 }
2113
2114 himlDst = ImageList_Create (cxDst, cyDst, ILC_MASK | ILC_COLOR, 1, 1);
2115
2116 if (himlDst)
2117 {
2118 imagelist_point_from_index( himl1, i1, &pt1 );
2119 imagelist_point_from_index( himl2, i2, &pt2 );
2120
2121 /* copy image */
2122 BitBlt (himlDst->hdcImage, 0, 0, cxDst, cyDst, himl1->hdcImage, 0, 0, BLACKNESS);
2123 if (i1 >= 0 && i1 < himl1->cCurImage)
2124 BitBlt (himlDst->hdcImage, xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcImage, pt1.x, pt1.y, SRCCOPY);
2125 if (i2 >= 0 && i2 < himl2->cCurImage)
2126 {
2127 BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask , pt2.x, pt2.y, SRCAND);
2128 BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcImage, pt2.x, pt2.y, SRCPAINT);
2129 }
2130
2131 /* copy mask */
2132 BitBlt (himlDst->hdcMask, 0, 0, cxDst, cyDst, himl1->hdcMask, 0, 0, WHITENESS);
2133 if (i1 >= 0 && i1 < himl1->cCurImage)
2134 BitBlt (himlDst->hdcMask, xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcMask, pt1.x, pt1.y, SRCCOPY);
2135 if (i2 >= 0 && i2 < himl2->cCurImage)
2136 BitBlt (himlDst->hdcMask, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask, pt2.x, pt2.y, SRCAND);
2137
2138 himlDst->cCurImage = 1;
2139 }
2140
2141 return himlDst;
2142 }
2143
2144
2145 /* helper for ImageList_Read, see comments below */
2146 static void *read_bitmap(LPSTREAM pstm, BITMAPINFO *bmi)
2147 {
2148 BITMAPFILEHEADER bmfh;
2149 int bitsperpixel, palspace;
2150 void *bits;
2151
2152 if (FAILED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL)))
2153 return NULL;
2154
2155 if (bmfh.bfType != (('M'<<8)|'B'))
2156 return NULL;
2157
2158 if (FAILED(IStream_Read ( pstm, &bmi->bmiHeader, sizeof(bmi->bmiHeader), NULL)))
2159 return NULL;
2160
2161 if ((bmi->bmiHeader.biSize != sizeof(bmi->bmiHeader)))
2162 return NULL;
2163
2164 TRACE("width %u, height %u, planes %u, bpp %u\n",
2165 bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight,
2166 bmi->bmiHeader.biPlanes, bmi->bmiHeader.biBitCount);
2167
2168 bitsperpixel = bmi->bmiHeader.biPlanes * bmi->bmiHeader.biBitCount;
2169 if (bitsperpixel<=8)
2170 palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
2171 else
2172 palspace = 0;
2173
2174 bmi->bmiHeader.biSizeImage = get_dib_image_size( bmi );
2175
2176 /* read the palette right after the end of the bitmapinfoheader */
2177 if (palspace && FAILED(IStream_Read(pstm, bmi->bmiColors, palspace, NULL)))
2178 return NULL;
2179
2180 bits = Alloc(bmi->bmiHeader.biSizeImage);
2181 if (!bits) return NULL;
2182
2183 if (FAILED(IStream_Read(pstm, bits, bmi->bmiHeader.biSizeImage, NULL)))
2184 {
2185 Free(bits);
2186 return NULL;
2187 }
2188 return bits;
2189 }
2190
2191 /*************************************************************************
2192 * ImageList_Read [COMCTL32.@]
2193 *
2194 * Reads an image list from a stream.
2195 *
2196 * PARAMS
2197 * pstm [I] pointer to a stream
2198 *
2199 * RETURNS
2200 * Success: handle to image list
2201 * Failure: NULL
2202 *
2203 * The format is like this:
2204 * ILHEAD ilheadstruct;
2205 *
2206 * for the color image part:
2207 * BITMAPFILEHEADER bmfh;
2208 * BITMAPINFOHEADER bmih;
2209 * only if it has a palette:
2210 * RGBQUAD rgbs[nr_of_paletted_colors];
2211 *
2212 * BYTE colorbits[imagesize];
2213 *
2214 * the following only if the ILC_MASK bit is set in ILHEAD.ilFlags:
2215 * BITMAPFILEHEADER bmfh_mask;
2216 * BITMAPINFOHEADER bmih_mask;
2217 * only if it has a palette (it usually does not):
2218 * RGBQUAD rgbs[nr_of_paletted_colors];
2219 *
2220 * BYTE maskbits[imagesize];
2221 */
2222 HIMAGELIST WINAPI ImageList_Read (LPSTREAM pstm)
2223 {
2224 char image_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
2225 char mask_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
2226 BITMAPINFO *image_info = (BITMAPINFO *)image_buf;
2227 BITMAPINFO *mask_info = (BITMAPINFO *)mask_buf;
2228 void *image_bits, *mask_bits = NULL;
2229 ILHEAD ilHead;
2230 HIMAGELIST himl;
2231 int i;
2232
2233 TRACE("%p\n", pstm);
2234
2235 if (FAILED(IStream_Read (pstm, &ilHead, sizeof(ILHEAD), NULL)))
2236 return NULL;
2237 if (ilHead.usMagic != (('L' << 8) | 'I'))
2238 return NULL;
2239 if (ilHead.usVersion != 0x101) /* probably version? */
2240 return NULL;
2241
2242 TRACE("cx %u, cy %u, flags 0x%04x, cCurImage %u, cMaxImage %u\n",
2243 ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
2244
2245 himl = ImageList_Create(ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
2246 if (!himl)
2247 return NULL;
2248
2249 if (!(image_bits = read_bitmap(pstm, image_info)))
2250 {
2251 WARN("failed to read bitmap from stream\n");
2252 return NULL;
2253 }
2254 if (ilHead.flags & ILC_MASK)
2255 {
2256 if (!(mask_bits = read_bitmap(pstm, mask_info)))
2257 {
2258 WARN("failed to read mask bitmap from stream\n");
2259 return NULL;
2260 }
2261 }
2262 else mask_info = NULL;
2263
2264 if (himl->has_alpha && image_info->bmiHeader.biBitCount == 32)
2265 {
2266 DWORD *ptr = image_bits;
2267 BYTE *mask_ptr = mask_bits;
2268 int stride = himl->cy * image_info->bmiHeader.biWidth;
2269
2270 if (image_info->bmiHeader.biHeight > 0) /* bottom-up */
2271 {
2272 ptr += image_info->bmiHeader.biHeight * image_info->bmiHeader.biWidth - stride;
2273 mask_ptr += (image_info->bmiHeader.biHeight * image_info->bmiHeader.biWidth - stride) / 8;
2274 stride = -stride;
2275 image_info->bmiHeader.biHeight = himl->cy;
2276 }
2277 else image_info->bmiHeader.biHeight = -himl->cy;
2278
2279 for (i = 0; i < ilHead.cCurImage; i += TILE_COUNT)
2280 {
2281 add_dib_bits( himl, i, min( ilHead.cCurImage - i, TILE_COUNT ),
2282 himl->cx, himl->cy, image_info, mask_info, ptr, mask_ptr );
2283 ptr += stride;
2284 mask_ptr += stride / 8;
2285 }
2286 }
2287 else
2288 {
2289 StretchDIBits( himl->hdcImage, 0, 0, image_info->bmiHeader.biWidth, image_info->bmiHeader.biHeight,
2290 0, 0, image_info->bmiHeader.biWidth, image_info->bmiHeader.biHeight,
2291 image_bits, image_info, DIB_RGB_COLORS, SRCCOPY);
2292 if (mask_info)
2293 StretchDIBits( himl->hdcMask, 0, 0, mask_info->bmiHeader.biWidth, mask_info->bmiHeader.biHeight,
2294 0, 0, mask_info->bmiHeader.biWidth, mask_info->bmiHeader.biHeight,
2295 mask_bits, mask_info, DIB_RGB_COLORS, SRCCOPY);
2296 }
2297 Free( image_bits );
2298 Free( mask_bits );
2299
2300 himl->cCurImage = ilHead.cCurImage;
2301 himl->cMaxImage = ilHead.cMaxImage;
2302
2303 ImageList_SetBkColor(himl,ilHead.bkcolor);
2304 for (i=0;i<4;i++)
2305 ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
2306 return himl;
2307 }
2308
2309
2310 /*************************************************************************
2311 * ImageList_Remove [COMCTL32.@]
2312 *
2313 * Removes an image from an image list
2314 *
2315 * PARAMS
2316 * himl [I] image list handle
2317 * i [I] image index
2318 *
2319 * RETURNS
2320 * Success: TRUE
2321 * Failure: FALSE
2322 *
2323 * FIXME: as the image list storage test shows, native comctl32 simply shifts
2324 * images without creating a new bitmap.
2325 */
2326 BOOL WINAPI
2327 ImageList_Remove (HIMAGELIST himl, INT i)
2328 {
2329 HBITMAP hbmNewImage, hbmNewMask;
2330 HDC hdcBmp;
2331 SIZE sz;
2332
2333 TRACE("(himl=%p i=%d)\n", himl, i);
2334
2335 if (!is_valid(himl)) {
2336 ERR("Invalid image list handle!\n");
2337 return FALSE;
2338 }
2339
2340 if ((i < -1) || (i >= himl->cCurImage)) {
2341 TRACE("index out of range! %d\n", i);
2342 return FALSE;
2343 }
2344
2345 if (i == -1) {
2346 INT nCount;
2347
2348 /* remove all */
2349 if (himl->cCurImage == 0) {
2350 /* remove all on empty ImageList is allowed */
2351 TRACE("remove all on empty ImageList!\n");
2352 return TRUE;
2353 }
2354
2355 himl->cMaxImage = himl->cInitial + himl->cGrow - 1;
2356 himl->cCurImage = 0;
2357 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
2358 himl->nOvlIdx[nCount] = -1;
2359
2360 hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
2361 SelectObject (himl->hdcImage, hbmNewImage);
2362 DeleteObject (himl->hbmImage);
2363 himl->hbmImage = hbmNewImage;
2364
2365 if (himl->hbmMask) {
2366
2367 imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
2368 hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2369 SelectObject (himl->hdcMask, hbmNewMask);
2370 DeleteObject (himl->hbmMask);
2371 himl->hbmMask = hbmNewMask;
2372 }
2373 }
2374 else {
2375 /* delete one image */
2376 TRACE("Remove single image! %d\n", i);
2377
2378 /* create new bitmap(s) */
2379 TRACE(" - Number of images: %d / %d (Old/New)\n",
2380 himl->cCurImage, himl->cCurImage - 1);
2381
2382 hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
2383
2384 imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz );
2385 if (himl->hbmMask)
2386 hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2387 else
2388 hbmNewMask = 0; /* Just to keep compiler happy! */
2389
2390 hdcBmp = CreateCompatibleDC (0);
2391
2392 /* copy all images and masks prior to the "removed" image */
2393 if (i > 0) {
2394 TRACE("Pre image copy: Copy %d images\n", i);
2395
2396 SelectObject (hdcBmp, hbmNewImage);
2397 imagelist_copy_images( himl, himl->hdcImage, hdcBmp, 0, i, 0 );
2398
2399 if (himl->hbmMask) {
2400 SelectObject (hdcBmp, hbmNewMask);
2401 imagelist_copy_images( himl, himl->hdcMask, hdcBmp, 0, i, 0 );
2402 }
2403 }
2404
2405 /* copy all images and masks behind the removed image */
2406 if (i < himl->cCurImage - 1) {
2407 TRACE("Post image copy!\n");
2408
2409 SelectObject (hdcBmp, hbmNewImage);
2410 imagelist_copy_images( himl, himl->hdcImage, hdcBmp, i + 1,
2411 (himl->cCurImage - i), i );
2412
2413 if (himl->hbmMask) {
2414 SelectObject (hdcBmp, hbmNewMask);
2415 imagelist_copy_images( himl, himl->hdcMask, hdcBmp, i + 1,
2416 (himl->cCurImage - i), i );
2417 }
2418 }
2419
2420 DeleteDC (hdcBmp);
2421
2422 /* delete old images and insert new ones */
2423 SelectObject (himl->hdcImage, hbmNewImage);
2424 DeleteObject (himl->hbmImage);
2425 himl->hbmImage = hbmNewImage;
2426 if (himl->hbmMask) {
2427 SelectObject (himl->hdcMask, hbmNewMask);
2428 DeleteObject (himl->hbmMask);
2429 himl->hbmMask = hbmNewMask;
2430 }
2431
2432 himl->cCurImage--;
2433 }
2434
2435 return TRUE;
2436 }
2437
2438
2439 /*************************************************************************
2440 * ImageList_Replace [COMCTL32.@]
2441 *
2442 * Replaces an image in an image list with a new image.
2443 *
2444 * PARAMS
2445 * himl [I] handle to image list
2446 * i [I] image index
2447 * hbmImage [I] handle to image bitmap
2448 * hbmMask [I] handle to mask bitmap. Can be NULL.
2449 *
2450 * RETURNS
2451 * Success: TRUE
2452 * Failure: FALSE
2453 */
2454
2455 BOOL WINAPI
2456 ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage,
2457 HBITMAP hbmMask)
2458 {
2459 HDC hdcImage;
2460 BITMAP bmp;
2461 POINT pt;
2462
2463 TRACE("%p %d %p %p\n", himl, i, hbmImage, hbmMask);
2464
2465 if (!is_valid(himl)) {
2466 ERR("Invalid image list handle!\n");
2467 return FALSE;
2468 }
2469
2470 if ((i >= himl->cMaxImage) || (i < 0)) {
2471 ERR("Invalid image index!\n");
2472 return FALSE;
2473 }
2474
2475 if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
2476 return FALSE;
2477
2478 hdcImage = CreateCompatibleDC (0);
2479
2480 /* Replace Image */
2481 SelectObject (hdcImage, hbmImage);
2482
2483 if (add_with_alpha( himl, hdcImage, i, 1, bmp.bmWidth, bmp.bmHeight, hbmImage, hbmMask ))
2484 goto done;
2485
2486 imagelist_point_from_index(himl, i, &pt);
2487 StretchBlt (himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
2488 hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2489
2490 if (himl->hbmMask)
2491 {
2492 HDC hdcTemp;
2493 HBITMAP hOldBitmapTemp;
2494
2495 hdcTemp = CreateCompatibleDC(0);
2496 hOldBitmapTemp = SelectObject(hdcTemp, hbmMask);
2497
2498 StretchBlt (himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
2499 hdcTemp, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2500 SelectObject(hdcTemp, hOldBitmapTemp);
2501 DeleteDC(hdcTemp);
2502
2503 /* Remove the background from the image
2504 */
2505 BitBlt (himl->hdcImage, pt.x, pt.y, bmp.bmWidth, bmp.bmHeight,
2506 himl->hdcMask, pt.x, pt.y, 0x220326); /* NOTSRCAND */
2507 }
2508
2509 done:
2510 DeleteDC (hdcImage);
2511
2512 return TRUE;
2513 }
2514
2515
2516 /*************************************************************************
2517 * ImageList_ReplaceIcon [COMCTL32.@]
2518 *
2519 * Replaces an image in an image list using an icon.
2520 *
2521 * PARAMS
2522 * himl [I] handle to image list
2523 * i [I] image index
2524 * hIcon [I] handle to icon
2525 *
2526 * RETURNS
2527 * Success: index of the replaced image
2528 * Failure: -1
2529 */
2530
2531 INT WINAPI
2532 ImageList_ReplaceIcon (HIMAGELIST himl, INT nIndex, HICON hIcon)
2533 {
2534 HICON hBestFitIcon;
2535 ICONINFO ii;
2536 BITMAP bmp;
2537 BOOL ret;
2538 POINT pt;
2539
2540 TRACE("(%p %d %p)\n", himl, nIndex, hIcon);
2541
2542 if (!is_valid(himl)) {
2543 ERR("invalid image list\n");
2544 return -1;
2545 }
2546 if ((nIndex >= himl->cMaxImage) || (nIndex < -1)) {
2547 ERR("invalid image index %d / %d\n", nIndex, himl->cMaxImage);
2548 return -1;
2549 }
2550
2551 hBestFitIcon = CopyImage(
2552 hIcon, IMAGE_ICON,
2553 himl->cx, himl->cy,
2554 LR_COPYFROMRESOURCE);
2555 /* the above will fail if the icon wasn't loaded from a resource, so try
2556 * again without LR_COPYFROMRESOURCE flag */
2557 if (!hBestFitIcon)
2558 hBestFitIcon = CopyImage(
2559 hIcon, IMAGE_ICON,
2560 himl->cx, himl->cy,
2561 0);
2562 if (!hBestFitIcon)
2563 return -1;
2564
2565 if (nIndex == -1) {
2566 if (himl->cCurImage + 1 > himl->cMaxImage)
2567 IMAGELIST_InternalExpandBitmaps(himl, 1);
2568
2569 nIndex = himl->cCurImage;
2570 himl->cCurImage++;
2571 }
2572
2573 if (himl->has_alpha && GetIconInfo (hBestFitIcon, &ii))
2574 {
2575 HDC hdcImage = CreateCompatibleDC( 0 );
2576 GetObjectW (ii.hbmMask, sizeof(BITMAP), &bmp);
2577
2578 if (!ii.hbmColor)
2579 {
2580 UINT height = bmp.bmHeight / 2;
2581 HDC hdcMask = CreateCompatibleDC( 0 );
2582 HBITMAP color = CreateBitmap( bmp.bmWidth, height, 1, 1, NULL );
2583 SelectObject( hdcImage, color );
2584 SelectObject( hdcMask, ii.hbmMask );
2585 BitBlt( hdcImage, 0, 0, bmp.bmWidth, height, hdcMask, 0, height, SRCCOPY );
2586 ret = add_with_alpha( himl, hdcImage, nIndex, 1, bmp.bmWidth, height, color, ii.hbmMask );
2587 DeleteDC( hdcMask );
2588 DeleteObject( color );
2589 }
2590 else ret = add_with_alpha( himl, hdcImage, nIndex, 1, bmp.bmWidth, bmp.bmHeight,
2591 ii.hbmColor, ii.hbmMask );
2592
2593 DeleteDC( hdcImage );
2594 DeleteObject (ii.hbmMask);
2595 if (ii.hbmColor) DeleteObject (ii.hbmColor);
2596 if (ret) goto done;
2597 }
2598
2599 imagelist_point_from_index(himl, nIndex, &pt);
2600
2601 if (himl->hbmMask)
2602 {
2603 DrawIconEx( himl->hdcImage, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_IMAGE );
2604 PatBlt( himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy, WHITENESS );
2605 DrawIconEx( himl->hdcMask, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_MASK );
2606 }
2607 else
2608 {
2609 COLORREF color = himl->clrBk != CLR_NONE ? himl->clrBk : comctl32_color.clrWindow;
2610 HBRUSH brush = CreateSolidBrush( GetNearestColor( himl->hdcImage, color ));
2611
2612 SelectObject( himl->hdcImage, brush );
2613 PatBlt( himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy, PATCOPY );
2614 SelectObject( himl->hdcImage, GetStockObject(BLACK_BRUSH) );
2615 DeleteObject( brush );
2616 DrawIconEx( himl->hdcImage, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_NORMAL );
2617 }
2618
2619 done:
2620 DestroyIcon(hBestFitIcon);
2621
2622 TRACE("Insert index = %d, himl->cCurImage = %d\n", nIndex, himl->cCurImage);
2623 return nIndex;
2624 }
2625
2626
2627 /*************************************************************************
2628 * ImageList_SetBkColor [COMCTL32.@]
2629 *
2630 * Sets the background color of an image list.
2631 *
2632 * PARAMS
2633 * himl [I] handle to image list
2634 * clrBk [I] background color
2635 *
2636 * RETURNS
2637 * Success: previous background color
2638 * Failure: CLR_NONE
2639 */
2640
2641 COLORREF WINAPI
2642 ImageList_SetBkColor (HIMAGELIST himl, COLORREF clrBk)
2643 {
2644 COLORREF clrOldBk;
2645
2646 if (!is_valid(himl))
2647 return CLR_NONE;
2648
2649 clrOldBk = himl->clrBk;
2650 himl->clrBk = clrBk;
2651 return clrOldBk;
2652 }
2653
2654
2655 /*************************************************************************
2656 * ImageList_SetDragCursorImage [COMCTL32.@]
2657 *
2658 * Combines the specified image with the current drag image
2659 *
2660 * PARAMS
2661 * himlDrag [I] handle to drag image list
2662 * iDrag [I] drag image index
2663 * dxHotspot [I] X position of the hot spot
2664 * dyHotspot [I] Y position of the hot spot
2665 *
2666 * RETURNS
2667 * Success: TRUE
2668 * Failure: FALSE
2669 *
2670 * NOTES
2671 * - The names dxHotspot, dyHotspot are misleading because they have nothing
2672 * to do with a hotspot but are only the offset of the origin of the new
2673 * image relative to the origin of the old image.
2674 *
2675 * - When this function is called and the drag image is visible, a
2676 * short flickering occurs but this matches the Win9x behavior. It is
2677 * possible to fix the flickering using code like in ImageList_DragMove.
2678 */
2679
2680 BOOL WINAPI
2681 ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag,
2682 INT dxHotspot, INT dyHotspot)
2683 {
2684 HIMAGELIST himlTemp;
2685 BOOL visible;
2686
2687 if (!is_valid(InternalDrag.himl) || !is_valid(himlDrag))
2688 return FALSE;
2689
2690 TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
2691 dxHotspot, dyHotspot, InternalDrag.dxHotspot, InternalDrag.dyHotspot);
2692
2693 visible = InternalDrag.bShow;
2694
2695 himlTemp = ImageList_Merge (InternalDrag.himl, 0, himlDrag, iDrag,
2696 dxHotspot, dyHotspot);
2697
2698 if (visible) {
2699 /* hide the drag image */
2700 ImageList_DragShowNolock(FALSE);
2701 }
2702 if ((InternalDrag.himl->cx != himlTemp->cx) ||
2703 (InternalDrag.himl->cy != himlTemp->cy)) {
2704 /* the size of the drag image changed, invalidate the buffer */
2705 DeleteObject(InternalDrag.hbmBg);
2706 InternalDrag.hbmBg = 0;
2707 }
2708
2709 ImageList_Destroy (InternalDrag.himl);
2710 InternalDrag.himl = himlTemp;
2711
2712 if (visible) {
2713 /* show the drag image */
2714 ImageList_DragShowNolock(TRUE);
2715 }
2716
2717 return TRUE;
2718 }
2719
2720
2721 /*************************************************************************
2722 * ImageList_SetFilter [COMCTL32.@]
2723 *
2724 * Sets a filter (or does something completely different)!!???
2725 * It removes 12 Bytes from the stack (3 Parameters).
2726 *
2727 * PARAMS
2728 * himl [I] SHOULD be a handle to image list
2729 * i [I] COULD be an index?
2730 * dwFilter [I] ???
2731 *
2732 * RETURNS
2733 * Success: TRUE ???
2734 * Failure: FALSE ???
2735 *
2736 * BUGS
2737 * This is an UNDOCUMENTED function!!!!
2738 * empty stub.
2739 */
2740
2741 BOOL WINAPI
2742 ImageList_SetFilter (HIMAGELIST himl, INT i, DWORD dwFilter)
2743 {
2744 FIXME("(%p 0x%x 0x%x):empty stub!\n", himl, i, dwFilter);
2745
2746 return FALSE;
2747 }
2748
2749
2750 /*************************************************************************
2751 * ImageList_SetFlags [COMCTL32.@]
2752 *
2753 * Sets the image list flags.
2754 *
2755 * PARAMS
2756 * himl [I] Handle to image list
2757 * flags [I] Flags to set
2758 *
2759 * RETURNS
2760 * Old flags?
2761 *
2762 * BUGS
2763 * Stub.
2764 */
2765
2766 DWORD WINAPI
2767 ImageList_SetFlags(HIMAGELIST himl, DWORD flags)
2768 {
2769 FIXME("(%p %08x):empty stub\n", himl, flags);
2770 return 0;
2771 }
2772
2773
2774 /*************************************************************************
2775 * ImageList_SetIconSize [COMCTL32.@]
2776 *
2777 * Sets the image size of the bitmap and deletes all images.
2778 *
2779 * PARAMS
2780 * himl [I] handle to image list
2781 * cx [I] image width
2782 * cy [I] image height
2783 *
2784 * RETURNS
2785 * Success: TRUE
2786 * Failure: FALSE
2787 */
2788
2789 BOOL WINAPI
2790 ImageList_SetIconSize (HIMAGELIST himl, INT cx, INT cy)
2791 {
2792 INT nCount;
2793 HBITMAP hbmNew;
2794
2795 if (!is_valid(himl))
2796 return FALSE;
2797
2798 /* remove all images */
2799 himl->cMaxImage = himl->cInitial + 1;
2800 himl->cCurImage = 0;
2801 himl->cx = cx;
2802 himl->cy = cy;
2803
2804 /* initialize overlay mask indices */
2805 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
2806 himl->nOvlIdx[nCount] = -1;
2807
2808 hbmNew = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
2809 SelectObject (himl->hdcImage, hbmNew);
2810 DeleteObject (himl->hbmImage);
2811 himl->hbmImage = hbmNew;
2812
2813 if (himl->hbmMask) {
2814 SIZE sz;
2815 imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
2816 hbmNew = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2817 SelectObject (himl->hdcMask, hbmNew);
2818 DeleteObject (himl->hbmMask);
2819 himl->hbmMask = hbmNew;
2820 }
2821
2822 return TRUE;
2823 }
2824
2825
2826 /*************************************************************************
2827 * ImageList_SetImageCount [COMCTL32.@]
2828 *
2829 * Resizes an image list to the specified number of images.
2830 *
2831 * PARAMS
2832 * himl [I] handle to image list
2833 * iImageCount [I] number of images in the image list
2834 *
2835 * RETURNS
2836 * Success: TRUE
2837 * Failure: FALSE
2838 */
2839
2840 BOOL WINAPI
2841 ImageList_SetImageCount (HIMAGELIST himl, UINT iImageCount)
2842 {
2843 HDC hdcBitmap;
2844 HBITMAP hbmNewBitmap, hbmOld;
2845 INT nNewCount, nCopyCount;
2846
2847 TRACE("%p %d\n",himl,iImageCount);
2848
2849 if (!is_valid(himl))
2850 return FALSE;
2851 if (himl->cMaxImage > iImageCount)
2852 {
2853 himl->cCurImage = iImageCount;
2854 /* TODO: shrink the bitmap when cMaxImage-cCurImage>cGrow ? */
2855 return TRUE;
2856 }
2857
2858 nNewCount = iImageCount + himl->cGrow;
2859 nCopyCount = min(himl->cCurImage, iImageCount);
2860
2861 hdcBitmap = CreateCompatibleDC (0);
2862
2863 hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount);
2864
2865 if (hbmNewBitmap != 0)
2866 {
2867 hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
2868 imagelist_copy_images( himl, himl->hdcImage, hdcBitmap, 0, nCopyCount, 0 );
2869 SelectObject (hdcBitmap, hbmOld);
2870
2871 /* FIXME: delete 'empty' image space? */
2872
2873 SelectObject (himl->hdcImage, hbmNewBitmap);
2874 DeleteObject (himl->hbmImage);
2875 himl->hbmImage = hbmNewBitmap;
2876 }
2877 else
2878 ERR("Could not create new image bitmap !\n");
2879
2880 if (himl->hbmMask)
2881 {
2882 SIZE sz;
2883 imagelist_get_bitmap_size( himl, nNewCount, &sz );
2884 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2885 if (hbmNewBitmap != 0)
2886 {
2887 hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
2888 imagelist_copy_images( himl, himl->hdcMask, hdcBitmap, 0, nCopyCount, 0 );
2889 SelectObject (hdcBitmap, hbmOld);
2890
2891 /* FIXME: delete 'empty' image space? */
2892
2893 SelectObject (himl->hdcMask, hbmNewBitmap);
2894 DeleteObject (himl->hbmMask);
2895 himl->hbmMask = hbmNewBitmap;
2896 }
2897 else
2898 ERR("Could not create new mask bitmap!\n");
2899 }
2900
2901 DeleteDC (hdcBitmap);
2902
2903 if (himl->has_alpha)
2904 {
2905 char *new_alpha = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, himl->has_alpha, nNewCount );
2906 if (new_alpha) himl->has_alpha = new_alpha;
2907 else
2908 {
2909 HeapFree( GetProcessHeap(), 0, himl->has_alpha );
2910 himl->has_alpha = NULL;
2911 }
2912 }
2913
2914 /* Update max image count and current image count */
2915 himl->cMaxImage = nNewCount;
2916 himl->cCurImage = iImageCount;
2917
2918 return TRUE;
2919 }
2920
2921
2922 /*************************************************************************
2923 * ImageList_SetOverlayImage [COMCTL32.@]
2924 *
2925 * Assigns an overlay mask index to an existing image in an image list.
2926 *
2927 * PARAMS
2928 * himl [I] handle to image list
2929 * iImage [I] image index
2930 * iOverlay [I] overlay mask index
2931 *
2932 * RETURNS
2933 * Success: TRUE
2934 * Failure: FALSE
2935 */
2936
2937 BOOL WINAPI
2938 ImageList_SetOverlayImage (HIMAGELIST himl, INT iImage, INT iOverlay)
2939 {
2940 if (!is_valid(himl))
2941 return FALSE;
2942 if ((iOverlay < 1) || (iOverlay > MAX_OVERLAYIMAGE))
2943 return FALSE;
2944 if ((iImage!=-1) && ((iImage < 0) || (iImage > himl->cCurImage)))
2945 return FALSE;
2946 himl->nOvlIdx[iOverlay - 1] = iImage;
2947 return TRUE;
2948 }
2949
2950
2951
2952 /* helper for ImageList_Write - write bitmap to pstm
2953 * currently everything is written as 24 bit RGB, except masks
2954 */
2955 static BOOL
2956 _write_bitmap(HBITMAP hBitmap, LPSTREAM pstm)
2957 {
2958 LPBITMAPFILEHEADER bmfh;
2959 LPBITMAPINFOHEADER bmih;
2960 LPBYTE data = NULL, lpBits;
2961 BITMAP bm;
2962 INT bitCount, sizeImage, offBits, totalSize;
2963 HDC xdc;
2964 BOOL result = FALSE;
2965
2966 if (!GetObjectW(hBitmap, sizeof(BITMAP), &bm))
2967 return FALSE;
2968
2969 bitCount = bm.bmBitsPixel;
2970 sizeImage = get_dib_stride(bm.bmWidth, bitCount) * bm.bmHeight;
2971
2972 totalSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
2973 if(bitCount <= 8)
2974 totalSize += (1 << bitCount) * sizeof(RGBQUAD);
2975 offBits = totalSize;
2976 totalSize += sizeImage;
2977
2978 data = Alloc(totalSize);
2979 bmfh = (LPBITMAPFILEHEADER)data;
2980 bmih = (LPBITMAPINFOHEADER)(data + sizeof(BITMAPFILEHEADER));
2981 lpBits = data + offBits;
2982
2983 /* setup BITMAPFILEHEADER */
2984 bmfh->bfType = (('M' << 8) | 'B');
2985 bmfh->bfSize = offBits;
2986 bmfh->bfReserved1 = 0;
2987 bmfh->bfReserved2 = 0;
2988 bmfh->bfOffBits = offBits;
2989
2990 /* setup BITMAPINFOHEADER */
2991 bmih->biSize = sizeof(BITMAPINFOHEADER);
2992 bmih->biWidth = bm.bmWidth;
2993 bmih->biHeight = bm.bmHeight;
2994 bmih->biPlanes = 1;
2995 bmih->biBitCount = bitCount;
2996 bmih->biCompression = BI_RGB;
2997 bmih->biSizeImage = sizeImage;
2998 bmih->biXPelsPerMeter = 0;
2999 bmih->biYPelsPerMeter = 0;
3000 bmih->biClrUsed = 0;
3001 bmih->biClrImportant = 0;
3002
3003 xdc = GetDC(0);
3004 result = GetDIBits(xdc, hBitmap, 0, bm.bmHeight, lpBits, (BITMAPINFO *)bmih, DIB_RGB_COLORS) == bm.bmHeight;
3005 ReleaseDC(0, xdc);
3006 if (!result)
3007 goto failed;
3008
3009 TRACE("width %u, height %u, planes %u, bpp %u\n",
3010 bmih->biWidth, bmih->biHeight,
3011 bmih->biPlanes, bmih->biBitCount);
3012
3013 if(FAILED(IStream_Write(pstm, data, totalSize, NULL)))
3014 goto failed;
3015
3016 result = TRUE;
3017
3018 failed:
3019 Free(data);
3020
3021 return result;
3022 }
3023
3024
3025 /*************************************************************************
3026 * ImageList_Write [COMCTL32.@]
3027 *
3028 * Writes an image list to a stream.
3029 *
3030 * PARAMS
3031 * himl [I] handle to image list
3032 * pstm [O] Pointer to a stream.
3033 *
3034 * RETURNS
3035 * Success: TRUE
3036 * Failure: FALSE
3037 *
3038 * BUGS
3039 * probably.
3040 */
3041
3042 BOOL WINAPI
3043 ImageList_Write (HIMAGELIST himl, LPSTREAM pstm)
3044 {
3045 ILHEAD ilHead;
3046 int i;
3047
3048 TRACE("%p %p\n", himl, pstm);
3049
3050 if (!is_valid(himl))
3051 return FALSE;
3052
3053 ilHead.usMagic = (('L' << 8) | 'I');
3054 ilHead.usVersion = 0x101;
3055 ilHead.cCurImage = himl->cCurImage;
3056 ilHead.cMaxImage = himl->cMaxImage;
3057 ilHead.cGrow = himl->cGrow;
3058 ilHead.cx = himl->cx;
3059 ilHead.cy = himl->cy;
3060 ilHead.bkcolor = himl->clrBk;
3061 ilHead.flags = himl->flags;
3062 for(i = 0; i < 4; i++) {
3063 ilHead.ovls[i] = himl->nOvlIdx[i];
3064 }
3065
3066 TRACE("cx %u, cy %u, flags 0x04%x, cCurImage %u, cMaxImage %u\n",
3067 ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
3068
3069 if(FAILED(IStream_Write(pstm, &ilHead, sizeof(ILHEAD), NULL)))
3070 return FALSE;
3071
3072 /* write the bitmap */
3073 if(!_write_bitmap(himl->hbmImage, pstm))
3074 return FALSE;
3075
3076 /* write the mask if we have one */
3077 if(himl->flags & ILC_MASK) {
3078 if(!_write_bitmap(himl->hbmMask, pstm))
3079 return FALSE;
3080 }
3081
3082 return TRUE;
3083 }
3084
3085
3086 static HBITMAP ImageList_CreateImage(HDC hdc, HIMAGELIST himl, UINT count)
3087 {
3088 HBITMAP hbmNewBitmap;
3089 UINT ilc = (himl->flags & 0xFE);
3090 SIZE sz;
3091
3092 imagelist_get_bitmap_size( himl, count, &sz );
3093
3094 if ((ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32) || ilc == ILC_COLOR)
3095 {
3096 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
3097 BITMAPINFO *bmi = (BITMAPINFO *)buffer;
3098
3099 TRACE("Creating DIBSection %d x %d, %d Bits per Pixel\n",
3100 sz.cx, sz.cy, himl->uBitsPixel);
3101
3102 memset( buffer, 0, sizeof(buffer) );
3103 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
3104 bmi->bmiHeader.biWidth = sz.cx;
3105 bmi->bmiHeader.biHeight = sz.cy;
3106 bmi->bmiHeader.biPlanes = 1;
3107 bmi->bmiHeader.biBitCount = himl->uBitsPixel;
3108 bmi->bmiHeader.biCompression = BI_RGB;
3109
3110 if (himl->uBitsPixel <= ILC_COLOR8)
3111 {
3112 /* retrieve the default color map */
3113 HBITMAP tmp = CreateBitmap( 1, 1, 1, 1, NULL );
3114 GetDIBits( hdc, tmp, 0, 0, NULL, bmi, DIB_RGB_COLORS );
3115 DeleteObject( tmp );
3116 }
3117 hbmNewBitmap = CreateDIBSection(hdc, bmi, DIB_RGB_COLORS, NULL, 0, 0);
3118 }
3119 else /*if (ilc == ILC_COLORDDB)*/
3120 {
3121 TRACE("Creating Bitmap: %d Bits per Pixel\n", himl->uBitsPixel);
3122
3123 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, himl->uBitsPixel, NULL);
3124 }
3125 TRACE("returning %p\n", hbmNewBitmap);
3126 return hbmNewBitmap;
3127 }
3128
3129 /*************************************************************************
3130 * ImageList_SetColorTable [COMCTL32.@]
3131 *
3132 * Sets the color table of an image list.
3133 *
3134 * PARAMS
3135 * himl [I] Handle to the image list.
3136 * uStartIndex [I] The first index to set.
3137 * cEntries [I] Number of entries to set.
3138 * prgb [I] New color information for color table for the image list.
3139 *
3140 * RETURNS
3141 * Success: Number of entries in the table that were set.
3142 * Failure: Zero.
3143 *
3144 * SEE
3145 * ImageList_Create(), SetDIBColorTable()
3146 */
3147
3148 UINT WINAPI
3149 ImageList_SetColorTable (HIMAGELIST himl, UINT uStartIndex, UINT cEntries, CONST RGBQUAD * prgb)
3150 {
3151 return SetDIBColorTable(himl->hdcImage, uStartIndex, cEntries, prgb);
3152 }
3153
3154 /*************************************************************************
3155 * ImageList_CoCreateInstance [COMCTL32.@]
3156 *
3157 * Creates a new imagelist instance and returns an interface pointer to it.
3158 *
3159 * PARAMS
3160 * rclsid [I] A reference to the CLSID (CLSID_ImageList).
3161 * punkOuter [I] Pointer to IUnknown interface for aggregation, if desired
3162 * riid [I] Identifier of the requested interface.
3163 * ppv [O] Returns the address of the pointer requested, or NULL.
3164 *
3165 * RETURNS
3166 * Success: S_OK.
3167 * Failure: Error value.
3168 */
3169 HRESULT WINAPI
3170 ImageList_CoCreateInstance (REFCLSID rclsid, const IUnknown *punkOuter, REFIID riid, void **ppv)
3171 {
3172 TRACE("(%s,%p,%s,%p)\n", debugstr_guid(rclsid), punkOuter, debugstr_guid(riid), ppv);
3173
3174 if (!IsEqualCLSID(&CLSID_ImageList, rclsid))
3175 return E_NOINTERFACE;
3176
3177 return ImageListImpl_CreateInstance(punkOuter, riid, ppv);
3178 }
3179
3180
3181 /*************************************************************************
3182 * IImageList implementation
3183 */
3184
3185 static HRESULT WINAPI ImageListImpl_QueryInterface(IImageList *iface,
3186 REFIID iid, void **ppv)
3187 {
3188 HIMAGELIST This = (HIMAGELIST) iface;
3189 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
3190
3191 if (!ppv) return E_INVALIDARG;
3192
3193 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IImageList, iid))
3194 *ppv = This;
3195 else
3196 {
3197 *ppv = NULL;
3198 return E_NOINTERFACE;
3199 }
3200
3201 IUnknown_AddRef((IUnknown*)*ppv);
3202 return S_OK;
3203 }
3204
3205 static ULONG WINAPI ImageListImpl_AddRef(IImageList *iface)
3206 {
3207 HIMAGELIST This = (HIMAGELIST) iface;
3208 ULONG ref = InterlockedIncrement(&This->ref);
3209
3210 TRACE("(%p) refcount=%u\n", iface, ref);
3211 return ref;
3212 }
3213
3214 static ULONG WINAPI ImageListImpl_Release(IImageList *iface)
3215 {
3216 HIMAGELIST This = (HIMAGELIST) iface;
3217 ULONG ref = InterlockedDecrement(&This->ref);
3218
3219 TRACE("(%p) refcount=%u\n", iface, ref);
3220
3221 if (ref == 0)
3222 {
3223 /* delete image bitmaps */
3224 if (This->hbmImage) DeleteObject (This->hbmImage);
3225 if (This->hbmMask) DeleteObject (This->hbmMask);
3226
3227 /* delete image & mask DCs */
3228 if (This->hdcImage) DeleteDC (This->hdcImage);
3229 if (This->hdcMask) DeleteDC (This->hdcMask);
3230
3231 /* delete blending brushes */
3232 if (This->hbrBlend25) DeleteObject (This->hbrBlend25);
3233 if (This->hbrBlend50) DeleteObject (This->hbrBlend50);
3234
3235 This->lpVtbl = NULL;
3236 HeapFree(GetProcessHeap(), 0, This->has_alpha);
3237 HeapFree(GetProcessHeap(), 0, This);
3238 }
3239
3240 return ref;
3241 }
3242
3243 static HRESULT WINAPI ImageListImpl_Add(IImageList *iface, HBITMAP hbmImage,
3244 HBITMAP hbmMask, int *pi)
3245 {
3246 HIMAGELIST This = (HIMAGELIST) iface;
3247 int ret;
3248
3249 if (!pi)
3250 return E_FAIL;
3251
3252 ret = ImageList_Add(This, hbmImage, hbmMask);
3253
3254 if (ret == -1)
3255 return E_FAIL;
3256
3257 *pi = ret;
3258 return S_OK;
3259 }
3260
3261 static HRESULT WINAPI ImageListImpl_ReplaceIcon(IImageList *iface, int i,
3262 HICON hicon, int *pi)
3263 {
3264 HIMAGELIST This = (HIMAGELIST) iface;
3265 int ret;
3266
3267 if (!pi)
3268 return E_FAIL;
3269
3270 ret = ImageList_ReplaceIcon(This, i, hicon);
3271
3272 if (ret == -1)
3273 return E_FAIL;
3274
3275 *pi = ret;
3276 return S_OK;
3277 }
3278
3279 static HRESULT WINAPI ImageListImpl_SetOverlayImage(IImageList *iface,
3280 int iImage, int iOverlay)
3281 {
3282 return ImageList_SetOverlayImage((HIMAGELIST) iface, iImage, iOverlay)
3283 ? S_OK : E_FAIL;
3284 }
3285
3286 static HRESULT WINAPI ImageListImpl_Replace(IImageList *iface, int i,
3287 HBITMAP hbmImage, HBITMAP hbmMask)
3288 {
3289 return ImageList_Replace((HIMAGELIST) iface, i, hbmImage, hbmMask) ? S_OK :
3290 E_FAIL;
3291 }
3292
3293 static HRESULT WINAPI ImageListImpl_AddMasked(IImageList *iface, HBITMAP hbmImage,
3294 COLORREF crMask, int *pi)
3295 {
3296 HIMAGELIST This = (HIMAGELIST) iface;
3297 int ret;
3298
3299 if (!pi)
3300 return E_FAIL;
3301
3302 ret = ImageList_AddMasked(This, hbmImage, crMask);
3303
3304 if (ret == -1)
3305 return E_FAIL;
3306
3307 *pi = ret;
3308 return S_OK;
3309 }
3310
3311 static HRESULT WINAPI ImageListImpl_Draw(IImageList *iface,
3312 IMAGELISTDRAWPARAMS *pimldp)
3313 {
3314 HIMAGELIST This = (HIMAGELIST) iface;
3315 HIMAGELIST old_himl;
3316 int ret;
3317
3318 /* As far as I can tell, Windows simply ignores the contents of pimldp->himl
3319 so we shall simulate the same */
3320 old_himl = pimldp->himl;
3321 pimldp->himl = This;
3322
3323 ret = ImageList_DrawIndirect(pimldp);
3324
3325 pimldp->himl = old_himl;
3326 return ret ? S_OK : E_INVALIDARG;
3327 }
3328
3329 static HRESULT WINAPI ImageListImpl_Remove(IImageList *iface, int i)
3330 {
3331 return (ImageList_Remove((HIMAGELIST) iface, i) == 0) ? E_INVALIDARG : S_OK;
3332 }
3333
3334 static HRESULT WINAPI ImageListImpl_GetIcon(IImageList *iface, int i, UINT flags,
3335 HICON *picon)
3336 {
3337 HICON hIcon;
3338
3339 if (!picon)
3340 return E_FAIL;
3341
3342 hIcon = ImageList_GetIcon((HIMAGELIST) iface, i, flags);
3343
3344 if (hIcon == NULL)
3345 return E_FAIL;
3346
3347 *picon = hIcon;
3348 return S_OK;
3349 }
3350
3351 static HRESULT WINAPI ImageListImpl_GetImageInfo(IImageList *iface, int i,
3352 IMAGEINFO *pImageInfo)
3353 {
3354 return ImageList_GetImageInfo((HIMAGELIST) iface, i, pImageInfo) ? S_OK : E_FAIL;
3355 }
3356
3357 static HRESULT WINAPI ImageListImpl_Copy(IImageList *iface, int iDst,
3358 IUnknown *punkSrc, int iSrc, UINT uFlags)
3359 {
3360 HIMAGELIST This = (HIMAGELIST) iface;
3361 IImageList *src = NULL;
3362 HRESULT ret;
3363
3364 if (!punkSrc)
3365 return E_FAIL;
3366
3367 /* TODO: Add test for IID_ImageList2 too */
3368 if (FAILED(IImageList_QueryInterface(punkSrc, &IID_IImageList,
3369 (void **) &src)))
3370 return E_FAIL;
3371
3372 if (ImageList_Copy(This, iDst, (HIMAGELIST) src, iSrc, uFlags))
3373 ret = S_OK;
3374 else
3375 ret = E_FAIL;
3376
3377 IImageList_Release(src);
3378 return ret;
3379 }
3380
3381 static HRESULT WINAPI ImageListImpl_Merge(IImageList *iface, int i1,
3382 IUnknown *punk2, int i2, int dx, int dy, REFIID riid, void **ppv)
3383 {
3384 HIMAGELIST This = (HIMAGELIST) iface;
3385 IImageList *iml2 = NULL;
3386 HIMAGELIST hNew;
3387 HRESULT ret = E_FAIL;
3388
3389 TRACE("(%p)->(%d %p %d %d %d %s %p)\n", iface, i1, punk2, i2, dx, dy, debugstr_guid(riid), ppv);
3390
3391 /* TODO: Add test for IID_ImageList2 too */
3392 if (FAILED(IImageList_QueryInterface(punk2, &IID_IImageList,
3393 (void **) &iml2)))
3394 return E_FAIL;
3395
3396 hNew = ImageList_Merge(This, i1, (HIMAGELIST) iml2, i2, dx, dy);
3397
3398 /* Get the interface for the new image list */
3399 if (hNew)
3400 {
3401 IImageList *imerge = (IImageList*)hNew;
3402
3403 ret = HIMAGELIST_QueryInterface(hNew, riid, ppv);
3404 IImageList_Release(imerge);
3405 }
3406
3407 IImageList_Release(iml2);
3408 return ret;
3409 }
3410
3411 static HRESULT WINAPI ImageListImpl_Clone(IImageList *iface, REFIID riid, void **ppv)
3412 {
3413 HIMAGELIST This = (HIMAGELIST) iface;
3414 HIMAGELIST clone;
3415 HRESULT ret = E_FAIL;
3416
3417 TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
3418
3419 clone = ImageList_Duplicate(This);
3420
3421 /* Get the interface for the new image list */
3422 if (clone)
3423 {
3424 IImageList *iclone = (IImageList*)clone;
3425
3426 ret = HIMAGELIST_QueryInterface(clone, riid, ppv);
3427 IImageList_Release(iclone);
3428 }
3429
3430 return ret;
3431 }
3432
3433 static HRESULT WINAPI ImageListImpl_GetImageRect(IImageList *iface, int i,
3434 RECT *prc)
3435 {
3436 HIMAGELIST This = (HIMAGELIST) iface;
3437 IMAGEINFO info;
3438
3439 if (!prc)
3440 return E_FAIL;
3441
3442 if (!ImageList_GetImageInfo(This, i, &info))
3443 return E_FAIL;
3444
3445 return CopyRect(prc, &info.rcImage) ? S_OK : E_FAIL;
3446 }
3447
3448 static HRESULT WINAPI ImageListImpl_GetIconSize(IImageList *iface, int *cx,
3449 int *cy)
3450 {
3451 HIMAGELIST This = (HIMAGELIST) iface;
3452
3453 return ImageList_GetIconSize(This, cx, cy) ? S_OK : E_INVALIDARG;
3454 }
3455
3456 static HRESULT WINAPI ImageListImpl_SetIconSize(IImageList *iface, int cx,
3457 int cy)
3458 {
3459 return ImageList_SetIconSize((HIMAGELIST) iface, cx, cy) ? S_OK : E_FAIL;
3460 }
3461
3462 static HRESULT WINAPI ImageListImpl_GetImageCount(IImageList *iface, int *pi)
3463 {
3464 *pi = ImageList_GetImageCount((HIMAGELIST) iface);
3465 return S_OK;
3466 }
3467
3468 static HRESULT WINAPI ImageListImpl_SetImageCount(IImageList *iface,
3469 UINT uNewCount)
3470 {
3471 return ImageList_SetImageCount((HIMAGELIST) iface, uNewCount) ? S_OK : E_FAIL;
3472 }
3473
3474 static HRESULT WINAPI ImageListImpl_SetBkColor(IImageList *iface, COLORREF clrBk,
3475 COLORREF *pclr)
3476 {
3477 *pclr = ImageList_SetBkColor((HIMAGELIST) iface, clrBk);
3478 return S_OK;
3479 }
3480
3481 static HRESULT WINAPI ImageListImpl_GetBkColor(IImageList *iface, COLORREF *pclr)
3482 {
3483 *pclr = ImageList_GetBkColor((HIMAGELIST) iface);
3484 return S_OK;
3485 }
3486
3487 static HRESULT WINAPI ImageListImpl_BeginDrag(IImageList *iface, int iTrack,
3488 int dxHotspot, int dyHotspot)
3489 {
3490 return ImageList_BeginDrag((HIMAGELIST) iface, iTrack, dxHotspot, dyHotspot) ? S_OK : E_FAIL;
3491 }
3492
3493 static HRESULT WINAPI ImageListImpl_EndDrag(IImageList *iface)
3494 {
3495 ImageList_EndDrag();
3496 return S_OK;
3497 }
3498
3499 static HRESULT WINAPI ImageListImpl_DragEnter(IImageList *iface, HWND hwndLock,
3500 int x, int y)
3501 {
3502 return ImageList_DragEnter(hwndLock, x, y) ? S_OK : E_FAIL;
3503 }
3504
3505 static HRESULT WINAPI ImageListImpl_DragLeave(IImageList *iface, HWND hwndLock)
3506 {
3507 return ImageList_DragLeave(hwndLock) ? S_OK : E_FAIL;
3508 }
3509
3510 static HRESULT WINAPI ImageListImpl_DragMove(IImageList *iface, int x, int y)
3511 {
3512 return ImageList_DragMove(x, y) ? S_OK : E_FAIL;
3513 }
3514
3515 static HRESULT WINAPI ImageListImpl_SetDragCursorImage(IImageList *iface,
3516 IUnknown *punk, int iDrag, int dxHotspot, int dyHotspot)
3517 {
3518 IImageList *iml2 = NULL;
3519 HRESULT ret;
3520
3521 if (!punk)
3522 return E_FAIL;
3523
3524 /* TODO: Add test for IID_ImageList2 too */
3525 if (FAILED(IImageList_QueryInterface(punk, &IID_IImageList,
3526 (void **) &iml2)))
3527 return E_FAIL;
3528
3529 ret = ImageList_SetDragCursorImage((HIMAGELIST) iml2, iDrag, dxHotspot,
3530 dyHotspot);
3531
3532 IImageList_Release(iml2);
3533
3534 return ret ? S_OK : E_FAIL;
3535 }
3536
3537 static HRESULT WINAPI ImageListImpl_DragShowNolock(IImageList *iface, BOOL fShow)
3538 {
3539 return ImageList_DragShowNolock(fShow) ? S_OK : E_FAIL;
3540 }
3541
3542 static HRESULT WINAPI ImageListImpl_GetDragImage(IImageList *iface, POINT *ppt,
3543 POINT *pptHotspot, REFIID riid, PVOID *ppv)
3544 {
3545 HRESULT ret = E_FAIL;
3546 HIMAGELIST hNew;
3547
3548 if (!ppv)
3549 return E_FAIL;
3550
3551 hNew = ImageList_GetDragImage(ppt, pptHotspot);
3552
3553 /* Get the interface for the new image list */
3554 if (hNew)
3555 {
3556 IImageList *idrag = (IImageList*)hNew;
3557
3558 ret = HIMAGELIST_QueryInterface(hNew, riid, ppv);
3559 IImageList_Release(idrag);
3560 }
3561
3562 return ret;
3563 }
3564
3565 static HRESULT WINAPI ImageListImpl_GetItemFlags(IImageList *iface, int i,
3566 DWORD *dwFlags)
3567 {
3568 FIXME("STUB: %p %d %p\n", iface, i, dwFlags);
3569 return E_NOTIMPL;
3570 }
3571
3572 static HRESULT WINAPI ImageListImpl_GetOverlayImage(IImageList *iface, int iOverlay,
3573 int *piIndex)
3574 {
3575 HIMAGELIST This = (HIMAGELIST) iface;
3576 int i;
3577
3578 if ((iOverlay < 0) || (iOverlay > This->cCurImage))
3579 return E_FAIL;
3580
3581 for (i = 0; i < MAX_OVERLAYIMAGE; i++)
3582 {
3583 if (This->nOvlIdx[i] == iOverlay)
3584 {
3585 *piIndex = i + 1;
3586 return S_OK;
3587 }
3588 }
3589
3590 return E_FAIL;
3591 }
3592
3593
3594 static const IImageListVtbl ImageListImpl_Vtbl = {
3595 ImageListImpl_QueryInterface,
3596 ImageListImpl_AddRef,
3597 ImageListImpl_Release,
3598 ImageListImpl_Add,
3599 ImageListImpl_ReplaceIcon,
3600 ImageListImpl_SetOverlayImage,
3601 ImageListImpl_Replace,
3602 ImageListImpl_AddMasked,
3603 ImageListImpl_Draw,
3604 ImageListImpl_Remove,
3605 ImageListImpl_GetIcon,
3606 ImageListImpl_GetImageInfo,
3607 ImageListImpl_Copy,
3608 ImageListImpl_Merge,
3609 ImageListImpl_Clone,
3610 ImageListImpl_GetImageRect,
3611 ImageListImpl_GetIconSize,
3612 ImageListImpl_SetIconSize,
3613 ImageListImpl_GetImageCount,
3614 ImageListImpl_SetImageCount,
3615 ImageListImpl_SetBkColor,
3616 ImageListImpl_GetBkColor,
3617 ImageListImpl_BeginDrag,
3618 ImageListImpl_EndDrag,
3619 ImageListImpl_DragEnter,
3620 ImageListImpl_DragLeave,
3621 ImageListImpl_DragMove,
3622 ImageListImpl_SetDragCursorImage,
3623 ImageListImpl_DragShowNolock,
3624 ImageListImpl_GetDragImage,
3625 ImageListImpl_GetItemFlags,
3626 ImageListImpl_GetOverlayImage
3627 };
3628
3629 static BOOL is_valid(HIMAGELIST himl)
3630 {
3631 BOOL valid;
3632 __TRY
3633 {
3634 valid = himl && himl->lpVtbl == &ImageListImpl_Vtbl;
3635 }
3636 __EXCEPT_PAGE_FAULT
3637 {
3638 valid = FALSE;
3639 }
3640 __ENDTRY
3641 return valid;
3642 }
3643
3644 /*************************************************************************
3645 * HIMAGELIST_QueryInterface [COMCTL32.@]
3646 *
3647 * Returns a pointer to an IImageList or IImageList2 object for the given
3648 * HIMAGELIST.
3649 *
3650 * PARAMS
3651 * himl [I] Image list handle.
3652 * riid [I] Identifier of the requested interface.
3653 * ppv [O] Returns the address of the pointer requested, or NULL.
3654 *
3655 * RETURNS
3656 * Success: S_OK.
3657 * Failure: Error value.
3658 */
3659 HRESULT WINAPI
3660 HIMAGELIST_QueryInterface (HIMAGELIST himl, REFIID riid, void **ppv)
3661 {
3662 TRACE("(%p,%s,%p)\n", himl, debugstr_guid(riid), ppv);
3663 return IImageList_QueryInterface((IImageList *) himl, riid, ppv);
3664 }
3665
3666 static HRESULT ImageListImpl_CreateInstance(const IUnknown *pUnkOuter, REFIID iid, void** ppv)
3667 {
3668 HIMAGELIST This;
3669 HRESULT ret;
3670
3671 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
3672
3673 *ppv = NULL;
3674
3675 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
3676
3677 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct _IMAGELIST));
3678 if (!This) return E_OUTOFMEMORY;
3679
3680 This->lpVtbl = &ImageListImpl_Vtbl;
3681 This->ref = 1;
3682
3683 ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
3684 IUnknown_Release((IUnknown*)This);
3685
3686 return ret;
3687 }
Maarten's multimedia branch