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