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