projects / reactos.git / blob
? search:


a2bc10a80e586e3891e14ba79c1da65fc3521f75
[reactos.git] / dll / win32 / comctl32 / imagelist.c
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, ILS_ALPHA
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 "imagelist.h"
55 #include "wine/debug.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(imagelist);
58
59
60 #define MAX_OVERLAYIMAGE 15
61
62 /* internal image list data used for Drag & Drop operations */
63 typedef struct
64 {
65 HWND hwnd;
66 HIMAGELIST himl;
67 /* position of the drag image relative to the window */
68 INT x;
69 INT y;
70 /* offset of the hotspot relative to the origin of the image */
71 INT dxHotspot;
72 INT dyHotspot;
73 /* is the drag image visible */
74 BOOL bShow;
75 /* saved background */
76 HBITMAP hbmBg;
77 } INTERNALDRAG;
78
79 static INTERNALDRAG InternalDrag = { 0, 0, 0, 0, 0, 0, FALSE, 0 };
80
81 static HBITMAP ImageList_CreateImage(HDC hdc, HIMAGELIST himl, UINT count, UINT width);
82
83 static inline BOOL is_valid(HIMAGELIST himl)
84 {
85 return himl && himl->magic == IMAGELIST_MAGIC;
86 }
87
88 /*
89 * An imagelist with N images is tiled like this:
90 *
91 * N/4 ->
92 *
93 * 4 048C..
94 * 159D..
95 * | 26AE.N
96 * V 37BF.
97 */
98
99 #define TILE_COUNT 4
100
101 static inline UINT imagelist_height( UINT count )
102 {
103 return ((count + TILE_COUNT - 1)/TILE_COUNT);
104 }
105
106 static inline void imagelist_point_from_index( HIMAGELIST himl, UINT index, LPPOINT pt )
107 {
108 pt->x = (index%TILE_COUNT) * himl->cx;
109 pt->y = (index/TILE_COUNT) * himl->cy;
110 }
111
112 static inline void imagelist_get_bitmap_size( HIMAGELIST himl, UINT count, UINT cx, SIZE *sz )
113 {
114 sz->cx = cx * TILE_COUNT;
115 sz->cy = imagelist_height( count ) * himl->cy;
116 }
117
118 /*
119 * imagelist_copy_images()
120 *
121 * Copies a block of count images from offset src in the list to offset dest.
122 * Images are copied a row at at time. Assumes hdcSrc and hdcDest are different.
123 */
124 static inline void imagelist_copy_images( HIMAGELIST himl, HDC hdcSrc, HDC hdcDest,
125 UINT src, UINT count, UINT dest )
126 {
127 POINT ptSrc, ptDest;
128 SIZE sz;
129 UINT i;
130
131 for ( i=0; i<TILE_COUNT; i++ )
132 {
133 imagelist_point_from_index( himl, src+i, &ptSrc );
134 imagelist_point_from_index( himl, dest+i, &ptDest );
135 sz.cx = himl->cx;
136 sz.cy = himl->cy * imagelist_height( count - i );
137
138 BitBlt( hdcDest, ptDest.x, ptDest.y, sz.cx, sz.cy,
139 hdcSrc, ptSrc.x, ptSrc.y, SRCCOPY );
140 }
141 }
142
143 /*************************************************************************
144 * IMAGELIST_InternalExpandBitmaps [Internal]
145 *
146 * Expands the bitmaps of an image list by the given number of images.
147 *
148 * PARAMS
149 * himl [I] handle to image list
150 * nImageCount [I] number of images to add
151 *
152 * RETURNS
153 * nothing
154 *
155 * NOTES
156 * This function CANNOT be used to reduce the number of images.
157 */
158 static void
159 IMAGELIST_InternalExpandBitmaps (HIMAGELIST himl, INT nImageCount, INT cy)
160 {
161 HDC hdcBitmap;
162 HBITMAP hbmNewBitmap, hbmNull;
163 INT nNewCount;
164 SIZE sz;
165
166 if ((himl->cCurImage + nImageCount <= himl->cMaxImage)
167 && (himl->cy >= cy))
168 return;
169
170 nNewCount = himl->cCurImage + nImageCount + himl->cGrow;
171
172 imagelist_get_bitmap_size(himl, nNewCount, himl->cx, &sz);
173
174 TRACE("Create expanded bitmaps : himl=%p x=%d y=%d count=%d\n", himl, sz.cx, cy, nNewCount);
175 hdcBitmap = CreateCompatibleDC (0);
176
177 hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount, himl->cx);
178
179 if (hbmNewBitmap == 0)
180 ERR("creating new image bitmap (x=%d y=%d)!\n", sz.cx, cy);
181
182 if (himl->cCurImage)
183 {
184 hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
185 BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
186 himl->hdcImage, 0, 0, SRCCOPY);
187 SelectObject (hdcBitmap, hbmNull);
188 }
189 SelectObject (himl->hdcImage, hbmNewBitmap);
190 DeleteObject (himl->hbmImage);
191 himl->hbmImage = hbmNewBitmap;
192
193 if (himl->flags & ILC_MASK)
194 {
195 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
196
197 if (hbmNewBitmap == 0)
198 ERR("creating new mask bitmap!\n");
199
200 if(himl->cCurImage)
201 {
202 hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
203 BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
204 himl->hdcMask, 0, 0, SRCCOPY);
205 SelectObject (hdcBitmap, hbmNull);
206 }
207 SelectObject (himl->hdcMask, hbmNewBitmap);
208 DeleteObject (himl->hbmMask);
209 himl->hbmMask = hbmNewBitmap;
210 }
211
212 himl->cMaxImage = nNewCount;
213
214 DeleteDC (hdcBitmap);
215 }
216
217
218 /*************************************************************************
219 * ImageList_Add [COMCTL32.@]
220 *
221 * Add an image or images to an image list.
222 *
223 * PARAMS
224 * himl [I] handle to image list
225 * hbmImage [I] handle to image bitmap
226 * hbmMask [I] handle to mask bitmap
227 *
228 * RETURNS
229 * Success: Index of the first new image.
230 * Failure: -1
231 */
232
233 INT WINAPI
234 ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
235 {
236 HDC hdcBitmap, hdcTemp;
237 INT nFirstIndex, nImageCount, i;
238 BITMAP bmp;
239 HBITMAP hOldBitmap, hOldBitmapTemp;
240 POINT pt;
241
242 TRACE("himl=%p hbmimage=%p hbmmask=%p\n", himl, hbmImage, hbmMask);
243 if (!is_valid(himl))
244 return -1;
245
246 if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
247 return -1;
248
249 nImageCount = bmp.bmWidth / himl->cx;
250
251 IMAGELIST_InternalExpandBitmaps (himl, nImageCount, bmp.bmHeight);
252
253 hdcBitmap = CreateCompatibleDC(0);
254
255 hOldBitmap = SelectObject(hdcBitmap, hbmImage);
256
257 for (i=0; i<nImageCount; i++)
258 {
259 imagelist_point_from_index( himl, himl->cCurImage + i, &pt );
260
261 /* Copy result to the imagelist
262 */
263 BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
264 hdcBitmap, i*himl->cx, 0, SRCCOPY );
265
266 if (!himl->hbmMask)
267 continue;
268
269 hdcTemp = CreateCompatibleDC(0);
270 hOldBitmapTemp = SelectObject(hdcTemp, hbmMask);
271
272 BitBlt( himl->hdcMask, pt.x, pt.y, himl->cx, bmp.bmHeight,
273 hdcTemp, i*himl->cx, 0, SRCCOPY );
274
275 SelectObject(hdcTemp, hOldBitmapTemp);
276 DeleteDC(hdcTemp);
277
278 /* Remove the background from the image
279 */
280 BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
281 himl->hdcMask, pt.x, pt.y, 0x220326 ); /* NOTSRCAND */
282 }
283
284 SelectObject(hdcBitmap, hOldBitmap);
285 DeleteDC(hdcBitmap);
286
287 nFirstIndex = himl->cCurImage;
288 himl->cCurImage += nImageCount;
289
290 return nFirstIndex;
291 }
292
293
294 /*************************************************************************
295 * ImageList_AddIcon [COMCTL32.@]
296 *
297 * Adds an icon to an image list.
298 *
299 * PARAMS
300 * himl [I] handle to image list
301 * hIcon [I] handle to icon
302 *
303 * RETURNS
304 * Success: index of the new image
305 * Failure: -1
306 */
307 #undef ImageList_AddIcon
308 INT WINAPI ImageList_AddIcon (HIMAGELIST himl, HICON hIcon)
309 {
310 return ImageList_ReplaceIcon (himl, -1, hIcon);
311 }
312
313
314 /*************************************************************************
315 * ImageList_AddMasked [COMCTL32.@]
316 *
317 * Adds an image or images to an image list and creates a mask from the
318 * specified bitmap using the mask color.
319 *
320 * PARAMS
321 * himl [I] handle to image list.
322 * hBitmap [I] handle to bitmap
323 * clrMask [I] mask color.
324 *
325 * RETURNS
326 * Success: Index of the first new image.
327 * Failure: -1
328 */
329
330 INT WINAPI
331 ImageList_AddMasked (HIMAGELIST himl, HBITMAP hBitmap, COLORREF clrMask)
332 {
333 HDC hdcMask, hdcBitmap;
334 INT i, nIndex, nImageCount;
335 BITMAP bmp;
336 HBITMAP hOldBitmap;
337 HBITMAP hMaskBitmap=0;
338 COLORREF bkColor;
339 POINT pt;
340
341 TRACE("himl=%p hbitmap=%p clrmask=%x\n", himl, hBitmap, clrMask);
342 if (!is_valid(himl))
343 return -1;
344
345 if (!GetObjectW(hBitmap, sizeof(BITMAP), &bmp))
346 return -1;
347
348 if (himl->cx > 0)
349 nImageCount = bmp.bmWidth / himl->cx;
350 else
351 nImageCount = 0;
352
353 IMAGELIST_InternalExpandBitmaps (himl, nImageCount, bmp.bmHeight);
354
355 nIndex = himl->cCurImage;
356 himl->cCurImage += nImageCount;
357
358 hdcBitmap = CreateCompatibleDC(0);
359 hOldBitmap = SelectObject(hdcBitmap, hBitmap);
360
361 /* Create a temp Mask so we can remove the background of the Image */
362 hdcMask = CreateCompatibleDC(0);
363 hMaskBitmap = CreateBitmap(bmp.bmWidth, bmp.bmHeight, 1, 1, NULL);
364 SelectObject(hdcMask, hMaskBitmap);
365
366 /* create monochrome image to the mask bitmap */
367 bkColor = (clrMask != CLR_DEFAULT) ? clrMask : GetPixel (hdcBitmap, 0, 0);
368 SetBkColor (hdcBitmap, bkColor);
369 BitBlt (hdcMask, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcBitmap, 0, 0, SRCCOPY);
370
371 SetBkColor(hdcBitmap, RGB(255,255,255));
372
373 /*
374 * Remove the background from the image
375 *
376 * WINDOWS BUG ALERT!!!!!!
377 * The statement below should not be done in common practice
378 * but this is how ImageList_AddMasked works in Windows.
379 * It overwrites the original bitmap passed, this was discovered
380 * by using the same bitmap to iterate the different styles
381 * on windows where it failed (BUT ImageList_Add is OK)
382 * This is here in case some apps rely on this bug
383 *
384 * Blt mode 0x220326 is NOTSRCAND
385 */
386 BitBlt(hdcBitmap, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcMask, 0, 0, 0x220326);
387
388 /* Copy result to the imagelist */
389 for (i=0; i<nImageCount; i++)
390 {
391 imagelist_point_from_index( himl, nIndex + i, &pt );
392 BitBlt(himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
393 hdcBitmap, i*himl->cx, 0, SRCCOPY);
394 BitBlt(himl->hdcMask, pt.x, pt.y, himl->cx, bmp.bmHeight,
395 hdcMask, i*himl->cx, 0, SRCCOPY);
396 }
397
398 /* Clean up */
399 SelectObject(hdcBitmap, hOldBitmap);
400 DeleteDC(hdcBitmap);
401 DeleteObject(hMaskBitmap);
402 DeleteDC(hdcMask);
403
404 return nIndex;
405 }
406
407
408 /*************************************************************************
409 * ImageList_BeginDrag [COMCTL32.@]
410 *
411 * Creates a temporary image list that contains one image. It will be used
412 * as a drag image.
413 *
414 * PARAMS
415 * himlTrack [I] handle to the source image list
416 * iTrack [I] index of the drag image in the source image list
417 * dxHotspot [I] X position of the hot spot of the drag image
418 * dyHotspot [I] Y position of the hot spot of the drag image
419 *
420 * RETURNS
421 * Success: TRUE
422 * Failure: FALSE
423 */
424
425 BOOL WINAPI
426 ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack,
427 INT dxHotspot, INT dyHotspot)
428 {
429 INT cx, cy;
430
431 TRACE("(himlTrack=%p iTrack=%d dx=%d dy=%d)\n", himlTrack, iTrack,
432 dxHotspot, dyHotspot);
433
434 if (!is_valid(himlTrack))
435 return FALSE;
436
437 if (InternalDrag.himl)
438 ImageList_EndDrag ();
439
440 cx = himlTrack->cx;
441 cy = himlTrack->cy;
442
443 InternalDrag.himl = ImageList_Create (cx, cy, himlTrack->flags, 1, 1);
444 if (InternalDrag.himl == NULL) {
445 WARN("Error creating drag image list!\n");
446 return FALSE;
447 }
448
449 InternalDrag.dxHotspot = dxHotspot;
450 InternalDrag.dyHotspot = dyHotspot;
451
452 /* copy image */
453 BitBlt (InternalDrag.himl->hdcImage, 0, 0, cx, cy, himlTrack->hdcImage, iTrack * cx, 0, SRCCOPY);
454
455 /* copy mask */
456 BitBlt (InternalDrag.himl->hdcMask, 0, 0, cx, cy, himlTrack->hdcMask, iTrack * cx, 0, SRCCOPY);
457
458 InternalDrag.himl->cCurImage = 1;
459
460 return TRUE;
461 }
462
463
464 /*************************************************************************
465 * ImageList_Copy [COMCTL32.@]
466 *
467 * Copies an image of the source image list to an image of the
468 * destination image list. Images can be copied or swapped.
469 *
470 * PARAMS
471 * himlDst [I] handle to the destination image list
472 * iDst [I] destination image index.
473 * himlSrc [I] handle to the source image list
474 * iSrc [I] source image index
475 * uFlags [I] flags for the copy operation
476 *
477 * RETURNS
478 * Success: TRUE
479 * Failure: FALSE
480 *
481 * NOTES
482 * Copying from one image list to another is possible. The original
483 * implementation just copies or swaps within one image list.
484 * Could this feature become a bug??? ;-)
485 */
486
487 BOOL WINAPI
488 ImageList_Copy (HIMAGELIST himlDst, INT iDst, HIMAGELIST himlSrc,
489 INT iSrc, UINT uFlags)
490 {
491 POINT ptSrc, ptDst;
492
493 TRACE("himlDst=%p iDst=%d himlSrc=%p iSrc=%d\n", himlDst, iDst, himlSrc, iSrc);
494
495 if (!is_valid(himlSrc) || !is_valid(himlDst))
496 return FALSE;
497 if ((iDst < 0) || (iDst >= himlDst->cCurImage))
498 return FALSE;
499 if ((iSrc < 0) || (iSrc >= himlSrc->cCurImage))
500 return FALSE;
501
502 imagelist_point_from_index( himlDst, iDst, &ptDst );
503 imagelist_point_from_index( himlSrc, iSrc, &ptSrc );
504
505 if (uFlags & ILCF_SWAP) {
506 /* swap */
507 HDC hdcBmp;
508 HBITMAP hbmTempImage, hbmTempMask;
509
510 hdcBmp = CreateCompatibleDC (0);
511
512 /* create temporary bitmaps */
513 hbmTempImage = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
514 himlSrc->uBitsPixel, NULL);
515 hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
516 1, NULL);
517
518 /* copy (and stretch) destination to temporary bitmaps.(save) */
519 /* image */
520 SelectObject (hdcBmp, hbmTempImage);
521 StretchBlt (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
522 himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
523 SRCCOPY);
524 /* mask */
525 SelectObject (hdcBmp, hbmTempMask);
526 StretchBlt (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
527 himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
528 SRCCOPY);
529
530 /* copy (and stretch) source to destination */
531 /* image */
532 StretchBlt (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
533 himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
534 SRCCOPY);
535 /* mask */
536 StretchBlt (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
537 himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
538 SRCCOPY);
539
540 /* copy (without stretching) temporary bitmaps to source (restore) */
541 /* mask */
542 BitBlt (himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
543 hdcBmp, 0, 0, SRCCOPY);
544
545 /* image */
546 BitBlt (himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
547 hdcBmp, 0, 0, SRCCOPY);
548 /* delete temporary bitmaps */
549 DeleteObject (hbmTempMask);
550 DeleteObject (hbmTempImage);
551 DeleteDC(hdcBmp);
552 }
553 else {
554 /* copy image */
555 StretchBlt (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
556 himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
557 SRCCOPY);
558
559 /* copy mask */
560 StretchBlt (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
561 himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
562 SRCCOPY);
563 }
564
565 return TRUE;
566 }
567
568
569 /*************************************************************************
570 * ImageList_Create [COMCTL32.@]
571 *
572 * Creates a new image list.
573 *
574 * PARAMS
575 * cx [I] image height
576 * cy [I] image width
577 * flags [I] creation flags
578 * cInitial [I] initial number of images in the image list
579 * cGrow [I] number of images by which image list grows
580 *
581 * RETURNS
582 * Success: Handle to the created image list
583 * Failure: NULL
584 */
585 HIMAGELIST WINAPI
586 ImageList_Create (INT cx, INT cy, UINT flags,
587 INT cInitial, INT cGrow)
588 {
589 HIMAGELIST himl;
590 INT nCount;
591 HBITMAP hbmTemp;
592 UINT ilc = (flags & 0xFE);
593 static const WORD aBitBlend25[] =
594 {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
595
596 static const WORD aBitBlend50[] =
597 {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
598
599 TRACE("(%d %d 0x%x %d %d)\n", cx, cy, flags, cInitial, cGrow);
600
601 himl = Alloc (sizeof(struct _IMAGELIST));
602 if (!himl)
603 return NULL;
604
605 cGrow = (cGrow < 4) ? 4 : (cGrow + 3) & ~3;
606
607 himl->magic = IMAGELIST_MAGIC;
608 himl->cx = cx;
609 himl->cy = cy;
610 himl->flags = flags;
611 himl->cMaxImage = cInitial + 1;
612 himl->cInitial = cInitial;
613 himl->cGrow = cGrow;
614 himl->clrFg = CLR_DEFAULT;
615 himl->clrBk = CLR_NONE;
616
617 /* initialize overlay mask indices */
618 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
619 himl->nOvlIdx[nCount] = -1;
620
621 /* Create Image & Mask DCs */
622 himl->hdcImage = CreateCompatibleDC (0);
623 if (!himl->hdcImage)
624 goto cleanup;
625 if (himl->flags & ILC_MASK){
626 himl->hdcMask = CreateCompatibleDC(0);
627 if (!himl->hdcMask)
628 goto cleanup;
629 }
630
631 /* Default to ILC_COLOR4 if none of the ILC_COLOR* flags are specified */
632 if (ilc == ILC_COLOR)
633 ilc = ILC_COLOR4;
634
635 if (ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32)
636 himl->uBitsPixel = ilc;
637 else
638 himl->uBitsPixel = (UINT)GetDeviceCaps (himl->hdcImage, BITSPIXEL);
639
640 if (himl->cMaxImage > 0) {
641 himl->hbmImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage, cx);
642 SelectObject(himl->hdcImage, himl->hbmImage);
643 } else
644 himl->hbmImage = 0;
645
646 if ((himl->cMaxImage > 0) && (himl->flags & ILC_MASK)) {
647 SIZE sz;
648
649 imagelist_get_bitmap_size(himl, himl->cMaxImage, himl->cx, &sz);
650 himl->hbmMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
651 if (himl->hbmMask == 0) {
652 ERR("Error creating mask bitmap!\n");
653 goto cleanup;
654 }
655 SelectObject(himl->hdcMask, himl->hbmMask);
656 }
657 else
658 himl->hbmMask = 0;
659
660 /* create blending brushes */
661 hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend25);
662 himl->hbrBlend25 = CreatePatternBrush (hbmTemp);
663 DeleteObject (hbmTemp);
664
665 hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend50);
666 himl->hbrBlend50 = CreatePatternBrush (hbmTemp);
667 DeleteObject (hbmTemp);
668
669 TRACE("created imagelist %p\n", himl);
670 return himl;
671
672 cleanup:
673 if (himl) ImageList_Destroy(himl);
674 return NULL;
675 }
676
677
678 /*************************************************************************
679 * ImageList_Destroy [COMCTL32.@]
680 *
681 * Destroys an image list.
682 *
683 * PARAMS
684 * himl [I] handle to image list
685 *
686 * RETURNS
687 * Success: TRUE
688 * Failure: FALSE
689 */
690
691 BOOL WINAPI
692 ImageList_Destroy (HIMAGELIST himl)
693 {
694 if (!is_valid(himl))
695 return FALSE;
696
697 /* delete image bitmaps */
698 if (himl->hbmImage)
699 DeleteObject (himl->hbmImage);
700 if (himl->hbmMask)
701 DeleteObject (himl->hbmMask);
702
703 /* delete image & mask DCs */
704 if (himl->hdcImage)
705 DeleteDC(himl->hdcImage);
706 if (himl->hdcMask)
707 DeleteDC(himl->hdcMask);
708
709 /* delete blending brushes */
710 if (himl->hbrBlend25)
711 DeleteObject (himl->hbrBlend25);
712 if (himl->hbrBlend50)
713 DeleteObject (himl->hbrBlend50);
714
715 ZeroMemory(himl, sizeof(*himl));
716 Free (himl);
717
718 return TRUE;
719 }
720
721
722 /*************************************************************************
723 * ImageList_DragEnter [COMCTL32.@]
724 *
725 * Locks window update and displays the drag image at the given position.
726 *
727 * PARAMS
728 * hwndLock [I] handle of the window that owns the drag image.
729 * x [I] X position of the drag image.
730 * y [I] Y position of the drag image.
731 *
732 * RETURNS
733 * Success: TRUE
734 * Failure: FALSE
735 *
736 * NOTES
737 * The position of the drag image is relative to the window, not
738 * the client area.
739 */
740
741 BOOL WINAPI
742 ImageList_DragEnter (HWND hwndLock, INT x, INT y)
743 {
744 TRACE("(hwnd=%p x=%d y=%d)\n", hwndLock, x, y);
745
746 if (!is_valid(InternalDrag.himl))
747 return FALSE;
748
749 if (hwndLock)
750 InternalDrag.hwnd = hwndLock;
751 else
752 InternalDrag.hwnd = GetDesktopWindow ();
753
754 InternalDrag.x = x;
755 InternalDrag.y = y;
756
757 /* draw the drag image and save the background */
758 if (!ImageList_DragShowNolock(TRUE)) {
759 return FALSE;
760 }
761
762 return TRUE;
763 }
764
765
766 /*************************************************************************
767 * ImageList_DragLeave [COMCTL32.@]
768 *
769 * Unlocks window update and hides the drag image.
770 *
771 * PARAMS
772 * hwndLock [I] handle of the window that owns the drag image.
773 *
774 * RETURNS
775 * Success: TRUE
776 * Failure: FALSE
777 */
778
779 BOOL WINAPI
780 ImageList_DragLeave (HWND hwndLock)
781 {
782 /* As we don't save drag info in the window this can lead to problems if
783 an app does not supply the same window as DragEnter */
784 /* if (hwndLock)
785 InternalDrag.hwnd = hwndLock;
786 else
787 InternalDrag.hwnd = GetDesktopWindow (); */
788 if(!hwndLock)
789 hwndLock = GetDesktopWindow();
790 if(InternalDrag.hwnd != hwndLock)
791 FIXME("DragLeave hWnd != DragEnter hWnd\n");
792
793 ImageList_DragShowNolock (FALSE);
794
795 return TRUE;
796 }
797
798
799 /*************************************************************************
800 * ImageList_InternalDragDraw [Internal]
801 *
802 * Draws the drag image.
803 *
804 * PARAMS
805 * hdc [I] device context to draw into.
806 * x [I] X position of the drag image.
807 * y [I] Y position of the drag image.
808 *
809 * RETURNS
810 * Success: TRUE
811 * Failure: FALSE
812 *
813 * NOTES
814 * The position of the drag image is relative to the window, not
815 * the client area.
816 *
817 */
818
819 static inline void
820 ImageList_InternalDragDraw (HDC hdc, INT x, INT y)
821 {
822 IMAGELISTDRAWPARAMS imldp;
823
824 ZeroMemory (&imldp, sizeof(imldp));
825 imldp.cbSize = sizeof(imldp);
826 imldp.himl = InternalDrag.himl;
827 imldp.i = 0;
828 imldp.hdcDst = hdc,
829 imldp.x = x;
830 imldp.y = y;
831 imldp.rgbBk = CLR_DEFAULT;
832 imldp.rgbFg = CLR_DEFAULT;
833 imldp.fStyle = ILD_NORMAL;
834 imldp.fState = ILS_ALPHA;
835 imldp.Frame = 128;
836
837 /* FIXME: instead of using the alpha blending, we should
838 * create a 50% mask, and draw it semitransparantly that way */
839 ImageList_DrawIndirect (&imldp);
840 }
841
842 /*************************************************************************
843 * ImageList_DragMove [COMCTL32.@]
844 *
845 * Moves the drag image.
846 *
847 * PARAMS
848 * x [I] X position of the drag image.
849 * y [I] Y position of the drag image.
850 *
851 * RETURNS
852 * Success: TRUE
853 * Failure: FALSE
854 *
855 * NOTES
856 * The position of the drag image is relative to the window, not
857 * the client area.
858 *
859 * BUGS
860 * The drag image should be drawn semitransparent.
861 */
862
863 BOOL WINAPI
864 ImageList_DragMove (INT x, INT y)
865 {
866 TRACE("(x=%d y=%d)\n", x, y);
867
868 if (!is_valid(InternalDrag.himl))
869 return FALSE;
870
871 /* draw/update the drag image */
872 if (InternalDrag.bShow) {
873 HDC hdcDrag;
874 HDC hdcOffScreen;
875 HDC hdcBg;
876 HBITMAP hbmOffScreen;
877 INT origNewX, origNewY;
878 INT origOldX, origOldY;
879 INT origRegX, origRegY;
880 INT sizeRegX, sizeRegY;
881
882
883 /* calculate the update region */
884 origNewX = x - InternalDrag.dxHotspot;
885 origNewY = y - InternalDrag.dyHotspot;
886 origOldX = InternalDrag.x - InternalDrag.dxHotspot;
887 origOldY = InternalDrag.y - InternalDrag.dyHotspot;
888 origRegX = min(origNewX, origOldX);
889 origRegY = min(origNewY, origOldY);
890 sizeRegX = InternalDrag.himl->cx + abs(x - InternalDrag.x);
891 sizeRegY = InternalDrag.himl->cy + abs(y - InternalDrag.y);
892
893 hdcDrag = GetDCEx(InternalDrag.hwnd, 0,
894 DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
895 hdcOffScreen = CreateCompatibleDC(hdcDrag);
896 hdcBg = CreateCompatibleDC(hdcDrag);
897
898 hbmOffScreen = CreateCompatibleBitmap(hdcDrag, sizeRegX, sizeRegY);
899 SelectObject(hdcOffScreen, hbmOffScreen);
900 SelectObject(hdcBg, InternalDrag.hbmBg);
901
902 /* get the actual background of the update region */
903 BitBlt(hdcOffScreen, 0, 0, sizeRegX, sizeRegY, hdcDrag,
904 origRegX, origRegY, SRCCOPY);
905 /* erase the old image */
906 BitBlt(hdcOffScreen, origOldX - origRegX, origOldY - origRegY,
907 InternalDrag.himl->cx, InternalDrag.himl->cy, hdcBg, 0, 0,
908 SRCCOPY);
909 /* save the background */
910 BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
911 hdcOffScreen, origNewX - origRegX, origNewY - origRegY, SRCCOPY);
912 /* draw the image */
913 ImageList_InternalDragDraw(hdcOffScreen, origNewX - origRegX,
914 origNewY - origRegY);
915 /* draw the update region to the screen */
916 BitBlt(hdcDrag, origRegX, origRegY, sizeRegX, sizeRegY,
917 hdcOffScreen, 0, 0, SRCCOPY);
918
919 DeleteDC(hdcBg);
920 DeleteDC(hdcOffScreen);
921 DeleteObject(hbmOffScreen);
922 ReleaseDC(InternalDrag.hwnd, hdcDrag);
923 }
924
925 /* update the image position */
926 InternalDrag.x = x;
927 InternalDrag.y = y;
928
929 return TRUE;
930 }
931
932
933 /*************************************************************************
934 * ImageList_DragShowNolock [COMCTL32.@]
935 *
936 * Shows or hides the drag image.
937 *
938 * PARAMS
939 * bShow [I] TRUE shows the drag image, FALSE hides it.
940 *
941 * RETURNS
942 * Success: TRUE
943 * Failure: FALSE
944 *
945 * BUGS
946 * The drag image should be drawn semitransparent.
947 */
948
949 BOOL WINAPI
950 ImageList_DragShowNolock (BOOL bShow)
951 {
952 HDC hdcDrag;
953 HDC hdcBg;
954 INT x, y;
955
956 if (!is_valid(InternalDrag.himl))
957 return FALSE;
958
959 TRACE("bShow=0x%X!\n", bShow);
960
961 /* DragImage is already visible/hidden */
962 if ((InternalDrag.bShow && bShow) || (!InternalDrag.bShow && !bShow)) {
963 return FALSE;
964 }
965
966 /* position of the origin of the DragImage */
967 x = InternalDrag.x - InternalDrag.dxHotspot;
968 y = InternalDrag.y - InternalDrag.dyHotspot;
969
970 hdcDrag = GetDCEx (InternalDrag.hwnd, 0,
971 DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
972 if (!hdcDrag) {
973 return FALSE;
974 }
975
976 hdcBg = CreateCompatibleDC(hdcDrag);
977 if (!InternalDrag.hbmBg) {
978 InternalDrag.hbmBg = CreateCompatibleBitmap(hdcDrag,
979 InternalDrag.himl->cx, InternalDrag.himl->cy);
980 }
981 SelectObject(hdcBg, InternalDrag.hbmBg);
982
983 if (bShow) {
984 /* save the background */
985 BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
986 hdcDrag, x, y, SRCCOPY);
987 /* show the image */
988 ImageList_InternalDragDraw(hdcDrag, x, y);
989 } else {
990 /* hide the image */
991 BitBlt(hdcDrag, x, y, InternalDrag.himl->cx, InternalDrag.himl->cy,
992 hdcBg, 0, 0, SRCCOPY);
993 }
994
995 InternalDrag.bShow = !InternalDrag.bShow;
996
997 DeleteDC(hdcBg);
998 ReleaseDC (InternalDrag.hwnd, hdcDrag);
999 return TRUE;
1000 }
1001
1002
1003 /*************************************************************************
1004 * ImageList_Draw [COMCTL32.@]
1005 *
1006 * Draws an image.
1007 *
1008 * PARAMS
1009 * himl [I] handle to image list
1010 * i [I] image index
1011 * hdc [I] handle to device context
1012 * x [I] x position
1013 * y [I] y position
1014 * fStyle [I] drawing flags
1015 *
1016 * RETURNS
1017 * Success: TRUE
1018 * Failure: FALSE
1019 *
1020 * SEE
1021 * ImageList_DrawEx.
1022 */
1023
1024 BOOL WINAPI
1025 ImageList_Draw (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
1026 {
1027 return ImageList_DrawEx (himl, i, hdc, x, y, 0, 0,
1028 CLR_DEFAULT, CLR_DEFAULT, fStyle);
1029 }
1030
1031
1032 /*************************************************************************
1033 * ImageList_DrawEx [COMCTL32.@]
1034 *
1035 * Draws an image and allows to use extended drawing features.
1036 *
1037 * PARAMS
1038 * himl [I] handle to image list
1039 * i [I] image index
1040 * hdc [I] handle to device context
1041 * x [I] X position
1042 * y [I] Y position
1043 * dx [I] X offset
1044 * dy [I] Y offset
1045 * rgbBk [I] background color
1046 * rgbFg [I] foreground color
1047 * fStyle [I] drawing flags
1048 *
1049 * RETURNS
1050 * Success: TRUE
1051 * Failure: FALSE
1052 *
1053 * NOTES
1054 * Calls ImageList_DrawIndirect.
1055 *
1056 * SEE
1057 * ImageList_DrawIndirect.
1058 */
1059
1060 BOOL WINAPI
1061 ImageList_DrawEx (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y,
1062 INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg,
1063 UINT fStyle)
1064 {
1065 IMAGELISTDRAWPARAMS imldp;
1066
1067 ZeroMemory (&imldp, sizeof(imldp));
1068 imldp.cbSize = sizeof(imldp);
1069 imldp.himl = himl;
1070 imldp.i = i;
1071 imldp.hdcDst = hdc,
1072 imldp.x = x;
1073 imldp.y = y;
1074 imldp.cx = dx;
1075 imldp.cy = dy;
1076 imldp.rgbBk = rgbBk;
1077 imldp.rgbFg = rgbFg;
1078 imldp.fStyle = fStyle;
1079
1080 return ImageList_DrawIndirect (&imldp);
1081 }
1082
1083
1084 /*************************************************************************
1085 * ImageList_DrawIndirect [COMCTL32.@]
1086 *
1087 * Draws an image using various parameters specified in pimldp.
1088 *
1089 * PARAMS
1090 * pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
1091 *
1092 * RETURNS
1093 * Success: TRUE
1094 * Failure: FALSE
1095 */
1096
1097 BOOL WINAPI
1098 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
1099 {
1100 INT cx, cy, nOvlIdx;
1101 DWORD fState, dwRop;
1102 UINT fStyle;
1103 COLORREF oldImageBk, oldImageFg;
1104 HDC hImageDC, hImageListDC, hMaskListDC;
1105 HBITMAP hImageBmp, hOldImageBmp, hBlendMaskBmp;
1106 BOOL bIsTransparent, bBlend, bResult = FALSE, bMask;
1107 HIMAGELIST himl;
1108 POINT pt;
1109
1110 if (!pimldp || !(himl = pimldp->himl)) return FALSE;
1111 if (!is_valid(himl)) return FALSE;
1112 if ((pimldp->i < 0) || (pimldp->i >= himl->cCurImage)) return FALSE;
1113
1114 imagelist_point_from_index( himl, pimldp->i, &pt );
1115 pt.x += pimldp->xBitmap;
1116 pt.y += pimldp->yBitmap;
1117
1118 fState = pimldp->cbSize < sizeof(IMAGELISTDRAWPARAMS) ? ILS_NORMAL : pimldp->fState;
1119 fStyle = pimldp->fStyle & ~ILD_OVERLAYMASK;
1120 cx = (pimldp->cx == 0) ? himl->cx : pimldp->cx;
1121 cy = (pimldp->cy == 0) ? himl->cy : pimldp->cy;
1122
1123 bIsTransparent = (fStyle & ILD_TRANSPARENT);
1124 if( pimldp->rgbBk == CLR_NONE )
1125 bIsTransparent = TRUE;
1126 if( ( pimldp->rgbBk == CLR_DEFAULT ) && ( himl->clrBk == CLR_NONE ) )
1127 bIsTransparent = TRUE;
1128 bMask = (himl->flags & ILC_MASK) && (fStyle & ILD_MASK) ;
1129 bBlend = (fStyle & (ILD_BLEND25 | ILD_BLEND50) ) && !bMask;
1130
1131 TRACE("himl(%p) hbmMask(%p) iImage(%d) x(%d) y(%d) cx(%d) cy(%d)\n",
1132 himl, himl->hbmMask, pimldp->i, pimldp->x, pimldp->y, cx, cy);
1133
1134 /* we will use these DCs to access the images and masks in the ImageList */
1135 hImageListDC = himl->hdcImage;
1136 hMaskListDC = himl->hdcMask;
1137
1138 /* these will accumulate the image and mask for the image we're drawing */
1139 hImageDC = CreateCompatibleDC( pimldp->hdcDst );
1140 hImageBmp = CreateCompatibleBitmap( pimldp->hdcDst, cx, cy );
1141 hBlendMaskBmp = bBlend ? CreateBitmap(cx, cy, 1, 1, NULL) : 0;
1142
1143 /* Create a compatible DC. */
1144 if (!hImageListDC || !hImageDC || !hImageBmp ||
1145 (bBlend && !hBlendMaskBmp) || (himl->hbmMask && !hMaskListDC))
1146 goto cleanup;
1147
1148 hOldImageBmp = SelectObject(hImageDC, hImageBmp);
1149
1150 /*
1151 * To obtain a transparent look, background color should be set
1152 * to white and foreground color to black when blting the
1153 * monochrome mask.
1154 */
1155 oldImageFg = SetTextColor( hImageDC, RGB( 0, 0, 0 ) );
1156 oldImageBk = SetBkColor( hImageDC, RGB( 0xff, 0xff, 0xff ) );
1157
1158 /*
1159 * Draw the initial image
1160 */
1161 if( bMask ) {
1162 if (himl->hbmMask) {
1163 HBRUSH hOldBrush;
1164 hOldBrush = SelectObject (hImageDC, CreateSolidBrush (GetTextColor(pimldp->hdcDst)));
1165 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
1166 BitBlt(hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCPAINT);
1167 DeleteObject (SelectObject (hImageDC, hOldBrush));
1168 if( bIsTransparent )
1169 {
1170 BitBlt ( pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hImageDC, 0, 0, SRCAND);
1171 bResult = TRUE;
1172 goto end;
1173 }
1174 } else {
1175 HBRUSH hOldBrush = SelectObject (hImageDC, GetStockObject(BLACK_BRUSH));
1176 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY);
1177 SelectObject(hImageDC, hOldBrush);
1178 }
1179 } else {
1180 /* blend the image with the needed solid background */
1181 COLORREF colour = RGB(0,0,0);
1182 HBRUSH hOldBrush;
1183
1184 if( !bIsTransparent )
1185 {
1186 colour = pimldp->rgbBk;
1187 if( colour == CLR_DEFAULT )
1188 colour = himl->clrBk;
1189 if( colour == CLR_NONE )
1190 colour = GetBkColor(pimldp->hdcDst);
1191 }
1192
1193 hOldBrush = SelectObject (hImageDC, CreateSolidBrush (colour));
1194 PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
1195 if (himl->hbmMask)
1196 {
1197 BitBlt( hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND );
1198 BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCPAINT );
1199 }
1200 else
1201 BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCCOPY);
1202 DeleteObject (SelectObject (hImageDC, hOldBrush));
1203 }
1204
1205 /* Time for blending, if required */
1206 if (bBlend) {
1207 HBRUSH hBlendBrush, hOldBrush;
1208 COLORREF clrBlend = pimldp->rgbFg;
1209 HDC hBlendMaskDC = hImageListDC;
1210 HBITMAP hOldBitmap;
1211
1212 /* Create the blend Mask */
1213 hOldBitmap = SelectObject(hBlendMaskDC, hBlendMaskBmp);
1214 hBlendBrush = fStyle & ILD_BLEND50 ? himl->hbrBlend50 : himl->hbrBlend25;
1215 hOldBrush = SelectObject(hBlendMaskDC, hBlendBrush);
1216 PatBlt(hBlendMaskDC, 0, 0, cx, cy, PATCOPY);
1217 SelectObject(hBlendMaskDC, hOldBrush);
1218
1219 /* Modify the blend mask if an Image Mask exist */
1220 if(himl->hbmMask) {
1221 BitBlt(hBlendMaskDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, 0x220326); /* NOTSRCAND */
1222 BitBlt(hBlendMaskDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, NOTSRCCOPY);
1223 }
1224
1225 /* now apply blend to the current image given the BlendMask */
1226 if (clrBlend == CLR_DEFAULT) clrBlend = GetSysColor (COLOR_HIGHLIGHT);
1227 else if (clrBlend == CLR_NONE) clrBlend = GetTextColor (pimldp->hdcDst);
1228 hOldBrush = SelectObject (hImageDC, CreateSolidBrush(clrBlend));
1229 BitBlt (hImageDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, 0xB8074A); /* PSDPxax */
1230 DeleteObject(SelectObject(hImageDC, hOldBrush));
1231 SelectObject(hBlendMaskDC, hOldBitmap);
1232 }
1233
1234 /* Now do the overlay image, if any */
1235 nOvlIdx = (pimldp->fStyle & ILD_OVERLAYMASK) >> 8;
1236 if ( (nOvlIdx >= 1) && (nOvlIdx <= MAX_OVERLAYIMAGE)) {
1237 nOvlIdx = himl->nOvlIdx[nOvlIdx - 1];
1238 if ((nOvlIdx >= 0) && (nOvlIdx < himl->cCurImage)) {
1239 POINT ptOvl;
1240 imagelist_point_from_index( himl, nOvlIdx, &ptOvl );
1241 ptOvl.x += pimldp->xBitmap;
1242 if (himl->hbmMask && !(fStyle & ILD_IMAGE))
1243 BitBlt (hImageDC, 0, 0, cx, cy, hMaskListDC, ptOvl.x, ptOvl.y, SRCAND);
1244 BitBlt (hImageDC, 0, 0, cx, cy, hImageListDC, ptOvl.x, ptOvl.y, SRCPAINT);
1245 }
1246 }
1247
1248 if (fState & ILS_SATURATE) FIXME("ILS_SATURATE: unimplemented!\n");
1249 if (fState & ILS_GLOW) FIXME("ILS_GLOW: unimplemented!\n");
1250 if (fState & ILS_SHADOW) FIXME("ILS_SHADOW: unimplemented!\n");
1251 if (fState & ILS_ALPHA) FIXME("ILS_ALPHA: unimplemented!\n");
1252
1253 if (fStyle & ILD_PRESERVEALPHA) FIXME("ILD_PRESERVEALPHA: unimplemented!\n");
1254 if (fStyle & ILD_SCALE) FIXME("ILD_SCALE: unimplemented!\n");
1255 if (fStyle & ILD_DPISCALE) FIXME("ILD_DPISCALE: unimplemented!\n");
1256
1257 /* now copy the image to the screen */
1258 dwRop = SRCCOPY;
1259 if (himl->hbmMask && bIsTransparent ) {
1260 COLORREF oldDstFg = SetTextColor(pimldp->hdcDst, RGB( 0, 0, 0 ) );
1261 COLORREF oldDstBk = SetBkColor(pimldp->hdcDst, RGB( 0xff, 0xff, 0xff ));
1262 BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND);
1263 SetBkColor(pimldp->hdcDst, oldDstBk);
1264 SetTextColor(pimldp->hdcDst, oldDstFg);
1265 dwRop = SRCPAINT;
1266 }
1267 if (fStyle & ILD_ROP) dwRop = pimldp->dwRop;
1268 BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy, hImageDC, 0, 0, dwRop);
1269
1270 bResult = TRUE;
1271 end:
1272 /* cleanup the mess */
1273 SetBkColor(hImageDC, oldImageBk);
1274 SetTextColor(hImageDC, oldImageFg);
1275 SelectObject(hImageDC, hOldImageBmp);
1276 cleanup:
1277 DeleteObject(hBlendMaskBmp);
1278 DeleteObject(hImageBmp);
1279 DeleteDC(hImageDC);
1280
1281 return bResult;
1282 }
1283
1284
1285 /*************************************************************************
1286 * ImageList_Duplicate [COMCTL32.@]
1287 *
1288 * Duplicates an image list.
1289 *
1290 * PARAMS
1291 * himlSrc [I] source image list handle
1292 *
1293 * RETURNS
1294 * Success: Handle of duplicated image list.
1295 * Failure: NULL
1296 */
1297
1298 HIMAGELIST WINAPI
1299 ImageList_Duplicate (HIMAGELIST himlSrc)
1300 {
1301 HIMAGELIST himlDst;
1302
1303 if (!is_valid(himlSrc)) {
1304 ERR("Invalid image list handle!\n");
1305 return NULL;
1306 }
1307
1308 himlDst = ImageList_Create (himlSrc->cx, himlSrc->cy, himlSrc->flags,
1309 himlSrc->cInitial, himlSrc->cGrow);
1310
1311 if (himlDst)
1312 {
1313 SIZE sz;
1314
1315 imagelist_get_bitmap_size(himlSrc, himlSrc->cCurImage, himlSrc->cx, &sz);
1316 BitBlt (himlDst->hdcImage, 0, 0, sz.cx, sz.cy,
1317 himlSrc->hdcImage, 0, 0, SRCCOPY);
1318
1319 if (himlDst->hbmMask)
1320 BitBlt (himlDst->hdcMask, 0, 0, sz.cx, sz.cy,
1321 himlSrc->hdcMask, 0, 0, SRCCOPY);
1322
1323 himlDst->cCurImage = himlSrc->cCurImage;
1324 himlDst->cMaxImage = himlSrc->cMaxImage;
1325 }
1326 return himlDst;
1327 }
1328
1329
1330 /*************************************************************************
1331 * ImageList_EndDrag [COMCTL32.@]
1332 *
1333 * Finishes a drag operation.
1334 *
1335 * PARAMS
1336 * no Parameters
1337 *
1338 * RETURNS
1339 * Success: TRUE
1340 * Failure: FALSE
1341 */
1342
1343 VOID WINAPI
1344 ImageList_EndDrag (void)
1345 {
1346 /* cleanup the InternalDrag struct */
1347 InternalDrag.hwnd = 0;
1348 ImageList_Destroy (InternalDrag.himl);
1349 InternalDrag.himl = 0;
1350 InternalDrag.x= 0;
1351 InternalDrag.y= 0;
1352 InternalDrag.dxHotspot = 0;
1353 InternalDrag.dyHotspot = 0;
1354 InternalDrag.bShow = FALSE;
1355 DeleteObject(InternalDrag.hbmBg);
1356 InternalDrag.hbmBg = 0;
1357 }
1358
1359
1360 /*************************************************************************
1361 * ImageList_GetBkColor [COMCTL32.@]
1362 *
1363 * Returns the background color of an image list.
1364 *
1365 * PARAMS
1366 * himl [I] Image list handle.
1367 *
1368 * RETURNS
1369 * Success: background color
1370 * Failure: CLR_NONE
1371 */
1372
1373 COLORREF WINAPI
1374 ImageList_GetBkColor (HIMAGELIST himl)
1375 {
1376 return himl ? himl->clrBk : CLR_NONE;
1377 }
1378
1379
1380 /*************************************************************************
1381 * ImageList_GetDragImage [COMCTL32.@]
1382 *
1383 * Returns the handle to the internal drag image list.
1384 *
1385 * PARAMS
1386 * ppt [O] Pointer to the drag position. Can be NULL.
1387 * pptHotspot [O] Pointer to the position of the hot spot. Can be NULL.
1388 *
1389 * RETURNS
1390 * Success: Handle of the drag image list.
1391 * Failure: NULL.
1392 */
1393
1394 HIMAGELIST WINAPI
1395 ImageList_GetDragImage (POINT *ppt, POINT *pptHotspot)
1396 {
1397 if (is_valid(InternalDrag.himl)) {
1398 if (ppt) {
1399 ppt->x = InternalDrag.x;
1400 ppt->y = InternalDrag.y;
1401 }
1402 if (pptHotspot) {
1403 pptHotspot->x = InternalDrag.dxHotspot;
1404 pptHotspot->y = InternalDrag.dyHotspot;
1405 }
1406 return (InternalDrag.himl);
1407 }
1408
1409 return NULL;
1410 }
1411
1412
1413 /*************************************************************************
1414 * ImageList_GetFlags [COMCTL32.@]
1415 *
1416 * Gets the flags of the specified image list.
1417 *
1418 * PARAMS
1419 * himl [I] Handle to image list
1420 *
1421 * RETURNS
1422 * Image list flags.
1423 *
1424 * BUGS
1425 * Stub.
1426 */
1427
1428 DWORD WINAPI
1429 ImageList_GetFlags(HIMAGELIST himl)
1430 {
1431 TRACE("%p\n", himl);
1432
1433 return is_valid(himl) ? himl->flags : 0;
1434 }
1435
1436
1437 /*************************************************************************
1438 * ImageList_GetIcon [COMCTL32.@]
1439 *
1440 * Creates an icon from a masked image of an image list.
1441 *
1442 * PARAMS
1443 * himl [I] handle to image list
1444 * i [I] image index
1445 * flags [I] drawing style flags
1446 *
1447 * RETURNS
1448 * Success: icon handle
1449 * Failure: NULL
1450 */
1451
1452 HICON WINAPI
1453 ImageList_GetIcon (HIMAGELIST himl, INT i, UINT fStyle)
1454 {
1455 ICONINFO ii;
1456 HICON hIcon;
1457 HBITMAP hOldDstBitmap;
1458 HDC hdcDst;
1459 POINT pt;
1460
1461 TRACE("%p %d %d\n", himl, i, fStyle);
1462 if (!is_valid(himl) || (i < 0) || (i >= himl->cCurImage)) return NULL;
1463
1464 ii.fIcon = TRUE;
1465 ii.xHotspot = 0;
1466 ii.yHotspot = 0;
1467
1468 /* create colour bitmap */
1469 hdcDst = GetDC(0);
1470 ii.hbmColor = CreateCompatibleBitmap(hdcDst, himl->cx, himl->cy);
1471 ReleaseDC(0, hdcDst);
1472
1473 hdcDst = CreateCompatibleDC(0);
1474
1475 imagelist_point_from_index( himl, i, &pt );
1476
1477 /* draw mask*/
1478 ii.hbmMask = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
1479 hOldDstBitmap = SelectObject (hdcDst, ii.hbmMask);
1480 if (himl->hbmMask) {
1481 BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1482 himl->hdcMask, pt.x, pt.y, SRCCOPY);
1483 }
1484 else
1485 PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
1486
1487 /* draw image*/
1488 SelectObject (hdcDst, ii.hbmColor);
1489 BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1490 himl->hdcImage, pt.x, pt.y, SRCCOPY);
1491
1492 /*
1493 * CreateIconIndirect requires us to deselect the bitmaps from
1494 * the DCs before calling
1495 */
1496 SelectObject(hdcDst, hOldDstBitmap);
1497
1498 hIcon = CreateIconIndirect (&ii);
1499
1500 DeleteObject (ii.hbmMask);
1501 DeleteObject (ii.hbmColor);
1502 DeleteDC (hdcDst);
1503
1504 return hIcon;
1505 }
1506
1507
1508 /*************************************************************************
1509 * ImageList_GetIconSize [COMCTL32.@]
1510 *
1511 * Retrieves the size of an image in an image list.
1512 *
1513 * PARAMS
1514 * himl [I] handle to image list
1515 * cx [O] pointer to the image width.
1516 * cy [O] pointer to the image height.
1517 *
1518 * RETURNS
1519 * Success: TRUE
1520 * Failure: FALSE
1521 *
1522 * NOTES
1523 * All images in an image list have the same size.
1524 */
1525
1526 BOOL WINAPI
1527 ImageList_GetIconSize (HIMAGELIST himl, INT *cx, INT *cy)
1528 {
1529 if (!is_valid(himl))
1530 return FALSE;
1531 if ((himl->cx <= 0) || (himl->cy <= 0))
1532 return FALSE;
1533
1534 if (cx)
1535 *cx = himl->cx;
1536 if (cy)
1537 *cy = himl->cy;
1538
1539 return TRUE;
1540 }
1541
1542
1543 /*************************************************************************
1544 * ImageList_GetImageCount [COMCTL32.@]
1545 *
1546 * Returns the number of images in an image list.
1547 *
1548 * PARAMS
1549 * himl [I] handle to image list
1550 *
1551 * RETURNS
1552 * Success: Number of images.
1553 * Failure: 0
1554 */
1555
1556 INT WINAPI
1557 ImageList_GetImageCount (HIMAGELIST himl)
1558 {
1559 if (!is_valid(himl))
1560 return 0;
1561
1562 return himl->cCurImage;
1563 }
1564
1565
1566 /*************************************************************************
1567 * ImageList_GetImageInfo [COMCTL32.@]
1568 *
1569 * Returns information about an image in an image list.
1570 *
1571 * PARAMS
1572 * himl [I] handle to image list
1573 * i [I] image index
1574 * pImageInfo [O] pointer to the image information
1575 *
1576 * RETURNS
1577 * Success: TRUE
1578 * Failure: FALSE
1579 */
1580
1581 BOOL WINAPI
1582 ImageList_GetImageInfo (HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
1583 {
1584 POINT pt;
1585
1586 if (!is_valid(himl) || (pImageInfo == NULL))
1587 return FALSE;
1588 if ((i < 0) || (i >= himl->cCurImage))
1589 return FALSE;
1590
1591 pImageInfo->hbmImage = himl->hbmImage;
1592 pImageInfo->hbmMask = himl->hbmMask;
1593
1594 imagelist_point_from_index( himl, i, &pt );
1595 pImageInfo->rcImage.top = pt.y;
1596 pImageInfo->rcImage.bottom = pt.y + himl->cy;
1597 pImageInfo->rcImage.left = pt.x;
1598 pImageInfo->rcImage.right = pt.x + himl->cx;
1599
1600 return TRUE;
1601 }
1602
1603
1604 /*************************************************************************
1605 * ImageList_GetImageRect [COMCTL32.@]
1606 *
1607 * Retrieves the rectangle of the specified image in an image list.
1608 *
1609 * PARAMS
1610 * himl [I] handle to image list
1611 * i [I] image index
1612 * lpRect [O] pointer to the image rectangle
1613 *
1614 * RETURNS
1615 * Success: TRUE
1616 * Failure: FALSE
1617 *
1618 * NOTES
1619 * This is an UNDOCUMENTED function!!!
1620 */
1621
1622 BOOL WINAPI
1623 ImageList_GetImageRect (HIMAGELIST himl, INT i, LPRECT lpRect)
1624 {
1625 POINT pt;
1626
1627 if (!is_valid(himl) || (lpRect == NULL))
1628 return FALSE;
1629 if ((i < 0) || (i >= himl->cCurImage))
1630 return FALSE;
1631
1632 imagelist_point_from_index( himl, i, &pt );
1633 lpRect->left = pt.x;
1634 lpRect->top = pt.y;
1635 lpRect->right = pt.x + himl->cx;
1636 lpRect->bottom = pt.y + himl->cy;
1637
1638 return TRUE;
1639 }
1640
1641
1642 /*************************************************************************
1643 * ImageList_LoadImage [COMCTL32.@]
1644 * ImageList_LoadImageA [COMCTL32.@]
1645 *
1646 * Creates an image list from a bitmap, icon or cursor.
1647 *
1648 * See ImageList_LoadImageW.
1649 */
1650
1651 HIMAGELIST WINAPI
1652 ImageList_LoadImageA (HINSTANCE hi, LPCSTR lpbmp, INT cx, INT cGrow,
1653 COLORREF clrMask, UINT uType, UINT uFlags)
1654 {
1655 HIMAGELIST himl;
1656 LPWSTR lpbmpW;
1657 DWORD len;
1658
1659 if (!HIWORD(lpbmp))
1660 return ImageList_LoadImageW(hi, (LPCWSTR)lpbmp, cx, cGrow, clrMask,
1661 uType, uFlags);
1662
1663 len = MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, NULL, 0);
1664 lpbmpW = Alloc(len * sizeof(WCHAR));
1665 MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, lpbmpW, len);
1666
1667 himl = ImageList_LoadImageW(hi, lpbmpW, cx, cGrow, clrMask, uType, uFlags);
1668 Free (lpbmpW);
1669 return himl;
1670 }
1671
1672
1673 /*************************************************************************
1674 * ImageList_LoadImageW [COMCTL32.@]
1675 *
1676 * Creates an image list from a bitmap, icon or cursor.
1677 *
1678 * PARAMS
1679 * hi [I] instance handle
1680 * lpbmp [I] name or id of the image
1681 * cx [I] width of each image
1682 * cGrow [I] number of images to expand
1683 * clrMask [I] mask color
1684 * uType [I] type of image to load
1685 * uFlags [I] loading flags
1686 *
1687 * RETURNS
1688 * Success: handle to the loaded image list
1689 * Failure: NULL
1690 *
1691 * SEE
1692 * LoadImage ()
1693 */
1694
1695 HIMAGELIST WINAPI
1696 ImageList_LoadImageW (HINSTANCE hi, LPCWSTR lpbmp, INT cx, INT cGrow,
1697 COLORREF clrMask, UINT uType, UINT uFlags)
1698 {
1699 HIMAGELIST himl = NULL;
1700 HANDLE handle;
1701 INT nImageCount;
1702
1703 handle = LoadImageW (hi, lpbmp, uType, 0, 0, uFlags);
1704 if (!handle) {
1705 WARN("Couldn't load image\n");
1706 return NULL;
1707 }
1708
1709 if (uType == IMAGE_BITMAP) {
1710 BITMAP bmp;
1711 GetObjectW (handle, sizeof(BITMAP), &bmp);
1712
1713 /* To match windows behavior, if cx is set to zero and
1714 the flag DI_DEFAULTSIZE is specified, cx becomes the
1715 system metric value for icons. If the flag is not specified
1716 the function sets the size to the height of the bitmap */
1717 if (cx == 0)
1718 {
1719 if (uFlags & DI_DEFAULTSIZE)
1720 cx = GetSystemMetrics (SM_CXICON);
1721 else
1722 cx = bmp.bmHeight;
1723 }
1724
1725 nImageCount = bmp.bmWidth / cx;
1726
1727 himl = ImageList_Create (cx, bmp.bmHeight, ILC_MASK | ILC_COLOR,
1728 nImageCount, cGrow);
1729 if (!himl) {
1730 DeleteObject (handle);
1731 return NULL;
1732 }
1733 ImageList_AddMasked (himl, handle, clrMask);
1734 }
1735 else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
1736 ICONINFO ii;
1737 BITMAP bmp;
1738
1739 GetIconInfo (handle, &ii);
1740 GetObjectW (ii.hbmColor, sizeof(BITMAP), &bmp);
1741 himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
1742 ILC_MASK | ILC_COLOR, 1, cGrow);
1743 if (!himl) {
1744 DeleteObject (ii.hbmColor);
1745 DeleteObject (ii.hbmMask);
1746 DeleteObject (handle);
1747 return NULL;
1748 }
1749 ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
1750 DeleteObject (ii.hbmColor);
1751 DeleteObject (ii.hbmMask);
1752 }
1753
1754 DeleteObject (handle);
1755
1756 return himl;
1757 }
1758
1759
1760 /*************************************************************************
1761 * ImageList_Merge [COMCTL32.@]
1762 *
1763 * Create an image list containing a merged image from two image lists.
1764 *
1765 * PARAMS
1766 * himl1 [I] handle to first image list
1767 * i1 [I] first image index
1768 * himl2 [I] handle to second image list
1769 * i2 [I] second image index
1770 * dx [I] X offset of the second image relative to the first.
1771 * dy [I] Y offset of the second image relative to the first.
1772 *
1773 * RETURNS
1774 * Success: The newly created image list. It contains a single image
1775 * consisting of the second image merged with the first.
1776 * Failure: NULL, if either himl1 or himl2 are invalid.
1777 *
1778 * NOTES
1779 * - The returned image list should be deleted by the caller using
1780 * ImageList_Destroy() when it is no longer required.
1781 * - If either i1 or i2 are not valid image indices they will be treated
1782 * as a blank image.
1783 */
1784 HIMAGELIST WINAPI
1785 ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2,
1786 INT dx, INT dy)
1787 {
1788 HIMAGELIST himlDst = NULL;
1789 INT cxDst, cyDst;
1790 INT xOff1, yOff1, xOff2, yOff2;
1791 POINT pt1, pt2;
1792
1793 TRACE("(himl1=%p i1=%d himl2=%p i2=%d dx=%d dy=%d)\n", himl1, i1, himl2,
1794 i2, dx, dy);
1795
1796 if (!is_valid(himl1) || !is_valid(himl2))
1797 return NULL;
1798
1799 if (dx > 0) {
1800 cxDst = max (himl1->cx, dx + himl2->cx);
1801 xOff1 = 0;
1802 xOff2 = dx;
1803 }
1804 else if (dx < 0) {
1805 cxDst = max (himl2->cx, himl1->cx - dx);
1806 xOff1 = -dx;
1807 xOff2 = 0;
1808 }
1809 else {
1810 cxDst = max (himl1->cx, himl2->cx);
1811 xOff1 = 0;
1812 xOff2 = 0;
1813 }
1814
1815 if (dy > 0) {
1816 cyDst = max (himl1->cy, dy + himl2->cy);
1817 yOff1 = 0;
1818 yOff2 = dy;
1819 }
1820 else if (dy < 0) {
1821 cyDst = max (himl2->cy, himl1->cy - dy);
1822 yOff1 = -dy;
1823 yOff2 = 0;
1824 }
1825 else {
1826 cyDst = max (himl1->cy, himl2->cy);
1827 yOff1 = 0;
1828 yOff2 = 0;
1829 }
1830
1831 himlDst = ImageList_Create (cxDst, cyDst, ILC_MASK | ILC_COLOR, 1, 1);
1832
1833 if (himlDst)
1834 {
1835 imagelist_point_from_index( himl1, i1, &pt1 );
1836 imagelist_point_from_index( himl1, i2, &pt2 );
1837
1838 /* copy image */
1839 BitBlt (himlDst->hdcImage, 0, 0, cxDst, cyDst, himl1->hdcImage, 0, 0, BLACKNESS);
1840 if (i1 >= 0 && i1 < himl1->cCurImage)
1841 BitBlt (himlDst->hdcImage, xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcImage, pt1.x, pt1.y, SRCCOPY);
1842 if (i2 >= 0 && i2 < himl2->cCurImage)
1843 {
1844 BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask , pt2.x, pt2.y, SRCAND);
1845 BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcImage, pt2.x, pt2.y, SRCPAINT);
1846 }
1847
1848 /* copy mask */
1849 BitBlt (himlDst->hdcMask, 0, 0, cxDst, cyDst, himl1->hdcMask, 0, 0, WHITENESS);
1850 if (i1 >= 0 && i1 < himl1->cCurImage)
1851 BitBlt (himlDst->hdcMask, xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcMask, pt1.x, pt1.y, SRCCOPY);
1852 if (i2 >= 0 && i2 < himl2->cCurImage)
1853 BitBlt (himlDst->hdcMask, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask, pt2.x, pt2.y, SRCAND);
1854
1855 himlDst->cCurImage = 1;
1856 }
1857
1858 return himlDst;
1859 }
1860
1861
1862 /***********************************************************************
1863 * DIB_GetDIBWidthBytes
1864 *
1865 * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
1866 */
1867 static int DIB_GetDIBWidthBytes( int width, int depth )
1868 {
1869 int words;
1870
1871 switch(depth)
1872 {
1873 case 1: words = (width + 31) / 32; break;
1874 case 4: words = (width + 7) / 8; break;
1875 case 8: words = (width + 3) / 4; break;
1876 case 15:
1877 case 16: words = (width + 1) / 2; break;
1878 case 24: words = (width * 3 + 3)/4; break;
1879
1880 default:
1881 WARN("(%d): Unsupported depth\n", depth );
1882 /* fall through */
1883 case 32:
1884 words = width;
1885 break;
1886 }
1887 return 4 * words;
1888 }
1889
1890 /***********************************************************************
1891 * DIB_GetDIBImageBytes
1892 *
1893 * Return the number of bytes used to hold the image in a DIB bitmap.
1894 */
1895 static int DIB_GetDIBImageBytes( int width, int height, int depth )
1896 {
1897 return DIB_GetDIBWidthBytes( width, depth ) * abs( height );
1898 }
1899
1900
1901 /* helper for ImageList_Read, see comments below */
1902 static BOOL _read_bitmap(HDC hdcIml, LPSTREAM pstm)
1903 {
1904 BITMAPFILEHEADER bmfh;
1905 int bitsperpixel, palspace;
1906 char bmi_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
1907 LPBITMAPINFO bmi = (LPBITMAPINFO)bmi_buf;
1908 int result = FALSE;
1909 LPBYTE bits = NULL;
1910
1911 if (FAILED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL)))
1912 return FALSE;
1913
1914 if (bmfh.bfType != (('M'<<8)|'B'))
1915 return FALSE;
1916
1917 if (FAILED(IStream_Read ( pstm, &bmi->bmiHeader, sizeof(bmi->bmiHeader), NULL)))
1918 return FALSE;
1919
1920 if ((bmi->bmiHeader.biSize != sizeof(bmi->bmiHeader)))
1921 return FALSE;
1922
1923 TRACE("width %u, height %u, planes %u, bpp %u\n",
1924 bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight,
1925 bmi->bmiHeader.biPlanes, bmi->bmiHeader.biBitCount);
1926
1927 bitsperpixel = bmi->bmiHeader.biPlanes * bmi->bmiHeader.biBitCount;
1928 if (bitsperpixel<=8)
1929 palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
1930 else
1931 palspace = 0;
1932
1933 bmi->bmiHeader.biSizeImage = DIB_GetDIBImageBytes(bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight, bitsperpixel);
1934
1935 /* read the palette right after the end of the bitmapinfoheader */
1936 if (palspace && FAILED(IStream_Read(pstm, bmi->bmiColors, palspace, NULL)))
1937 goto error;
1938
1939 bits = Alloc(bmi->bmiHeader.biSizeImage);
1940 if (!bits)
1941 goto error;
1942 if (FAILED(IStream_Read(pstm, bits, bmi->bmiHeader.biSizeImage, NULL)))
1943 goto error;
1944
1945 if (!StretchDIBits(hdcIml, 0, 0, bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight,
1946 0, 0, bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight,
1947 bits, bmi, DIB_RGB_COLORS, SRCCOPY))
1948 goto error;
1949 result = TRUE;
1950
1951 error:
1952 Free(bits);
1953 return result;
1954 }
1955
1956 /*************************************************************************
1957 * ImageList_Read [COMCTL32.@]
1958 *
1959 * Reads an image list from a stream.
1960 *
1961 * PARAMS
1962 * pstm [I] pointer to a stream
1963 *
1964 * RETURNS
1965 * Success: handle to image list
1966 * Failure: NULL
1967 *
1968 * The format is like this:
1969 * ILHEAD ilheadstruct;
1970 *
1971 * for the color image part:
1972 * BITMAPFILEHEADER bmfh;
1973 * BITMAPINFOHEADER bmih;
1974 * only if it has a palette:
1975 * RGBQUAD rgbs[nr_of_paletted_colors];
1976 *
1977 * BYTE colorbits[imagesize];
1978 *
1979 * the following only if the ILC_MASK bit is set in ILHEAD.ilFlags:
1980 * BITMAPFILEHEADER bmfh_mask;
1981 * BITMAPINFOHEADER bmih_mask;
1982 * only if it has a palette (it usually does not):
1983 * RGBQUAD rgbs[nr_of_paletted_colors];
1984 *
1985 * BYTE maskbits[imagesize];
1986 */
1987 HIMAGELIST WINAPI ImageList_Read (LPSTREAM pstm)
1988 {
1989 ILHEAD ilHead;
1990 HIMAGELIST himl;
1991 int i;
1992
1993 TRACE("%p\n", pstm);
1994
1995 if (FAILED(IStream_Read (pstm, &ilHead, sizeof(ILHEAD), NULL)))
1996 return NULL;
1997 if (ilHead.usMagic != (('L' << 8) | 'I'))
1998 return NULL;
1999 if (ilHead.usVersion != 0x101) /* probably version? */
2000 return NULL;
2001
2002 TRACE("cx %u, cy %u, flags 0x%04x, cCurImage %u, cMaxImage %u\n",
2003 ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
2004
2005 himl = ImageList_Create(ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
2006 if (!himl)
2007 return NULL;
2008
2009 if (!_read_bitmap(himl->hdcImage, pstm))
2010 {
2011 WARN("failed to read bitmap from stream\n");
2012 return NULL;
2013 }
2014 if (ilHead.flags & ILC_MASK)
2015 {
2016 if (!_read_bitmap(himl->hdcMask, pstm))
2017 {
2018 WARN("failed to read mask bitmap from stream\n");
2019 return NULL;
2020 }
2021 }
2022
2023 himl->cCurImage = ilHead.cCurImage;
2024 himl->cMaxImage = ilHead.cMaxImage;
2025
2026 ImageList_SetBkColor(himl,ilHead.bkcolor);
2027 for (i=0;i<4;i++)
2028 ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
2029 return himl;
2030 }
2031
2032
2033 /*************************************************************************
2034 * ImageList_Remove [COMCTL32.@]
2035 *
2036 * Removes an image from an image list
2037 *
2038 * PARAMS
2039 * himl [I] image list handle
2040 * i [I] image index
2041 *
2042 * RETURNS
2043 * Success: TRUE
2044 * Failure: FALSE
2045 *
2046 * FIXME: as the image list storage test shows, native comctl32 simply shifts
2047 * images without creating a new bitmap.
2048 */
2049 BOOL WINAPI
2050 ImageList_Remove (HIMAGELIST himl, INT i)
2051 {
2052 HBITMAP hbmNewImage, hbmNewMask;
2053 HDC hdcBmp;
2054 SIZE sz;
2055
2056 TRACE("(himl=%p i=%d)\n", himl, i);
2057
2058 if (!is_valid(himl)) {
2059 ERR("Invalid image list handle!\n");
2060 return FALSE;
2061 }
2062
2063 if ((i < -1) || (i >= himl->cCurImage)) {
2064 TRACE("index out of range! %d\n", i);
2065 return FALSE;
2066 }
2067
2068 if (i == -1) {
2069 INT nCount;
2070
2071 /* remove all */
2072 if (himl->cCurImage == 0) {
2073 /* remove all on empty ImageList is allowed */
2074 TRACE("remove all on empty ImageList!\n");
2075 return TRUE;
2076 }
2077
2078 himl->cMaxImage = himl->cInitial + himl->cGrow - 1;
2079 himl->cCurImage = 0;
2080 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
2081 himl->nOvlIdx[nCount] = -1;
2082
2083 hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage, himl->cx);
2084 SelectObject (himl->hdcImage, hbmNewImage);
2085 DeleteObject (himl->hbmImage);
2086 himl->hbmImage = hbmNewImage;
2087
2088 if (himl->hbmMask) {
2089
2090 imagelist_get_bitmap_size(himl, himl->cMaxImage, himl->cx, &sz);
2091 hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2092 SelectObject (himl->hdcMask, hbmNewMask);
2093 DeleteObject (himl->hbmMask);
2094 himl->hbmMask = hbmNewMask;
2095 }
2096 }
2097 else {
2098 /* delete one image */
2099 TRACE("Remove single image! %d\n", i);
2100
2101 /* create new bitmap(s) */
2102 TRACE(" - Number of images: %d / %d (Old/New)\n",
2103 himl->cCurImage, himl->cCurImage - 1);
2104
2105 hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage, himl->cx);
2106
2107 imagelist_get_bitmap_size(himl, himl->cMaxImage, himl->cx, &sz );
2108 if (himl->hbmMask)
2109 hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2110 else
2111 hbmNewMask = 0; /* Just to keep compiler happy! */
2112
2113 hdcBmp = CreateCompatibleDC (0);
2114
2115 /* copy all images and masks prior to the "removed" image */
2116 if (i > 0) {
2117 TRACE("Pre image copy: Copy %d images\n", i);
2118
2119 SelectObject (hdcBmp, hbmNewImage);
2120 imagelist_copy_images( himl, himl->hdcImage, hdcBmp, 0, i, 0 );
2121
2122 if (himl->hbmMask) {
2123 SelectObject (hdcBmp, hbmNewMask);
2124 imagelist_copy_images( himl, himl->hdcMask, hdcBmp, 0, i, 0 );
2125 }
2126 }
2127
2128 /* copy all images and masks behind the removed image */
2129 if (i < himl->cCurImage - 1) {
2130 TRACE("Post image copy!\n");
2131
2132 SelectObject (hdcBmp, hbmNewImage);
2133 imagelist_copy_images( himl, himl->hdcImage, hdcBmp, i + 1,
2134 (himl->cCurImage - i), i );
2135
2136 if (himl->hbmMask) {
2137 SelectObject (hdcBmp, hbmNewMask);
2138 imagelist_copy_images( himl, himl->hdcMask, hdcBmp, i + 1,
2139 (himl->cCurImage - i), i );
2140 }
2141 }
2142
2143 DeleteDC (hdcBmp);
2144
2145 /* delete old images and insert new ones */
2146 SelectObject (himl->hdcImage, hbmNewImage);
2147 DeleteObject (himl->hbmImage);
2148 himl->hbmImage = hbmNewImage;
2149 if (himl->hbmMask) {
2150 SelectObject (himl->hdcMask, hbmNewMask);
2151 DeleteObject (himl->hbmMask);
2152 himl->hbmMask = hbmNewMask;
2153 }
2154
2155 himl->cCurImage--;
2156 }
2157
2158 return TRUE;
2159 }
2160
2161
2162 /*************************************************************************
2163 * ImageList_Replace [COMCTL32.@]
2164 *
2165 * Replaces an image in an image list with a new image.
2166 *
2167 * PARAMS
2168 * himl [I] handle to image list
2169 * i [I] image index
2170 * hbmImage [I] handle to image bitmap
2171 * hbmMask [I] handle to mask bitmap. Can be NULL.
2172 *
2173 * RETURNS
2174 * Success: TRUE
2175 * Failure: FALSE
2176 */
2177
2178 BOOL WINAPI
2179 ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage,
2180 HBITMAP hbmMask)
2181 {
2182 HDC hdcImage;
2183 BITMAP bmp;
2184 HBITMAP hOldBitmap;
2185 POINT pt;
2186
2187 TRACE("%p %d %p %p\n", himl, i, hbmImage, hbmMask);
2188
2189 if (!is_valid(himl)) {
2190 ERR("Invalid image list handle!\n");
2191 return FALSE;
2192 }
2193
2194 if ((i >= himl->cMaxImage) || (i < 0)) {
2195 ERR("Invalid image index!\n");
2196 return FALSE;
2197 }
2198
2199 if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
2200 return FALSE;
2201
2202 hdcImage = CreateCompatibleDC (0);
2203
2204 /* Replace Image */
2205 hOldBitmap = SelectObject (hdcImage, hbmImage);
2206
2207 imagelist_point_from_index(himl, i, &pt);
2208 StretchBlt (himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
2209 hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2210
2211 if (himl->hbmMask)
2212 {
2213 HDC hdcTemp;
2214 HBITMAP hOldBitmapTemp;
2215
2216 hdcTemp = CreateCompatibleDC(0);
2217 hOldBitmapTemp = SelectObject(hdcTemp, hbmMask);
2218
2219 StretchBlt (himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
2220 hdcTemp, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2221 SelectObject(hdcTemp, hOldBitmapTemp);
2222 DeleteDC(hdcTemp);
2223
2224 /* Remove the background from the image
2225 */
2226 BitBlt (himl->hdcImage, pt.x, pt.y, bmp.bmWidth, bmp.bmHeight,
2227 himl->hdcMask, pt.x, pt.y, 0x220326); /* NOTSRCAND */
2228 }
2229
2230 SelectObject (hdcImage, hOldBitmap);
2231 DeleteDC (hdcImage);
2232
2233 return TRUE;
2234 }
2235
2236
2237 /*************************************************************************
2238 * ImageList_ReplaceIcon [COMCTL32.@]
2239 *
2240 * Replaces an image in an image list using an icon.
2241 *
2242 * PARAMS
2243 * himl [I] handle to image list
2244 * i [I] image index
2245 * hIcon [I] handle to icon
2246 *
2247 * RETURNS
2248 * Success: index of the replaced image
2249 * Failure: -1
2250 */
2251
2252 INT WINAPI
2253 ImageList_ReplaceIcon (HIMAGELIST himl, INT nIndex, HICON hIcon)
2254 {
2255 HDC hdcImage;
2256 HICON hBestFitIcon;
2257 HBITMAP hbmOldSrc;
2258 ICONINFO ii;
2259 BITMAP bmp;
2260 BOOL ret;
2261 POINT pt;
2262
2263 TRACE("(%p %d %p)\n", himl, nIndex, hIcon);
2264
2265 if (!is_valid(himl)) {
2266 ERR("invalid image list\n");
2267 return -1;
2268 }
2269 if ((nIndex >= himl->cMaxImage) || (nIndex < -1)) {
2270 ERR("invalid image index %d / %d\n", nIndex, himl->cMaxImage);
2271 return -1;
2272 }
2273
2274 hBestFitIcon = CopyImage(
2275 hIcon, IMAGE_ICON,
2276 himl->cx, himl->cy,
2277 LR_COPYFROMRESOURCE);
2278 /* the above will fail if the icon wasn't loaded from a resource, so try
2279 * again without LR_COPYFROMRESOURCE flag */
2280 if (!hBestFitIcon)
2281 hBestFitIcon = CopyImage(
2282 hIcon, IMAGE_ICON,
2283 himl->cx, himl->cy,
2284 0);
2285 if (!hBestFitIcon)
2286 return -1;
2287
2288 ret = GetIconInfo (hBestFitIcon, &ii);
2289 if (!ret) {
2290 DestroyIcon(hBestFitIcon);
2291 return -1;
2292 }
2293
2294 ret = GetObjectW (ii.hbmMask, sizeof(BITMAP), &bmp);
2295 if (!ret) {
2296 ERR("couldn't get mask bitmap info\n");
2297 if (ii.hbmColor)
2298 DeleteObject (ii.hbmColor);
2299 if (ii.hbmMask)
2300 DeleteObject (ii.hbmMask);
2301 DestroyIcon(hBestFitIcon);
2302 return -1;
2303 }
2304
2305 if (nIndex == -1) {
2306 if (himl->cCurImage + 1 > himl->cMaxImage)
2307 IMAGELIST_InternalExpandBitmaps (himl, 1, 0);
2308
2309 nIndex = himl->cCurImage;
2310 himl->cCurImage++;
2311 }
2312
2313 hdcImage = CreateCompatibleDC (0);
2314 TRACE("hdcImage=%p\n", hdcImage);
2315 if (hdcImage == 0)
2316 ERR("invalid hdcImage!\n");
2317
2318 imagelist_point_from_index(himl, nIndex, &pt);
2319
2320 SetTextColor(himl->hdcImage, RGB(0,0,0));
2321 SetBkColor (himl->hdcImage, RGB(255,255,255));
2322
2323 if (ii.hbmColor)
2324 {
2325 hbmOldSrc = SelectObject (hdcImage, ii.hbmColor);
2326 StretchBlt (himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
2327 hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2328 if (himl->hbmMask)
2329 {
2330 SelectObject (hdcImage, ii.hbmMask);
2331 StretchBlt (himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
2332 hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
2333 }
2334 }
2335 else
2336 {
2337 UINT height = bmp.bmHeight / 2;
2338 hbmOldSrc = SelectObject (hdcImage, ii.hbmMask);
2339 StretchBlt (himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
2340 hdcImage, 0, height, bmp.bmWidth, height, SRCCOPY);
2341 if (himl->hbmMask)
2342 StretchBlt (himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
2343 hdcImage, 0, 0, bmp.bmWidth, height, SRCCOPY);
2344 }
2345
2346 SelectObject (hdcImage, hbmOldSrc);
2347
2348 DestroyIcon(hBestFitIcon);
2349 if (hdcImage)
2350 DeleteDC (hdcImage);
2351 if (ii.hbmColor)
2352 DeleteObject (ii.hbmColor);
2353 if (ii.hbmMask)
2354 DeleteObject (ii.hbmMask);
2355
2356 TRACE("Insert index = %d, himl->cCurImage = %d\n", nIndex, himl->cCurImage);
2357 return nIndex;
2358 }
2359
2360
2361 /*************************************************************************
2362 * ImageList_SetBkColor [COMCTL32.@]
2363 *
2364 * Sets the background color of an image list.
2365 *
2366 * PARAMS
2367 * himl [I] handle to image list
2368 * clrBk [I] background color
2369 *
2370 * RETURNS
2371 * Success: previous background color
2372 * Failure: CLR_NONE
2373 */
2374
2375 COLORREF WINAPI
2376 ImageList_SetBkColor (HIMAGELIST himl, COLORREF clrBk)
2377 {
2378 COLORREF clrOldBk;
2379
2380 if (!is_valid(himl))
2381 return CLR_NONE;
2382
2383 clrOldBk = himl->clrBk;
2384 himl->clrBk = clrBk;
2385 return clrOldBk;
2386 }
2387
2388
2389 /*************************************************************************
2390 * ImageList_SetDragCursorImage [COMCTL32.@]
2391 *
2392 * Combines the specified image with the current drag image
2393 *
2394 * PARAMS
2395 * himlDrag [I] handle to drag image list
2396 * iDrag [I] drag image index
2397 * dxHotspot [I] X position of the hot spot
2398 * dyHotspot [I] Y position of the hot spot
2399 *
2400 * RETURNS
2401 * Success: TRUE
2402 * Failure: FALSE
2403 *
2404 * NOTES
2405 * - The names dxHotspot, dyHotspot are misleading because they have nothing
2406 * to do with a hotspot but are only the offset of the origin of the new
2407 * image relative to the origin of the old image.
2408 *
2409 * - When this function is called and the drag image is visible, a
2410 * short flickering occurs but this matches the Win9x behavior. It is
2411 * possible to fix the flickering using code like in ImageList_DragMove.
2412 */
2413
2414 BOOL WINAPI
2415 ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag,
2416 INT dxHotspot, INT dyHotspot)
2417 {
2418 HIMAGELIST himlTemp;
2419 BOOL visible;
2420
2421 if (!is_valid(InternalDrag.himl) || !is_valid(himlDrag))
2422 return FALSE;
2423
2424 TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
2425 dxHotspot, dyHotspot, InternalDrag.dxHotspot, InternalDrag.dyHotspot);
2426
2427 visible = InternalDrag.bShow;
2428
2429 himlTemp = ImageList_Merge (InternalDrag.himl, 0, himlDrag, iDrag,
2430 dxHotspot, dyHotspot);
2431
2432 if (visible) {
2433 /* hide the drag image */
2434 ImageList_DragShowNolock(FALSE);
2435 }
2436 if ((InternalDrag.himl->cx != himlTemp->cx) ||
2437 (InternalDrag.himl->cy != himlTemp->cy)) {
2438 /* the size of the drag image changed, invalidate the buffer */
2439 DeleteObject(InternalDrag.hbmBg);
2440 InternalDrag.hbmBg = 0;
2441 }
2442
2443 ImageList_Destroy (InternalDrag.himl);
2444 InternalDrag.himl = himlTemp;
2445
2446 if (visible) {
2447 /* show the drag image */
2448 ImageList_DragShowNolock(TRUE);
2449 }
2450
2451 return TRUE;
2452 }
2453
2454
2455 /*************************************************************************
2456 * ImageList_SetFilter [COMCTL32.@]
2457 *
2458 * Sets a filter (or does something completely different)!!???
2459 * It removes 12 Bytes from the stack (3 Parameters).
2460 *
2461 * PARAMS
2462 * himl [I] SHOULD be a handle to image list
2463 * i [I] COULD be an index?
2464 * dwFilter [I] ???
2465 *
2466 * RETURNS
2467 * Success: TRUE ???
2468 * Failure: FALSE ???
2469 *
2470 * BUGS
2471 * This is an UNDOCUMENTED function!!!!
2472 * empty stub.
2473 */
2474
2475 BOOL WINAPI
2476 ImageList_SetFilter (HIMAGELIST himl, INT i, DWORD dwFilter)
2477 {
2478 FIXME("(%p 0x%x 0x%x):empty stub!\n", himl, i, dwFilter);
2479
2480 return FALSE;
2481 }
2482
2483
2484 /*************************************************************************
2485 * ImageList_SetFlags [COMCTL32.@]
2486 *
2487 * Sets the image list flags.
2488 *
2489 * PARAMS
2490 * himl [I] Handle to image list
2491 * flags [I] Flags to set
2492 *
2493 * RETURNS
2494 * Old flags?
2495 *
2496 * BUGS
2497 * Stub.
2498 */
2499
2500 DWORD WINAPI
2501 ImageList_SetFlags(HIMAGELIST himl, DWORD flags)
2502 {
2503 FIXME("(%p %08x):empty stub\n", himl, flags);
2504 return 0;
2505 }
2506
2507
2508 /*************************************************************************
2509 * ImageList_SetIconSize [COMCTL32.@]
2510 *
2511 * Sets the image size of the bitmap and deletes all images.
2512 *
2513 * PARAMS
2514 * himl [I] handle to image list
2515 * cx [I] image width
2516 * cy [I] image height
2517 *
2518 * RETURNS
2519 * Success: TRUE
2520 * Failure: FALSE
2521 */
2522
2523 BOOL WINAPI
2524 ImageList_SetIconSize (HIMAGELIST himl, INT cx, INT cy)
2525 {
2526 INT nCount;
2527 HBITMAP hbmNew;
2528
2529 if (!is_valid(himl))
2530 return FALSE;
2531
2532 /* remove all images */
2533 himl->cMaxImage = himl->cInitial + 1;
2534 himl->cCurImage = 0;
2535 himl->cx = cx;
2536 himl->cy = cy;
2537
2538 /* initialize overlay mask indices */
2539 for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
2540 himl->nOvlIdx[nCount] = -1;
2541
2542 hbmNew = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage, himl->cx);
2543 SelectObject (himl->hdcImage, hbmNew);
2544 DeleteObject (himl->hbmImage);
2545 himl->hbmImage = hbmNew;
2546
2547 if (himl->hbmMask) {
2548 SIZE sz;
2549 imagelist_get_bitmap_size(himl, himl->cMaxImage, himl->cx, &sz);
2550 hbmNew = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2551 SelectObject (himl->hdcMask, hbmNew);
2552 DeleteObject (himl->hbmMask);
2553 himl->hbmMask = hbmNew;
2554 }
2555
2556 return TRUE;
2557 }
2558
2559
2560 /*************************************************************************
2561 * ImageList_SetImageCount [COMCTL32.@]
2562 *
2563 * Resizes an image list to the specified number of images.
2564 *
2565 * PARAMS
2566 * himl [I] handle to image list
2567 * iImageCount [I] number of images in the image list
2568 *
2569 * RETURNS
2570 * Success: TRUE
2571 * Failure: FALSE
2572 */
2573
2574 BOOL WINAPI
2575 ImageList_SetImageCount (HIMAGELIST himl, UINT iImageCount)
2576 {
2577 HDC hdcBitmap;
2578 HBITMAP hbmNewBitmap, hbmOld;
2579 INT nNewCount, nCopyCount;
2580
2581 TRACE("%p %d\n",himl,iImageCount);
2582
2583 if (!is_valid(himl))
2584 return FALSE;
2585 if (himl->cMaxImage > iImageCount)
2586 {
2587 himl->cCurImage = iImageCount;
2588 /* TODO: shrink the bitmap when cMaxImage-cCurImage>cGrow ? */
2589 return TRUE;
2590 }
2591
2592 nNewCount = iImageCount + himl->cGrow;
2593 nCopyCount = min(himl->cCurImage, iImageCount);
2594
2595 hdcBitmap = CreateCompatibleDC (0);
2596
2597 hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount, himl->cx);
2598
2599 if (hbmNewBitmap != 0)
2600 {
2601 hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
2602 imagelist_copy_images( himl, himl->hdcImage, hdcBitmap, 0, nCopyCount, 0 );
2603 SelectObject (hdcBitmap, hbmOld);
2604
2605 /* FIXME: delete 'empty' image space? */
2606
2607 SelectObject (himl->hdcImage, hbmNewBitmap);
2608 DeleteObject (himl->hbmImage);
2609 himl->hbmImage = hbmNewBitmap;
2610 }
2611 else
2612 ERR("Could not create new image bitmap !\n");
2613
2614 if (himl->hbmMask)
2615 {
2616 SIZE sz;
2617 imagelist_get_bitmap_size( himl, nNewCount, himl->cx, &sz );
2618 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
2619 if (hbmNewBitmap != 0)
2620 {
2621 hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
2622 imagelist_copy_images( himl, himl->hdcMask, hdcBitmap, 0, nCopyCount, 0 );
2623 SelectObject (hdcBitmap, hbmOld);
2624
2625 /* FIXME: delete 'empty' image space? */
2626
2627 SelectObject (himl->hdcMask, hbmNewBitmap);
2628 DeleteObject (himl->hbmMask);
2629 himl->hbmMask = hbmNewBitmap;
2630 }
2631 else
2632 ERR("Could not create new mask bitmap!\n");
2633 }
2634
2635 DeleteDC (hdcBitmap);
2636
2637 /* Update max image count and current image count */
2638 himl->cMaxImage = nNewCount;
2639 himl->cCurImage = iImageCount;
2640
2641 return TRUE;
2642 }
2643
2644
2645 /*************************************************************************
2646 * ImageList_SetOverlayImage [COMCTL32.@]
2647 *
2648 * Assigns an overlay mask index to an existing image in an image list.
2649 *
2650 * PARAMS
2651 * himl [I] handle to image list
2652 * iImage [I] image index
2653 * iOverlay [I] overlay mask index
2654 *
2655 * RETURNS
2656 * Success: TRUE
2657 * Failure: FALSE
2658 */
2659
2660 BOOL WINAPI
2661 ImageList_SetOverlayImage (HIMAGELIST himl, INT iImage, INT iOverlay)
2662 {
2663 if (!is_valid(himl))
2664 return FALSE;
2665 if ((iOverlay < 1) || (iOverlay > MAX_OVERLAYIMAGE))
2666 return FALSE;
2667 if ((iImage!=-1) && ((iImage < 0) || (iImage > himl->cCurImage)))
2668 return FALSE;
2669 himl->nOvlIdx[iOverlay - 1] = iImage;
2670 return TRUE;
2671 }
2672
2673
2674
2675 /* helper for ImageList_Write - write bitmap to pstm
2676 * currently everything is written as 24 bit RGB, except masks
2677 */
2678 static BOOL
2679 _write_bitmap(HBITMAP hBitmap, LPSTREAM pstm)
2680 {
2681 LPBITMAPFILEHEADER bmfh;
2682 LPBITMAPINFOHEADER bmih;
2683 LPBYTE data = NULL, lpBits;
2684 BITMAP bm;
2685 INT bitCount, sizeImage, offBits, totalSize;
2686 HDC xdc;
2687 BOOL result = FALSE;
2688
2689 if (!GetObjectW(hBitmap, sizeof(BITMAP), &bm))
2690 return FALSE;
2691
2692 bitCount = bm.bmBitsPixel == 1 ? 1 : 24;
2693 sizeImage = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, bitCount);
2694
2695 totalSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
2696 if(bitCount != 24)
2697 totalSize += (1 << bitCount) * sizeof(RGBQUAD);
2698 offBits = totalSize;
2699 totalSize += sizeImage;
2700
2701 data = Alloc(totalSize);
2702 bmfh = (LPBITMAPFILEHEADER)data;
2703 bmih = (LPBITMAPINFOHEADER)(data + sizeof(BITMAPFILEHEADER));
2704 lpBits = data + offBits;
2705
2706 /* setup BITMAPFILEHEADER */
2707 bmfh->bfType = (('M' << 8) | 'B');
2708 bmfh->bfSize = offBits;
2709 bmfh->bfReserved1 = 0;
2710 bmfh->bfReserved2 = 0;
2711 bmfh->bfOffBits = offBits;
2712
2713 /* setup BITMAPINFOHEADER */
2714 bmih->biSize = sizeof(BITMAPINFOHEADER);
2715 bmih->biWidth = bm.bmWidth;
2716 bmih->biHeight = bm.bmHeight;
2717 bmih->biPlanes = 1;
2718 bmih->biBitCount = bitCount;
2719 bmih->biCompression = BI_RGB;
2720 bmih->biSizeImage = sizeImage;
2721 bmih->biXPelsPerMeter = 0;
2722 bmih->biYPelsPerMeter = 0;
2723 bmih->biClrUsed = 0;
2724 bmih->biClrImportant = 0;
2725
2726 xdc = GetDC(0);
2727 result = GetDIBits(xdc, hBitmap, 0, bm.bmHeight, lpBits, (BITMAPINFO *)bmih, DIB_RGB_COLORS) == bm.bmHeight;
2728 ReleaseDC(0, xdc);
2729 if (!result)
2730 goto failed;
2731
2732 TRACE("width %u, height %u, planes %u, bpp %u\n",
2733 bmih->biWidth, bmih->biHeight,
2734 bmih->biPlanes, bmih->biBitCount);
2735
2736 if(bitCount == 1) {
2737 /* Hack. */
2738 LPBITMAPINFO inf = (LPBITMAPINFO)bmih;
2739 inf->bmiColors[0].rgbRed = inf->bmiColors[0].rgbGreen = inf->bmiColors[0].rgbBlue = 0;
2740 inf->bmiColors[1].rgbRed = inf->bmiColors[1].rgbGreen = inf->bmiColors[1].rgbBlue = 0xff;
2741 }
2742
2743 if(FAILED(IStream_Write(pstm, data, totalSize, NULL)))
2744 goto failed;
2745
2746 result = TRUE;
2747
2748 failed:
2749 Free(data);
2750
2751 return result;
2752 }
2753
2754
2755 /*************************************************************************
2756 * ImageList_Write [COMCTL32.@]
2757 *
2758 * Writes an image list to a stream.
2759 *
2760 * PARAMS
2761 * himl [I] handle to image list
2762 * pstm [O] Pointer to a stream.
2763 *
2764 * RETURNS
2765 * Success: TRUE
2766 * Failure: FALSE
2767 *
2768 * BUGS
2769 * probably.
2770 */
2771
2772 BOOL WINAPI
2773 ImageList_Write (HIMAGELIST himl, LPSTREAM pstm)
2774 {
2775 ILHEAD ilHead;
2776 int i;
2777
2778 TRACE("%p %p\n", himl, pstm);
2779
2780 if (!is_valid(himl))
2781 return FALSE;
2782
2783 ilHead.usMagic = (('L' << 8) | 'I');
2784 ilHead.usVersion = 0x101;
2785 ilHead.cCurImage = himl->cCurImage;
2786 ilHead.cMaxImage = himl->cMaxImage;
2787 ilHead.cGrow = himl->cGrow;
2788 ilHead.cx = himl->cx;
2789 ilHead.cy = himl->cy;
2790 ilHead.bkcolor = himl->clrBk;
2791 ilHead.flags = himl->flags;
2792 for(i = 0; i < 4; i++) {
2793 ilHead.ovls[i] = himl->nOvlIdx[i];
2794 }
2795
2796 TRACE("cx %u, cy %u, flags 0x04%x, cCurImage %u, cMaxImage %u\n",
2797 ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
2798
2799 if(FAILED(IStream_Write(pstm, &ilHead, sizeof(ILHEAD), NULL)))
2800 return FALSE;
2801
2802 /* write the bitmap */
2803 if(!_write_bitmap(himl->hbmImage, pstm))
2804 return FALSE;
2805
2806 /* write the mask if we have one */
2807 if(himl->flags & ILC_MASK) {
2808 if(!_write_bitmap(himl->hbmMask, pstm))
2809 return FALSE;
2810 }
2811
2812 return TRUE;
2813 }
2814
2815
2816 static HBITMAP ImageList_CreateImage(HDC hdc, HIMAGELIST himl, UINT count, UINT width)
2817 {
2818 HBITMAP hbmNewBitmap;
2819 UINT ilc = (himl->flags & 0xFE);
2820 SIZE sz;
2821
2822 imagelist_get_bitmap_size( himl, count, width, &sz );
2823
2824 if ((ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32) || ilc == ILC_COLOR)
2825 {
2826 VOID* bits;
2827 BITMAPINFO *bmi;
2828
2829 TRACE("Creating DIBSection %d x %d, %d Bits per Pixel\n",
2830 sz.cx, sz.cy, himl->uBitsPixel);
2831
2832 if (himl->uBitsPixel <= ILC_COLOR8)
2833 {
2834 LPPALETTEENTRY pal;
2835 ULONG i, colors;
2836 BYTE temp;
2837
2838 colors = 1 << himl->uBitsPixel;
2839 bmi = Alloc(sizeof(BITMAPINFOHEADER) +
2840 sizeof(PALETTEENTRY) * colors);
2841
2842 pal = (LPPALETTEENTRY)bmi->bmiColors;
2843 GetPaletteEntries(GetStockObject(DEFAULT_PALETTE), 0, colors, pal);
2844
2845 /* Swap colors returned by GetPaletteEntries so we can use them for
2846 * CreateDIBSection call. */
2847 for (i = 0; i < colors; i++)
2848 {
2849 temp = pal[i].peBlue;
2850 bmi->bmiColors[i].rgbRed = pal[i].peRed;
2851 bmi->bmiColors[i].rgbBlue = temp;
2852 }
2853 }
2854 else
2855 {
2856 bmi = Alloc(sizeof(BITMAPINFOHEADER));
2857 }
2858
2859 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2860 bmi->bmiHeader.biWidth = sz.cx;
2861 bmi->bmiHeader.biHeight = sz.cy;
2862 bmi->bmiHeader.biPlanes = 1;
2863 bmi->bmiHeader.biBitCount = himl->uBitsPixel;
2864 bmi->bmiHeader.biCompression = BI_RGB;
2865 bmi->bmiHeader.biSizeImage = 0;
2866 bmi->bmiHeader.biXPelsPerMeter = 0;
2867 bmi->bmiHeader.biYPelsPerMeter = 0;
2868 bmi->bmiHeader.biClrUsed = 0;
2869 bmi->bmiHeader.biClrImportant = 0;
2870
2871 hbmNewBitmap = CreateDIBSection(hdc, bmi, DIB_RGB_COLORS, &bits, 0, 0);
2872
2873 Free (bmi);
2874 }
2875 else /*if (ilc == ILC_COLORDDB)*/
2876 {
2877 TRACE("Creating Bitmap: %d Bits per Pixel\n", himl->uBitsPixel);
2878
2879 hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, himl->uBitsPixel, NULL);
2880 }
2881 TRACE("returning %p\n", hbmNewBitmap);
2882 return hbmNewBitmap;
2883 }
2884
2885 /*************************************************************************
2886 * ImageList_SetColorTable [COMCTL32.@]
2887 *
2888 * Sets the color table of an image list.
2889 *
2890 * PARAMS
2891 * himl [I] Handle to the image list.
2892 * uStartIndex [I] The first index to set.
2893 * cEntries [I] Number of entries to set.
2894 * prgb [I] New color information for color table for the image list.
2895 *
2896 * RETURNS
2897 * Success: Number of entries in the table that were set.
2898 * Failure: Zero.
2899 *
2900 * SEE
2901 * ImageList_Create(), SetDIBColorTable()
2902 */
2903
2904 UINT WINAPI
2905 ImageList_SetColorTable (HIMAGELIST himl, UINT uStartIndex, UINT cEntries, CONST RGBQUAD * prgb)
2906 {
2907 return SetDIBColorTable(himl->hdcImage, uStartIndex, cEntries, prgb);
2908 }
2909
2910 /*************************************************************************
2911 * ImageList_CoCreateInstance [COMCTL32.@]
2912 *
2913 * Creates a new imagelist instance and returns an interface pointer to it.
2914 *
2915 * PARAMS
2916 * rclsid [I] A reference to the CLSID (CLSID_ImageList).
2917 * punkOuter [I] Pointer to IUnknown interface for aggregation, if desired
2918 * riid [I] Identifier of the requested interface.
2919 * ppv [O] Returns the address of the pointer requested, or NULL.
2920 *
2921 * RETURNS
2922 * Success: S_OK.
2923 * Failure: Error value.
2924 */
2925 HRESULT WINAPI
2926 ImageList_CoCreateInstance (REFCLSID rclsid, const IUnknown *punkOuter, REFIID riid, void **ppv)
2927 {
2928 FIXME("STUB: %s %p %s %p\n", debugstr_guid(rclsid), punkOuter, debugstr_guid(riid), ppv);
2929 return E_NOINTERFACE;
2930 }
2931
2932 /*************************************************************************
2933 * HIMAGELIST_QueryInterface [COMCTL32.@]
2934 *
2935 * Returns a pointer to an IImageList or IImageList2 object for the given
2936 * HIMAGELIST.
2937 *
2938 * PARAMS
2939 * himl [I] Image list handle.
2940 * riid [I] Identifier of the requested interface.
2941 * ppv [O] Returns the address of the pointer requested, or NULL.
2942 *
2943 * RETURNS
2944 * Success: S_OK.
2945 * Failure: Error value.
2946 */
2947 HRESULT WINAPI
2948 HIMAGELIST_QueryInterface (HIMAGELIST himl, REFIID riid, void **ppv)
2949 {
2950 FIXME("STUB: %p %s %p\n", himl, debugstr_guid(riid), ppv);
2951 return E_NOINTERFACE;
2952 }
A free Windows-compatible Operating System