git.oblomov.eu Git - wine/blob - dlls/comctl32/imagelist.c

   1 /*
   2  *  ImageList implementation
   3  *
   4  *  Copyright 1998 Eric Kohl
   5  *
   6  *  TODO:
   7  *    - Fix ImageList_DrawIndirect (xBitmap, yBitmap, rgbFg, rgbBk, dwRop).
   8  *    - Fix ImageList_GetIcon.
   9  *    - Fix drag functions.
  10  *    - Fix ImageList_Read and ImageList_Write.
  11  *    - Fix ImageList_SetFilter (undocumented).
  12  *      BTW does anybody know anything about this function???
  13  *        - It removes 12 Bytes from the stack (3 Parameters).
  14  *        - First parameter SHOULD be a HIMAGELIST.
  15  *        - Second parameter COULD be an index?????
  16  *        - Third parameter.... ?????????????????????
  17  *
  18  *  Comments:
  19  *    - ImageList_Draw, ImageList_DrawEx and ImageList_GetIcon use
  20  *      ImageList_DrawIndirect. Since ImageList_DrawIndirect is still
  21  *      partially imlemented, the functions mentioned above will be
  22  *      limited in functionality too.
  23  */
  24
  25 /* This must be defined because the HIMAGELIST type is just a pointer
  26  * to the _IMAGELIST data structure. But M$ does not want us to know
  27  * anything about its contents. Applications just see a pointer to
  28  * an empty structure. It's just to keep compatibility.
  29  */
  30 #define __WINE_IMAGELIST_C
  31
  32
  33 #include "wine/obj_base.h"
  34 #include "wine/obj_storage.h"
  35 #include "imagelist.h"
  36 #include "commctrl.h"
  37 #include "debugtools.h"
  38
  39 DEFAULT_DEBUG_CHANNEL(imagelist)
  40
  41
  42 #define _MAX(a,b) (((a)>(b))?(a):(b))
  43 #define _MIN(a,b) (((a)>(b))?(b):(a))
  44
  45 #define MAX_OVERLAYIMAGE 15
  46
  47
  48 /* internal image list data used for Drag & Drop operations */
  49
  50 static HIMAGELIST himlInternalDrag = NULL;
  51 static INT      nInternalDragHotspotX = 0;
  52 static INT      nInternalDragHotspotY = 0;
  53
  54 static HWND     hwndInternalDrag = 0;
  55 static INT      xInternalPos = 0;
  56 static INT      yInternalPos = 0;
  57
  58 static HDC      hdcBackBuffer = 0;
  59 static HBITMAP  hbmBackBuffer = 0;
  60
  61
  62 /*************************************************************************
  63  * IMAGELIST_InternalExpandBitmaps [Internal]
  64  *
  65  * Expands the bitmaps of an image list by the given number of images.
  66  *
  67  * PARAMS
  68  *     himl        [I] handle to image list
  69  *     nImageCount [I] number of images to add
  70  *
  71  * RETURNS
  72  *     nothing
  73  *
  74  * NOTES
  75  *     This function can NOT be used to reduce the number of images.
  76  */
  77
  78 static VOID
  79 IMAGELIST_InternalExpandBitmaps (HIMAGELIST himl, INT nImageCount)
  80 {
  81     HDC     hdcImageList, hdcBitmap;
  82     HBITMAP hbmNewBitmap;
  83     INT     nNewWidth, nNewCount;
  84
  85     TRACE("Create expanded bitmaps!\n");
  86
  87     nNewCount = himl->cCurImage + nImageCount + himl->cGrow;
  88     nNewWidth = nNewCount * himl->cx;
  89
  90     hdcImageList = CreateCompatibleDC (0);
  91     hdcBitmap = CreateCompatibleDC (0);
  92
  93     hbmNewBitmap =
  94         CreateBitmap (nNewWidth, himl->cy, 1, himl->uBitsPixel, NULL);
  95     if (hbmNewBitmap == 0)
  96         ERR("creating new image bitmap!\n");
  97
  98     SelectObject (hdcImageList, himl->hbmImage);
  99     SelectObject (hdcBitmap, hbmNewBitmap);
 100     BitBlt (hdcBitmap, 0, 0, himl->cCurImage * himl->cx, himl->cy,
 101               hdcImageList, 0, 0, SRCCOPY);
 102
 103     DeleteObject (himl->hbmImage);
 104     himl->hbmImage = hbmNewBitmap;
 105
 106     if (himl->hbmMask) {
 107         hbmNewBitmap =
 108             CreateBitmap (nNewWidth, himl->cy, 1, 1, NULL);
 109
 110         if (hbmNewBitmap == 0)
 111             ERR("creating new mask bitmap!");
 112
 113         SelectObject (hdcImageList, himl->hbmMask);
 114         SelectObject (hdcBitmap, hbmNewBitmap);
 115         BitBlt (hdcBitmap, 0, 0, himl->cCurImage * himl->cx, himl->cy,
 116                   hdcImageList, 0, 0, SRCCOPY);
 117         DeleteObject (himl->hbmMask);
 118         himl->hbmMask = hbmNewBitmap;
 119     }
 120
 121     himl->cMaxImage = nNewCount;
 122
 123     DeleteDC (hdcImageList);
 124     DeleteDC (hdcBitmap);
 125 }
 126
 127
 128 /*************************************************************************
 129  * ImageList_Add [COMCTL32.39]
 130  *
 131  * Add an image or images to an image list.
 132  *
 133  * PARAMS
 134  *     himl     [I] handle to image list
 135  *     hbmImage [I] handle to image bitmap
 136  *     hbmMask  [I] handle to mask bitmap
 137  *
 138  * RETURNS
 139  *     Success: Index of the first new image.
 140  *     Failure: -1
 141  */
 142
 143 INT WINAPI
 144 ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
 145 {
 146     HDC    hdcSrc, hdcDst;
 147     INT    nFirstIndex, nImageCount;
 148     INT    nStartX;
 149     BITMAP bmp;
 150
 151     if (!himl || !hbmImage)
 152         return -1;
 153
 154     GetObjectA (hbmImage, sizeof(BITMAP), (LPVOID)&bmp);
 155     nImageCount = bmp.bmWidth / himl->cx;
 156
 157     if (himl->cCurImage + nImageCount >= himl->cMaxImage)
 158         IMAGELIST_InternalExpandBitmaps (himl, nImageCount);
 159
 160     nStartX = himl->cCurImage * himl->cx;
 161
 162     hdcSrc = CreateCompatibleDC (0);
 163     hdcDst = CreateCompatibleDC (0);
 164
 165     /* copy image bitmap */
 166     SelectObject (hdcDst, himl->hbmImage);
 167     SelectObject (hdcSrc, hbmImage);
 168     BitBlt (hdcDst, himl->cCurImage * himl->cx, 0,
 169               bmp.bmWidth, himl->cy, hdcSrc, 0, 0, SRCCOPY);
 170
 171     if (himl->hbmMask) {
 172         if (hbmMask) {
 173             /* copy mask bitmap */
 174             SelectObject (hdcDst, himl->hbmMask);
 175             SelectObject (hdcSrc, hbmMask);
 176             BitBlt (hdcDst, nStartX, 0, bmp.bmWidth, himl->cy,
 177                       hdcSrc, 0, 0, SRCCOPY);
 178         }
 179         else {
 180             /* copy monochrome image to the mask bitmap */
 181             SelectObject (hdcDst, himl->hbmMask);
 182             SelectObject (hdcSrc, hbmImage);
 183             SetBkColor (hdcSrc, GetNearestColor (hdcSrc,
 184                           GetPixel (hdcSrc, 0, 0)));
 185             BitBlt (hdcDst, nStartX, 0, bmp.bmWidth, himl->cy,
 186                       hdcSrc, nStartX, 0, SRCCOPY);
 187         }
 188     }
 189
 190     DeleteDC (hdcSrc);
 191     DeleteDC (hdcDst);
 192
 193     nFirstIndex = himl->cCurImage;
 194     himl->cCurImage += nImageCount;
 195
 196     return nFirstIndex;
 197 }
 198
 199
 200 /*************************************************************************
 201  * ImageList_AddIcon [COMCTL32.40]
 202  *
 203  * Adds an icon to an image list.
 204  *
 205  * PARAMS
 206  *     himl  [I] handle to image list
 207  *     hIcon [I] handle to icon
 208  *
 209  * RETURNS
 210  *     Success: index of the new image
 211  *     Failure: -1
 212  */
 213
 214 INT WINAPI
 215 ImageList_AddIcon (HIMAGELIST himl, HICON hIcon)
 216 {
 217     return ImageList_ReplaceIcon (himl, -1, hIcon);
 218 }
 219
 220
 221 /*************************************************************************
 222  * ImageList_AddMasked [COMCTL32.41]
 223  *
 224  * Adds an image or images to an image list and creates a mask from the
 225  * specified bitmap using the mask color.
 226  *
 227  * PARAMS
 228  *     himl    [I] handle to image list.
 229  *     hBitmap [I] handle to bitmap
 230  *     clrMask [I] mask color.
 231  *
 232  * RETURNS
 233  *     Success: Index of the first new image.
 234  *     Failure: -1
 235  */
 236
 237 INT WINAPI
 238 ImageList_AddMasked (HIMAGELIST himl, HBITMAP hBitmap, COLORREF clrMask)
 239 {
 240     HDC    hdcImage, hdcMask, hdcBitmap;
 241     INT    nIndex, nImageCount;
 242     BITMAP bmp;
 243
 244     if (himl == NULL)
 245         return -1;
 246
 247     if (!GetObjectA (hBitmap, sizeof(BITMAP), &bmp))
 248         return -1;
 249
 250     nImageCount = bmp.bmWidth / himl->cx;
 251
 252     if (himl->cCurImage + nImageCount >= himl->cMaxImage)
 253         IMAGELIST_InternalExpandBitmaps (himl, nImageCount);
 254
 255     nIndex = himl->cCurImage;
 256     himl->cCurImage += nImageCount;
 257
 258     hdcImage  = CreateCompatibleDC (0);
 259     hdcBitmap = CreateCompatibleDC (0);
 260
 261     SelectObject (hdcBitmap, hBitmap);
 262     SelectObject (hdcImage, himl->hbmImage);
 263     BitBlt (hdcImage, nIndex * himl->cx, 0, bmp.bmWidth, himl->cy,
 264               hdcBitmap, 0, 0, SRCCOPY);
 265
 266     if (himl->hbmMask) {
 267         COLORREF bkColor = (clrMask != CLR_DEFAULT) ? clrMask :
 268             GetNearestColor (hdcBitmap, GetPixel (hdcBitmap, 0, 0));
 269
 270         /* create mask from image */
 271         hdcMask = CreateCompatibleDC (0);
 272         SelectObject (hdcMask, himl->hbmMask);
 273
 274         /* create monochrome image to the mask bitmap */
 275         SetBkColor (hdcBitmap, bkColor);
 276         BitBlt (hdcMask, nIndex * himl->cx, 0, bmp.bmWidth, himl->cy,
 277                   hdcBitmap, 0, 0, SRCCOPY);
 278
 279         DeleteDC (hdcMask);
 280     }
 281
 282     DeleteDC (hdcImage);
 283     DeleteDC (hdcBitmap);
 284
 285     return nIndex;
 286 }
 287
 288
 289 /*************************************************************************
 290  * ImageList_BeginDrag [COMCTL32.42]
 291  *
 292  * Creates a temporary image list that contains one image. It will be used
 293  * as a drag image.
 294  *
 295  * PARAMS
 296  *     himlTrack [I] handle to the source image list
 297  *     iTrack    [I] index of the drag image in the source image list
 298  *     dxHotspot [I] X position of the hot spot of the drag image
 299  *     dyHotspot [I] Y position of the hot spot of the drag image
 300  *
 301  * RETURNS
 302  *     Success: TRUE
 303  *     Failure: FALSE
 304  */
 305
 306 BOOL WINAPI
 307 ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack,
 308                      INT dxHotspot, INT dyHotspot)
 309 {
 310     HDC hdcSrc, hdcDst;
 311
 312     FIXME("partially implemented!\n");
 313
 314     if (himlTrack == NULL)
 315         return FALSE;
 316
 317     if (himlInternalDrag)
 318         ImageList_EndDrag ();
 319
 320     himlInternalDrag =
 321         ImageList_Create (himlTrack->cx, himlTrack->cy,
 322                           himlTrack->flags, 1, 1);
 323     if (himlInternalDrag == NULL) {
 324         ERR("Error creating drag image list!\n");
 325         return FALSE;
 326     }
 327
 328     nInternalDragHotspotX = dxHotspot;
 329     nInternalDragHotspotY = dyHotspot;
 330
 331     hdcSrc = CreateCompatibleDC (0);
 332     hdcDst = CreateCompatibleDC (0);
 333
 334     /* copy image */
 335     SelectObject (hdcSrc, himlTrack->hbmImage);
 336     SelectObject (hdcDst, himlInternalDrag->hbmImage);
 337     StretchBlt (hdcDst, 0, 0, himlInternalDrag->cx, himlInternalDrag->cy, hdcSrc,
 338                   iTrack * himlTrack->cx, 0, himlTrack->cx, himlTrack->cy, SRCCOPY);
 339
 340     /* copy mask */
 341     SelectObject (hdcSrc, himlTrack->hbmMask);
 342     SelectObject (hdcDst, himlInternalDrag->hbmMask);
 343     StretchBlt (hdcDst, 0, 0, himlInternalDrag->cx, himlInternalDrag->cy, hdcSrc,
 344                   iTrack * himlTrack->cx, 0, himlTrack->cx, himlTrack->cy, SRCCOPY);
 345
 346     DeleteDC (hdcSrc);
 347     DeleteDC (hdcDst);
 348
 349     himlInternalDrag->cCurImage = 1;
 350
 351     return TRUE;
 352 }
 353
 354
 355 /*************************************************************************
 356  * ImageList_Copy [COMCTL32.43]
 357  *
 358  *  Copies an image of the source image list to an image of the
 359  *  destination image list. Images can be copied or swapped.
 360  *
 361  * PARAMS
 362  *     himlDst [I] handle to the destination image list
 363  *     iDst    [I] destination image index.
 364  *     himlSrc [I] handle to the source image list
 365  *     iSrc    [I] source image index
 366  *     uFlags  [I] flags for the copy operation
 367  *
 368  * RETURNS
 369  *     Success: TRUE
 370  *     Failure: FALSE
 371  *
 372  * NOTES
 373  *     Copying from one image list to another is possible. The original
 374  *     implementation just copies or swapps within one image list.
 375  *     Could this feature become a bug??? ;-)
 376  */
 377
 378 BOOL WINAPI
 379 ImageList_Copy (HIMAGELIST himlDst, INT iDst,   HIMAGELIST himlSrc,
 380                 INT iSrc, INT uFlags)
 381 {
 382     HDC hdcSrc, hdcDst;
 383
 384     TRACE("iDst=%d  iSrc=%d\n", iDst, iSrc);
 385
 386     if ((himlSrc == NULL) || (himlDst == NULL))
 387         return FALSE;
 388     if ((iDst < 0) || (iDst >= himlDst->cCurImage))
 389         return FALSE;
 390     if ((iSrc < 0) || (iSrc >= himlSrc->cCurImage))
 391         return FALSE;
 392
 393     hdcSrc = CreateCompatibleDC (0);
 394     if (himlDst == himlSrc)
 395         hdcDst = hdcSrc;
 396     else
 397         hdcDst = CreateCompatibleDC (0);
 398
 399     if (uFlags & ILCF_SWAP) {
 400         /* swap */
 401         HBITMAP hbmTempImage, hbmTempMask;
 402
 403         /* create temporary bitmaps */
 404         hbmTempImage = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
 405                                        himlSrc->uBitsPixel, NULL);
 406         hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
 407                                       1, NULL);
 408
 409         /* copy (and stretch) destination to temporary bitmaps.(save) */
 410         /* image */
 411         SelectObject (hdcSrc, himlDst->hbmImage);
 412         SelectObject (hdcDst, hbmTempImage);
 413         StretchBlt (hdcDst, 0, 0, himlSrc->cx, himlSrc->cy,
 414                       hdcSrc, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 415                       SRCCOPY);
 416         /* mask */
 417         SelectObject (hdcSrc, himlDst->hbmMask);
 418         SelectObject (hdcDst, hbmTempMask);
 419         StretchBlt (hdcDst, 0, 0, himlSrc->cx, himlSrc->cy,
 420                       hdcSrc, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 421                       SRCCOPY);
 422
 423         /* copy (and stretch) source to destination */
 424         /* image */
 425         SelectObject (hdcSrc, himlSrc->hbmImage);
 426         SelectObject (hdcDst, himlDst->hbmImage);
 427         StretchBlt (hdcDst, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 428                       hdcSrc, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 429                       SRCCOPY);
 430         /* mask */
 431         SelectObject (hdcSrc, himlSrc->hbmMask);
 432         SelectObject (hdcDst, himlDst->hbmMask);
 433         StretchBlt (hdcDst, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 434                       hdcSrc, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 435                       SRCCOPY);
 436
 437         /* copy (without stretching) temporary bitmaps to source (restore) */
 438         /* image */
 439         SelectObject (hdcSrc, hbmTempImage);
 440         SelectObject (hdcDst, himlSrc->hbmImage);
 441         BitBlt (hdcDst, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 442                   hdcSrc, 0, 0, SRCCOPY);
 443         /* mask */
 444         SelectObject (hdcSrc, hbmTempMask);
 445         SelectObject (hdcDst, himlSrc->hbmMask);
 446         BitBlt (hdcDst, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 447                   hdcSrc, 0, 0, SRCCOPY);
 448
 449         /* delete temporary bitmaps */
 450         DeleteObject (hbmTempMask);
 451         DeleteObject (hbmTempImage);
 452     }
 453     else {
 454         /* copy image */
 455         SelectObject (hdcSrc, himlSrc->hbmImage);
 456         if (himlSrc == himlDst)
 457             hdcDst = hdcSrc;
 458         else
 459             SelectObject (hdcDst, himlDst->hbmImage);
 460         StretchBlt (hdcDst, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 461                       hdcSrc, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 462                       SRCCOPY);
 463
 464         /* copy mask */
 465         SelectObject (hdcSrc, himlSrc->hbmMask);
 466         if (himlSrc == himlDst)
 467             hdcDst = hdcSrc;
 468         else
 469             SelectObject (hdcDst, himlDst->hbmMask);
 470         StretchBlt (hdcDst, iDst * himlDst->cx, 0, himlDst->cx, himlDst->cy,
 471                       hdcSrc, iSrc * himlSrc->cx, 0, himlSrc->cx, himlSrc->cy,
 472                       SRCCOPY);
 473     }
 474
 475     DeleteDC (hdcSrc);
 476     if (himlSrc != himlDst)
 477         DeleteDC (hdcDst);
 478
 479     return TRUE;
 480 }
 481
 482
 483 /*************************************************************************
 484  * ImageList_Create [COMCTL32.44]  Creates a new image list.
 485  *
 486  * PARAMS
 487  *     cx       [I] image height
 488  *     cy       [I] image width
 489  *     flags    [I] creation flags
 490  *     cInitial [I] initial number of images in the image list
 491  *     cGrow    [I] number of images by which image list grows
 492  *
 493  * RETURNS
 494  *     Success: Handle to the created image list
 495  *     Failure: NULL
 496  */
 497
 498 HIMAGELIST WINAPI
 499 ImageList_Create (INT cx, INT cy, UINT flags,
 500                   INT cInitial, INT cGrow)
 501 {
 502     HIMAGELIST himl;
 503     HDC      hdc;
 504     INT      nCount;
 505     HBITMAP  hbmTemp;
 506     static WORD aBitBlend25[] =
 507         {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
 508
 509     static WORD aBitBlend50[] =
 510         {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
 511
 512     TRACE("(%d %d 0x%x %d %d)\n", cx, cy, flags, cInitial, cGrow);
 513
 514     himl = (HIMAGELIST)COMCTL32_Alloc (sizeof(struct _IMAGELIST));
 515     if (!himl)
 516         return NULL;
 517
 518     himl->cx        = cx;
 519     himl->cy        = cy;
 520     himl->flags     = flags;
 521     himl->cMaxImage = cInitial + cGrow;
 522     himl->cInitial  = cInitial;
 523     himl->cGrow     = cGrow;
 524     himl->cCurImage = 0;
 525     himl->clrFg     = CLR_DEFAULT;
 526     himl->clrBk     = CLR_NONE;
 527
 528     /* initialize overlay mask indices */
 529     for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
 530         himl->nOvlIdx[nCount] = -1;
 531
 532     hdc = CreateCompatibleDC (0);
 533     himl->uBitsPixel = (UINT)GetDeviceCaps (hdc, BITSPIXEL);
 534     DeleteDC (hdc);
 535
 536     TRACE("Image: %d Bits per Pixel\n", himl->uBitsPixel);
 537
 538     himl->hbmImage =
 539         CreateBitmap (himl->cx * himl->cMaxImage, himl->cy,
 540                         1, himl->uBitsPixel, NULL);
 541     if (himl->hbmImage == 0) {
 542         ERR("Error creating image bitmap!\n");
 543         return NULL;
 544     }
 545
 546     if (himl->flags & ILC_MASK) {
 547         himl->hbmMask = CreateBitmap (himl->cx * himl->cMaxImage, himl->cy,
 548                                         1, 1, NULL);
 549         if (himl->hbmMask == 0) {
 550             ERR("Error creating mask bitmap!\n");
 551             if (himl->hbmImage)
 552                 DeleteObject (himl->hbmImage);
 553             return NULL;
 554         }
 555     }
 556     else
 557         himl->hbmMask = 0;
 558
 559     /* create blending brushes */
 560     hbmTemp = CreateBitmap (8, 8, 1, 1, &aBitBlend25);
 561     himl->hbrBlend25 = CreatePatternBrush (hbmTemp);
 562     DeleteObject (hbmTemp);
 563
 564     hbmTemp = CreateBitmap (8, 8, 1, 1, &aBitBlend50);
 565     himl->hbrBlend50 = CreatePatternBrush (hbmTemp);
 566     DeleteObject (hbmTemp);
 567
 568     return himl;
 569 }
 570
 571
 572 /*************************************************************************
 573  * ImageList_Destroy [COMCTL32.45]
 574  *
 575  * Destroys an image list.
 576  *
 577  * PARAMS
 578  *     himl [I] handle to image list
 579  *
 580  * RETURNS
 581  *     Success: TRUE
 582  *     Failure: FALSE
 583  */
 584
 585 BOOL WINAPI
 586 ImageList_Destroy (HIMAGELIST himl)
 587 {
 588     if (!himl)
 589         return FALSE;
 590
 591     /* delete image bitmaps */
 592     if (himl->hbmImage)
 593         DeleteObject (himl->hbmImage);
 594     if (himl->hbmMask)
 595         DeleteObject (himl->hbmMask);
 596
 597     /* delete blending brushes */
 598     if (himl->hbrBlend25)
 599         DeleteObject (himl->hbrBlend25);
 600     if (himl->hbrBlend50)
 601         DeleteObject (himl->hbrBlend50);
 602
 603     COMCTL32_Free (himl);
 604
 605     return TRUE;
 606 }
 607
 608
 609 /*************************************************************************
 610  * ImageList_DragEnter [COMCTL32.46]
 611  *
 612  * Locks window update and displays the drag image at the given position.
 613  *
 614  * PARAMS
 615  *     hwndLock [I] handle of the window that owns the drag image.
 616  *     x        [I] X position of the drag image.
 617  *     y        [I] Y position of the drag image.
 618  *
 619  * RETURNS
 620  *     Success: TRUE
 621  *     Failure: FALSE
 622  *
 623  * NOTES
 624  *     The position of the drag image is relative to the window, not
 625  *     the client area.
 626  */
 627
 628 BOOL WINAPI
 629 ImageList_DragEnter (HWND hwndLock, INT x, INT y)
 630 {
 631     if (himlInternalDrag == NULL)
 632         return FALSE;
 633
 634     if (hwndLock)
 635         hwndInternalDrag = hwndLock;
 636     else
 637         hwndInternalDrag = GetDesktopWindow ();
 638
 639     xInternalPos = x;
 640     yInternalPos = y;
 641
 642     hdcBackBuffer = CreateCompatibleDC (0);
 643     hbmBackBuffer = CreateCompatibleBitmap (hdcBackBuffer,
 644                 himlInternalDrag->cx, himlInternalDrag->cy);
 645
 646     ImageList_DragShowNolock (TRUE);
 647
 648     return FALSE;
 649 }
 650
 651
 652 /*************************************************************************
 653  * ImageList_DragLeave [COMCTL32.47]
 654  *
 655  * Unlocks window update and hides the drag image.
 656  *
 657  * PARAMS
 658  *     hwndLock [I] handle of the window that owns the drag image.
 659  *
 660  * RETURNS
 661  *     Success: TRUE
 662  *     Failure: FALSE
 663  */
 664
 665 BOOL WINAPI
 666 ImageList_DragLeave (HWND hwndLock)
 667 {
 668     if (hwndLock)
 669         hwndInternalDrag = hwndLock;
 670     else
 671         hwndInternalDrag = GetDesktopWindow ();
 672
 673     ImageList_DragShowNolock (FALSE);
 674
 675     DeleteDC (hdcBackBuffer);
 676     DeleteObject (hbmBackBuffer);
 677
 678     return TRUE;
 679 }
 680
 681
 682 /*************************************************************************
 683  * ImageList_DragMove [COMCTL32.48]
 684  *
 685  * Moves the drag image.
 686  *
 687  * PARAMS
 688  *     x [I] X position of the drag image.
 689  *     y [I] Y position of the drag image.
 690  *
 691  * RETURNS
 692  *     Success: TRUE
 693  *     Failure: FALSE
 694  *
 695  * NOTES
 696  *     The position of the drag image is relative to the window, not
 697  *     the client area.
 698  */
 699
 700 BOOL WINAPI
 701 ImageList_DragMove (INT x, INT y)
 702 {
 703     ImageList_DragShowNolock (FALSE);
 704
 705     xInternalPos = x;
 706     yInternalPos = y;
 707
 708     ImageList_DragShowNolock (TRUE);
 709
 710     return FALSE;
 711 }
 712
 713
 714 /*************************************************************************
 715  * ImageList_DragShowNolock [COMCTL32.49]
 716  *
 717  * Shows or hides the drag image.
 718  *
 719  * PARAMS
 720  *     bShow [I] TRUE shows the drag image, FALSE hides it.
 721  *
 722  * RETURNS
 723  *     Success: TRUE
 724  *     Failure: FALSE
 725  *
 726  * FIXME
 727  *     semi-stub.
 728  */
 729
 730 BOOL WINAPI
 731 ImageList_DragShowNolock (BOOL bShow)
 732 {
 733     HDC hdcDrag;
 734
 735     FIXME("semi-stub!\n");
 736     TRACE("bShow=0x%X!\n", bShow);
 737
 738     hdcDrag = GetDCEx (hwndInternalDrag, 0,
 739                          DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
 740
 741     if (bShow) {
 742         /* show drag image */
 743
 744         /* save background */
 745
 746         /* draw drag image */
 747
 748     }
 749     else {
 750         /* hide drag image */
 751
 752         /* restore background */
 753
 754     }
 755
 756     ReleaseDC (hwndInternalDrag, hdcDrag);
 757
 758     return FALSE;
 759 }
 760
 761
 762 /*************************************************************************
 763  * ImageList_Draw [COMCTL32.50] Draws an image.
 764  *
 765  * PARAMS
 766  *     himl   [I] handle to image list
 767  *     i      [I] image index
 768  *     hdc    [I] handle to device context
 769  *     x      [I] x position
 770  *     y      [I] y position
 771  *     fStyle [I] drawing flags
 772  *
 773  * RETURNS
 774  *     Success: TRUE
 775  *     Failure: FALSE
 776  *
 777  * NOTES
 778  *     Calls ImageList_DrawIndirect.
 779  *
 780  * SEE
 781  *     ImageList_DrawIndirect.
 782  */
 783
 784 BOOL WINAPI
 785 ImageList_Draw (HIMAGELIST himl, INT i, HDC hdc,
 786                 INT x, INT y, UINT fStyle)
 787 {
 788     IMAGELISTDRAWPARAMS imldp;
 789
 790     imldp.cbSize  = sizeof(IMAGELISTDRAWPARAMS);
 791     imldp.himl    = himl;
 792     imldp.i       = i;
 793     imldp.hdcDst  = hdc,
 794     imldp.x       = x;
 795     imldp.y       = y;
 796     imldp.cx      = 0;
 797     imldp.cy      = 0;
 798     imldp.xBitmap = 0;
 799     imldp.yBitmap = 0;
 800     imldp.rgbBk   = CLR_DEFAULT;
 801     imldp.rgbFg   = CLR_DEFAULT;
 802     imldp.fStyle  = fStyle;
 803     imldp.dwRop   = 0;
 804
 805     return ImageList_DrawIndirect (&imldp);
 806 }
 807
 808
 809 /*************************************************************************
 810  * ImageList_DrawEx [COMCTL32.51]
 811  *
 812  * Draws an image and allows to use extended drawing features.
 813  *
 814  * PARAMS
 815  *     himl   [I] handle to image list
 816  *     i      [I] image index
 817  *     hdc    [I] handle to device context
 818  *     x      [I] X position
 819  *     y      [I] Y position
 820  *     xOffs  [I] X offset
 821  *     yOffs  [I] Y offset
 822  *     rgbBk  [I] background color
 823  *     rgbFg  [I] foreground color
 824  *     fStyle [I] drawing flags
 825  *
 826  * RETURNS
 827  *     Success: TRUE
 828  *     Failure: FALSE
 829  *
 830  * NOTES
 831  *     Calls ImageList_DrawIndirect.
 832  *
 833  * SEE
 834  *     ImageList_DrawIndirect.
 835  */
 836
 837 BOOL WINAPI
 838 ImageList_DrawEx (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y,
 839                   INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg,
 840                   UINT fStyle)
 841 {
 842     IMAGELISTDRAWPARAMS imldp;
 843
 844     imldp.cbSize  = sizeof(IMAGELISTDRAWPARAMS);
 845     imldp.himl    = himl;
 846     imldp.i       = i;
 847     imldp.hdcDst  = hdc,
 848     imldp.x       = x;
 849     imldp.y       = y;
 850     imldp.cx      = dx;
 851     imldp.cy      = dy;
 852     imldp.xBitmap = 0;
 853     imldp.yBitmap = 0;
 854     imldp.rgbBk   = rgbBk;
 855     imldp.rgbFg   = rgbFg;
 856     imldp.fStyle  = fStyle;
 857     imldp.dwRop   = 0;
 858
 859     return ImageList_DrawIndirect (&imldp);
 860 }
 861
 862
 863 /*************************************************************************
 864  * ImageList_DrawIndirect [COMCTL32.52]
 865  *
 866  * Draws an image using ...
 867  *
 868  * PARAMS
 869  *     pimldp [I] pointer to IMAGELISTDRAWPARAMS structure.
 870  *
 871  * RETURNS
 872  *     Success: TRUE
 873  *     Failure: FALSE
 874  */
 875
 876 BOOL WINAPI
 877 ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
 878 {
 879     HIMAGELIST himlLocal;
 880     HDC      hdcImageList, hdcTempImage;
 881     HBITMAP  hbmTempImage;
 882     HBRUSH   hBrush, hOldBrush;
 883     INT      cx, cy;
 884     INT      nOvlIdx;
 885     COLORREF   clrBlend;
 886     BOOL     bImage;       /* draw image ? */
 887     BOOL     bImageTrans;  /* draw image transparent ? */
 888     BOOL     bMask;        /* draw mask ? */
 889     BOOL     bMaskTrans;   /* draw mask transparent ? */
 890     BOOL     bBlend25;
 891     BOOL     bBlend50;
 892
 893     if (pimldp == NULL)
 894         return FALSE;
 895     if (pimldp->cbSize < sizeof(IMAGELISTDRAWPARAMS))
 896         return FALSE;
 897     if (pimldp->himl == NULL)
 898         return FALSE;
 899     if ((pimldp->i < 0) || (pimldp->i > pimldp->himl->cCurImage))
 900         return FALSE;
 901
 902     himlLocal = pimldp->himl;
 903
 904     cx = (pimldp->cx == 0) ? himlLocal->cx : pimldp->cx;
 905     cy = (pimldp->cy == 0) ? himlLocal->cy : pimldp->cy;
 906
 907     /* ILD_NORMAL state */
 908     bImage      = TRUE;
 909     bImageTrans = FALSE;
 910     bMask       = FALSE;
 911     bMaskTrans  = FALSE;
 912     bBlend25    = FALSE;
 913     bBlend50    = FALSE;
 914     if ((himlLocal->clrBk == CLR_NONE) && (himlLocal->hbmMask))
 915     {
 916         bImageTrans = TRUE;
 917         bMask = TRUE;
 918         bMaskTrans = TRUE;
 919     }
 920
 921     /* ILD_IMAGE state (changes) */
 922     if (pimldp->fStyle & ILD_IMAGE)
 923     {
 924         bMask = FALSE;
 925         bImage = TRUE;
 926         bImageTrans = FALSE;
 927     }
 928
 929     /* ILD_MASK state (changes) */
 930     if ((pimldp->fStyle & ILD_MASK) && (himlLocal->hbmMask))
 931     {
 932         bMask  = TRUE;
 933         bMaskTrans = FALSE;
 934         bImage = FALSE;
 935     }
 936     if ((pimldp->fStyle & ILD_TRANSPARENT) && (himlLocal->hbmMask))
 937     {
 938         bMaskTrans = TRUE;
 939         bImageTrans = TRUE;
 940     }
 941     if ((himlLocal->clrBk == CLR_NONE) && (himlLocal->hbmMask))
 942         bMaskTrans = TRUE;
 943
 944     if (pimldp->fStyle & ILD_BLEND50)
 945         bBlend50 = TRUE;
 946     else if (pimldp->fStyle & ILD_BLEND25)
 947         bBlend25 = TRUE;
 948
 949     hdcImageList = CreateCompatibleDC (0);
 950
 951     if (bMask)
 952     {
 953         /* draw the mask */
 954         SelectObject (hdcImageList, himlLocal->hbmMask);
 955         SetBkColor (hdcImageList, RGB(255, 255, 255));
 956         SetTextColor (hdcImageList, RGB(0, 0, 0));
 957         BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy,
 958                   hdcImageList, himlLocal->cx * pimldp->i, 0,
 959                   bMaskTrans ? SRCAND : SRCCOPY);
 960     }
 961
 962     if (bImage)
 963     {
 964         /* draw the image */
 965         SelectObject (hdcImageList, himlLocal->hbmImage);
 966
 967         if (!bImageTrans)
 968         {
 969             hBrush = CreateSolidBrush (himlLocal->clrBk);
 970             hOldBrush = SelectObject (pimldp->hdcDst, hBrush);
 971             PatBlt (pimldp->hdcDst, pimldp->x, pimldp->y,
 972                       cx, cy, PATCOPY);
 973             DeleteObject (SelectObject (pimldp->hdcDst, hOldBrush));
 974         }
 975
 976         BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy,
 977                   hdcImageList, himlLocal->cx * pimldp->i, 0, SRCPAINT);
 978
 979         if (bBlend25 || bBlend50)
 980         {
 981             if (pimldp->rgbFg == CLR_DEFAULT)
 982                 clrBlend = GetSysColor (COLOR_HIGHLIGHT);
 983             else
 984                 clrBlend = pimldp->rgbFg;
 985
 986             hdcTempImage = CreateCompatibleDC (0);
 987             hbmTempImage = CreateBitmap (himlLocal->cx, himlLocal->cy,
 988                                            1, himlLocal->uBitsPixel, NULL);
 989             SelectObject (hdcTempImage, hbmTempImage);
 990
 991
 992             /* mask */
 993             SelectObject (hdcTempImage,
 994                             bBlend50 ? himlLocal->hbrBlend50 : himlLocal->hbrBlend25);
 995             PatBlt (hdcTempImage, 0, 0, himlLocal->cx, himlLocal->cy, PATCOPY);
 996
 997             SelectObject (hdcImageList, himlLocal->hbmMask);
 998             BitBlt (hdcTempImage, 0, 0, himlLocal->cx,
 999                       himlLocal->cy, hdcImageList,
1000                       pimldp->i * himlLocal->cx, 0, SRCPAINT);
1001
1002             BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy,
1003                       hdcTempImage, 0, 0, SRCAND);
1004
1005             /* fill */
1006             hBrush = CreateSolidBrush (clrBlend);
1007             SelectObject (hdcTempImage, hBrush);
1008             PatBlt (hdcTempImage, 0, 0, himlLocal->cx, himlLocal->cy, PATCOPY);
1009             DeleteObject (hBrush);
1010
1011             SelectObject (hdcTempImage,
1012                             bBlend50 ? himlLocal->hbrBlend50 : himlLocal->hbrBlend25);
1013             PatBlt (hdcTempImage, 0, 0, himlLocal->cx, himlLocal->cy, 0x0A0329);
1014
1015             SelectObject (hdcImageList, himlLocal->hbmMask);
1016             BitBlt (hdcTempImage, 0, 0, himlLocal->cx,
1017                       himlLocal->cy, hdcImageList,
1018                       pimldp->i * himlLocal->cx, 0, SRCPAINT);
1019
1020             BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy,
1021                       hdcTempImage, 0, 0, SRCPAINT);
1022
1023             DeleteObject (hbmTempImage);
1024             DeleteDC (hdcTempImage);
1025         }
1026     }
1027
1028     /* Draw overlay image */
1029     if (pimldp->fStyle & 0x0700) {
1030         nOvlIdx = (pimldp->fStyle & 0x0700) >> 8;
1031         if ((nOvlIdx >= 1) && (nOvlIdx <= MAX_OVERLAYIMAGE)) {
1032             nOvlIdx = pimldp->himl->nOvlIdx[nOvlIdx - 1];
1033             if ((nOvlIdx >= 0) && (nOvlIdx <= pimldp->himl->cCurImage)) {
1034                 if (pimldp->himl->hbmMask) {
1035                     SelectObject (hdcImageList, pimldp->himl->hbmMask);
1036                     BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y, cx, cy,
1037                               hdcImageList, pimldp->himl->cx * nOvlIdx, 0,
1038                               SRCAND);
1039                 }
1040                 SelectObject (hdcImageList, pimldp->himl->hbmImage);
1041                 BitBlt (pimldp->hdcDst, pimldp->x, pimldp->y,
1042                           cx, cy, hdcImageList,
1043                           pimldp->himl->cx * nOvlIdx, 0, SRCPAINT);
1044             }
1045         }
1046     }
1047
1048     DeleteDC (hdcImageList);
1049
1050     return TRUE;
1051 }
1052
1053
1054 /*************************************************************************
1055  * ImageList_Duplicate [COMCTL32.53] Duplicates an image list.
1056  *
1057  * PARAMS
1058  *     himlSrc [I] source image list handle
1059  *
1060  * RETURNS
1061  *     Success: Handle of duplicated image list.
1062  *     Failure: NULL
1063  */
1064
1065 HIMAGELIST WINAPI
1066 ImageList_Duplicate (HIMAGELIST himlSrc)
1067 {
1068     HIMAGELIST himlDst;
1069     HDC hdcSrc, hdcDst;
1070
1071     if (himlSrc == NULL) {
1072         ERR("Invalid image list handle!\n");
1073         return NULL;
1074     }
1075
1076     himlDst = ImageList_Create (himlSrc->cx, himlSrc->cy, himlSrc->flags,
1077                                 himlSrc->cInitial, himlSrc->cGrow);
1078
1079     if (himlDst)
1080     {
1081         hdcSrc = CreateCompatibleDC (0);
1082         hdcDst = CreateCompatibleDC (0);
1083         SelectObject (hdcSrc, himlSrc->hbmImage);
1084         SelectObject (hdcDst, himlDst->hbmImage);
1085         BitBlt (hdcDst, 0, 0, himlSrc->cCurImage * himlSrc->cx, himlSrc->cy,
1086                   hdcSrc, 0, 0, SRCCOPY);
1087
1088         if (himlDst->hbmMask)
1089         {
1090             SelectObject (hdcSrc, himlSrc->hbmMask);
1091             SelectObject (hdcDst, himlDst->hbmMask);
1092             BitBlt (hdcDst, 0, 0, himlSrc->cCurImage * himlSrc->cx,
1093                       himlSrc->cy, hdcSrc, 0, 0, SRCCOPY);
1094         }
1095
1096         DeleteDC (hdcDst);
1097         DeleteDC (hdcSrc);
1098     }
1099
1100     return himlDst;
1101 }
1102
1103
1104 /*************************************************************************
1105  * ImageList_EndDrag [COMCTL32.54] Finishes a drag operation.
1106  *
1107  * Finishes a drag operation.
1108  *
1109  * PARAMS
1110  *     no Parameters
1111  *
1112  * RETURNS
1113  *     Success: TRUE
1114  *     Failure: FALSE
1115  *
1116  * BUGS
1117  *     semi-stub.
1118  */
1119
1120 BOOL WINAPI
1121 ImageList_EndDrag (void)
1122 {
1123     FIXME("semi-stub!\n");
1124
1125     if (himlInternalDrag)
1126     {
1127
1128         ImageList_Destroy (himlInternalDrag);
1129         himlInternalDrag = NULL;
1130
1131         nInternalDragHotspotX = 0;
1132         nInternalDragHotspotY = 0;
1133
1134     }
1135
1136     return TRUE;
1137 }
1138
1139
1140 /*************************************************************************
1141  * ImageList_GetBkColor [COMCTL32.55]
1142  *
1143  * Returns the background color of an image list.
1144  *
1145  * PARAMS
1146  *     himl [I] Image list handle.
1147  *
1148  * RETURNS
1149  *     Success: background color
1150  *     Failure: CLR_NONE
1151  */
1152
1153 COLORREF WINAPI
1154 ImageList_GetBkColor (HIMAGELIST himl)
1155 {
1156     if (himl == NULL)
1157         return CLR_NONE;
1158
1159     return himl->clrBk;
1160 }
1161
1162
1163 /*************************************************************************
1164  * ImageList_GetDragImage [COMCTL32.56]
1165  *
1166  * Returns the handle to the internal drag image list.
1167  *
1168  * PARAMS
1169  *     ppt        [O] Pointer to the drag position. Can be NULL.
1170  *     pptHotspot [O] Pointer to the position of the hot spot. Can be NULL.
1171  *
1172  * RETURNS
1173  *     Success: Handle of the drag image list.
1174  *     Failure: NULL.
1175  *
1176  * BUGS
1177  *     semi-stub.
1178  */
1179
1180 HIMAGELIST WINAPI
1181 ImageList_GetDragImage (POINT *ppt, POINT *pptHotspot)
1182 {
1183     FIXME("semi-stub!\n");
1184
1185     if (himlInternalDrag)
1186         return (himlInternalDrag);
1187
1188     return NULL;
1189 }
1190
1191
1192 /*************************************************************************
1193  * ImageList_GetIcon [COMCTL32.57]
1194  *
1195  * Creates an icon from a masked image of an image list.
1196  *
1197  * PARAMS
1198  *     himl  [I] handle to image list
1199  *     i     [I] image index
1200  *     flags [I] drawing style flags
1201  *
1202  * RETURNS
1203  *     Success: icon handle
1204  *     Failure: NULL
1205  */
1206
1207 HICON WINAPI
1208 ImageList_GetIcon (HIMAGELIST himl, INT i, UINT fStyle)
1209 {
1210     ICONINFO ii;
1211     HICON  hIcon;
1212     HDC    hdcSrc, hdcDst;
1213
1214     if ((himl == NULL) || (i < 0) || (i >= himl->cCurImage))
1215         return 0;
1216
1217     hdcSrc = CreateCompatibleDC(0);
1218     hdcDst = CreateCompatibleDC(0);
1219
1220     ii.fIcon = TRUE;
1221     ii.hbmMask  = CreateCompatibleBitmap (hdcDst, himl->cx, himl->cy);
1222     ii.hbmColor = CreateCompatibleBitmap (hdcDst, himl->cx, himl->cy);
1223
1224
1225     /* draw mask*/
1226     SelectObject (hdcDst, ii.hbmMask);
1227     if (himl->hbmMask) {
1228         SelectObject (hdcSrc, himl->hbmMask);
1229         BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1230                   hdcSrc, i * himl->cx, 0, SRCCOPY);
1231     }
1232     else
1233         PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
1234
1235     /* draw image*/
1236     SelectObject (hdcDst, ii.hbmColor);
1237     SelectObject (hdcSrc, himl->hbmImage);
1238     BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
1239               hdcSrc, i * himl->cx, 0, SRCCOPY);
1240
1241     hIcon = CreateIconIndirect (&ii);
1242
1243     DeleteDC (hdcSrc);
1244     DeleteDC (hdcDst);
1245     DeleteObject (ii.hbmMask);
1246     DeleteObject (ii.hbmColor);
1247
1248     return hIcon;
1249 }
1250
1251
1252 /*************************************************************************
1253  * ImageList_GetIconSize [COMCTL32.58]
1254  *
1255  * Retrieves the size of an image in an image list.
1256  *
1257  * PARAMS
1258  *     himl [I] handle to image list
1259  *     cx   [O] pointer to the image width.
1260  *     cy   [O] pointer to the image height.
1261  *
1262  * RETURNS
1263  *     Success: TRUE
1264  *     Failure: FALSE
1265  *
1266  * NOTES
1267  *     All images in an image list have the same size.
1268  */
1269
1270 BOOL WINAPI
1271 ImageList_GetIconSize (HIMAGELIST himl, INT *cx, INT *cy)
1272 {
1273     if (himl == NULL)
1274         return FALSE;
1275     if ((himl->cx <= 0) || (himl->cy <= 0))
1276         return FALSE;
1277
1278     if (cx)
1279         *cx = himl->cx;
1280     if (cy)
1281         *cy = himl->cy;
1282
1283     return TRUE;
1284 }
1285
1286
1287 /*************************************************************************
1288  * ImageList_GetImageCount [COMCTL32.59]
1289  *
1290  * Returns the number of images in an image list.
1291  *
1292  * PARAMS
1293  *     himl [I] handle to image list
1294  *
1295  * RETURNS
1296  *     Success: Number of images.
1297  *     Failure: 0
1298  */
1299
1300 INT WINAPI
1301 ImageList_GetImageCount (HIMAGELIST himl)
1302 {
1303     if (himl == NULL)
1304         return 0;
1305
1306     return himl->cCurImage;
1307 }
1308
1309
1310 /*************************************************************************
1311  * ImageList_GetImageInfo [COMCTL32.60]
1312  *
1313  * Returns information about an image in an image list.
1314  *
1315  * PARAMS
1316  *     himl       [I] handle to image list
1317  *     i          [I] image index
1318  *     pImageInfo [O] pointer to the image information
1319  *
1320  * RETURNS
1321  *     Success: TRUE
1322  *     Failure: FALSE
1323  */
1324
1325 BOOL WINAPI
1326 ImageList_GetImageInfo (HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
1327 {
1328     if ((himl == NULL) || (pImageInfo == NULL))
1329         return FALSE;
1330     if ((i < 0) || (i >= himl->cCurImage))
1331         return FALSE;
1332
1333     pImageInfo->hbmImage = himl->hbmImage;
1334     pImageInfo->hbmMask  = himl->hbmMask;
1335
1336     pImageInfo->rcImage.top    = 0;
1337     pImageInfo->rcImage.bottom = himl->cy;
1338     pImageInfo->rcImage.left   = i * himl->cx;
1339     pImageInfo->rcImage.right  = (i+1) * himl->cx;
1340
1341     return TRUE;
1342 }
1343
1344
1345 /*************************************************************************
1346  * ImageList_GetImageRect [COMCTL32.61]
1347  *
1348  * Retrieves the rectangle of the specified image in an image list.
1349  *
1350  * PARAMS
1351  *     himl   [I] handle to image list
1352  *     i      [I] image index
1353  *     lpRect [O] pointer to the image rectangle
1354  *
1355  * RETURNS
1356  *    Success: TRUE
1357  *    Failure: FALSE
1358  *
1359  * NOTES
1360  *    This is an UNDOCUMENTED function!!!
1361  */
1362
1363 BOOL WINAPI
1364 ImageList_GetImageRect (HIMAGELIST himl, INT i, LPRECT lpRect)
1365 {
1366     if ((himl == NULL) || (lpRect == NULL))
1367         return FALSE;
1368     if ((i < 0) || (i >= himl->cCurImage))
1369         return FALSE;
1370
1371     lpRect->left   = i * himl->cx;
1372     lpRect->top    = 0;
1373     lpRect->right  = lpRect->left + himl->cx;
1374     lpRect->bottom = himl->cy;
1375
1376     return TRUE;
1377 }
1378
1379
1380 /*************************************************************************
1381  * ImageList_LoadImage32A [COMCTL32.63][COMCTL32.62]
1382  *
1383  * Creates an image list from a bitmap, icon or cursor.
1384  *
1385  * PARAMS
1386  *     hi      [I] instance handle
1387  *     lpbmp   [I] name or id of the image
1388  *     cx      [I] width of each image
1389  *     cGrow   [I] number of images to expand
1390  *     clrMask [I] mask color
1391  *     uType   [I] type of image to load
1392  *     uFlags  [I] loading flags
1393  *
1394  * RETURNS
1395  *     Success: handle to the loaded image list
1396  *     Failure: NULL
1397  *
1398  * SEE
1399  *     LoadImage ()
1400  */
1401
1402 HIMAGELIST WINAPI
1403 ImageList_LoadImageA (HINSTANCE hi, LPCSTR lpbmp, INT cx,       INT cGrow,
1404                         COLORREF clrMask, UINT uType,   UINT uFlags)
1405 {
1406     HIMAGELIST himl = NULL;
1407     HANDLE   handle;
1408     INT      nImageCount;
1409
1410     handle = LoadImageA (hi, lpbmp, uType, 0, 0, uFlags);
1411     if (!handle) {
1412         ERR("Error loading image!\n");
1413         return NULL;
1414     }
1415
1416     if (uType == IMAGE_BITMAP) {
1417         BITMAP bmp;
1418         GetObjectA (handle, sizeof(BITMAP), &bmp);
1419         nImageCount = bmp.bmWidth / cx;
1420
1421         himl = ImageList_Create (cx, bmp.bmHeight, ILC_MASK | ILC_COLOR,
1422                                  nImageCount, cGrow);
1423         ImageList_AddMasked (himl, (HBITMAP)handle, clrMask);
1424     }
1425     else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
1426         ICONINFO ii;
1427         BITMAP bmp;
1428
1429         GetIconInfo (handle, &ii);
1430         GetObjectA (ii.hbmColor, sizeof(BITMAP), (LPVOID)&bmp);
1431         himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
1432                                  ILC_MASK | ILC_COLOR, 1, cGrow);
1433         ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
1434         DeleteObject (ii.hbmColor);
1435         DeleteObject (ii.hbmMask);
1436     }
1437
1438     DeleteObject (handle);
1439
1440     return himl;
1441 }
1442
1443
1444 /*************************************************************************
1445  * ImageList_LoadImage32W [COMCTL32.64]
1446  *
1447  * Creates an image list from a bitmap, icon or cursor.
1448  *
1449  * PARAMS
1450  *     hi      [I] instance handle
1451  *     lpbmp   [I] name or id of the image
1452  *     cx      [I] width of each image
1453  *     cGrow   [I] number of images to expand
1454  *     clrMask [I] mask color
1455  *     uType   [I] type of image to load
1456  *     uFlags  [I] loading flags
1457  *
1458  * RETURNS
1459  *     Success: handle to the loaded image list
1460  *     Failure: NULL
1461  *
1462  * SEE
1463  *     LoadImage ()
1464  */
1465
1466 HIMAGELIST WINAPI
1467 ImageList_LoadImageW (HINSTANCE hi, LPCWSTR lpbmp, INT cx, INT cGrow,
1468                         COLORREF clrMask, UINT uType,   UINT uFlags)
1469 {
1470     HIMAGELIST himl = NULL;
1471     HANDLE   handle;
1472     INT      nImageCount;
1473
1474     handle = LoadImageW (hi, lpbmp, uType, 0, 0, uFlags);
1475     if (!handle) {
1476         ERR("Error loading image!\n");
1477         return NULL;
1478     }
1479
1480     if (uType == IMAGE_BITMAP) {
1481         BITMAP bmp;
1482         GetObjectA (handle, sizeof(BITMAP), &bmp);
1483         nImageCount = bmp.bmWidth / cx;
1484
1485         himl = ImageList_Create (cx, bmp.bmHeight, ILC_MASK | ILC_COLOR,
1486                                  nImageCount, cGrow);
1487         ImageList_AddMasked (himl, (HBITMAP)handle, clrMask);
1488     }
1489     else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
1490         ICONINFO ii;
1491         BITMAP bmp;
1492
1493         GetIconInfo (handle, &ii);
1494         GetObjectA (ii.hbmMask, sizeof(BITMAP), (LPVOID)&bmp);
1495         himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
1496                                  ILC_MASK | ILC_COLOR, 1, cGrow);
1497         ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
1498         DeleteObject (ii.hbmColor);
1499         DeleteObject (ii.hbmMask);
1500     }
1501
1502     DeleteObject (handle);
1503
1504     return himl;
1505 }
1506
1507
1508 /*************************************************************************
1509  * ImageList_Merge [COMCTL32.65]
1510  *
1511  * Creates a new image list that contains a merged image from the specified
1512  * images of both source image lists.
1513  *
1514  * PARAMS
1515  *     himl1 [I] handle to first image list
1516  *     i1    [I] first image index
1517  *     himl2 [I] handle to second image list
1518  *     i2    [I] second image index
1519  *     dx    [I] X offset of the second image relative to the first.
1520  *     dy    [I] Y offset of the second image relative to the first.
1521  *
1522  * RETURNS
1523  *     Success: handle of the merged image list.
1524  *     Failure: NULL
1525  */
1526
1527 HIMAGELIST WINAPI
1528 ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2,
1529                  INT dx, INT dy)
1530 {
1531     HIMAGELIST himlDst = NULL;
1532     HDC      hdcSrcImage, hdcDstImage;
1533     INT      cxDst, cyDst;
1534     INT      xOff1, yOff1, xOff2, yOff2;
1535     INT      nX1, nX2;
1536
1537     if ((himl1 == NULL) || (himl2 == NULL))
1538         return NULL;
1539
1540     /* check indices */
1541     if ((i1 < 0) || (i1 >= himl1->cCurImage)) {
1542         ERR("Index 1 out of range! %d\n", i1);
1543         return NULL;
1544     }
1545
1546     if ((i2 < 0) || (i2 >= himl2->cCurImage)) {
1547         ERR("Index 2 out of range! %d\n", i2);
1548         return NULL;
1549     }
1550
1551     if (dx > 0) {
1552         cxDst = _MAX (himl1->cx, dx + himl2->cx);
1553         xOff1 = 0;
1554         xOff2 = dx;
1555     }
1556     else if (dx < 0) {
1557         cxDst = _MAX (himl2->cx, himl1->cx - dx);
1558         xOff1 = -dx;
1559         xOff2 = 0;
1560     }
1561     else {
1562         cxDst = _MAX (himl1->cx, himl2->cx);
1563         xOff1 = 0;
1564         xOff2 = 0;
1565     }
1566
1567     if (dy > 0) {
1568         cyDst = _MAX (himl1->cy, dy + himl2->cy);
1569         yOff1 = 0;
1570         yOff2 = dy;
1571     }
1572     else if (dy < 0) {
1573         cyDst = _MAX (himl2->cy, himl1->cy - dy);
1574         yOff1 = -dy;
1575         yOff2 = 0;
1576     }
1577     else {
1578         cyDst = _MAX (himl1->cy, himl2->cy);
1579         yOff1 = 0;
1580         yOff2 = 0;
1581     }
1582
1583     himlDst = ImageList_Create (cxDst, cyDst, ILC_MASK | ILC_COLOR, 1, 1);
1584
1585     if (himlDst) {
1586         hdcSrcImage = CreateCompatibleDC (0);
1587         hdcDstImage = CreateCompatibleDC (0);
1588         nX1 = i1 * himl1->cx;
1589         nX2 = i2 * himl2->cx;
1590
1591         /* copy image */
1592         SelectObject (hdcSrcImage, himl1->hbmImage);
1593         SelectObject (hdcDstImage, himlDst->hbmImage);
1594         BitBlt (hdcDstImage, 0, 0, cxDst, cyDst,
1595                   hdcSrcImage, 0, 0, BLACKNESS);
1596         BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy,
1597                   hdcSrcImage, nX1, 0, SRCCOPY);
1598
1599         SelectObject (hdcSrcImage, himl2->hbmMask);
1600         BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
1601                   hdcSrcImage, nX2, 0, SRCAND);
1602
1603         SelectObject (hdcSrcImage, himl2->hbmImage);
1604         BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
1605                   hdcSrcImage, nX2, 0, SRCPAINT);
1606
1607         /* copy mask */
1608         SelectObject (hdcSrcImage, himl1->hbmMask);
1609         SelectObject (hdcDstImage, himlDst->hbmMask);
1610         BitBlt (hdcDstImage, 0, 0, cxDst, cyDst,
1611                   hdcSrcImage, 0, 0, WHITENESS);
1612         BitBlt (hdcDstImage, xOff1, yOff1, himl1->cx, himl1->cy,
1613                   hdcSrcImage, nX1, 0, SRCCOPY);
1614
1615         SelectObject (hdcSrcImage, himl2->hbmMask);
1616         BitBlt (hdcDstImage, xOff2, yOff2, himl2->cx, himl2->cy,
1617                   hdcSrcImage, nX2, 0, SRCAND);
1618
1619         DeleteDC (hdcSrcImage);
1620         DeleteDC (hdcDstImage);
1621     }
1622
1623     return himlDst;
1624 }
1625
1626
1627 /*************************************************************************
1628  * ImageList_Read [COMCTL32.66]
1629  *
1630  * Reads an image list from a stream.
1631  *
1632  * PARAMS
1633  *     pstm [I] pointer to a stream
1634  *
1635  * RETURNS
1636  *     Success: handle to image list
1637  *     Failure: NULL
1638  *
1639  * NOTES
1640  *     This function can not be implemented yet, because
1641  *     IStream32::Read is not implemented yet.
1642  *
1643  * BUGS
1644  *     empty stub.
1645  */
1646
1647 HIMAGELIST WINAPI ImageList_Read (LPSTREAM pstm)
1648 {
1649     FIXME("empty stub!\n");
1650
1651
1652     return NULL;
1653 }
1654
1655
1656 /*************************************************************************
1657  * ImageList_Remove [COMCTL32.67] Removes an image from an image list
1658  *
1659  * PARAMS
1660  *     himl [I] image list handle
1661  *     i    [I] image index
1662  *
1663  * RETURNS
1664  *     Success: TRUE
1665  *     Failure: FALSE
1666  */
1667
1668 BOOL WINAPI
1669 ImageList_Remove (HIMAGELIST himl, INT i)
1670 {
1671     HBITMAP hbmNewImage, hbmNewMask;
1672     HDC     hdcSrc, hdcDst;
1673     INT     cxNew, nCount;
1674
1675     if ((i < -1) || (i >= himl->cCurImage)) {
1676         ERR("index out of range! %d\n", i);
1677         return FALSE;
1678     }
1679
1680     if (himl->cCurImage == 0) {
1681         ERR("image list is already empty!\n");
1682         return FALSE;
1683     }
1684
1685     if (i == -1) {
1686         /* remove all */
1687         TRACE("remove all!\n");
1688
1689         himl->cMaxImage = himl->cInitial + himl->cGrow;
1690         himl->cCurImage = 0;
1691         for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
1692              himl->nOvlIdx[nCount] = -1;
1693
1694         DeleteObject (himl->hbmImage);
1695         himl->hbmImage =
1696             CreateBitmap (himl->cMaxImage * himl->cx, himl->cy,
1697                             1, himl->uBitsPixel, NULL);
1698
1699         if (himl->hbmMask) {
1700             DeleteObject (himl->hbmMask);
1701             himl->hbmMask =
1702                 CreateBitmap (himl->cMaxImage * himl->cx, himl->cy,
1703                                 1, 1, NULL);
1704         }
1705     }
1706     else {
1707         /* delete one image */
1708         TRACE("Remove single image! %d\n", i);
1709
1710         /* create new bitmap(s) */
1711         cxNew = (himl->cCurImage + himl->cGrow - 1) * himl->cx;
1712
1713         TRACE(" - Number of images: %d / %d (Old/New)\n",
1714                  himl->cCurImage, himl->cCurImage - 1);
1715         TRACE(" - Max. number of images: %d / %d (Old/New)\n",
1716                  himl->cMaxImage, himl->cCurImage + himl->cGrow - 1);
1717
1718         hbmNewImage =
1719             CreateBitmap (cxNew, himl->cy, 1, himl->uBitsPixel, NULL);
1720
1721         if (himl->hbmMask)
1722             hbmNewMask = CreateBitmap (cxNew, himl->cy, 1, 1, NULL);
1723         else
1724             hbmNewMask = 0;  /* Just to keep compiler happy! */
1725
1726         hdcSrc = CreateCompatibleDC (0);
1727         hdcDst = CreateCompatibleDC (0);
1728
1729         /* copy all images and masks prior to the "removed" image */
1730         if (i > 0) {
1731             TRACE("Pre image copy: Copy %d images\n", i);
1732
1733             SelectObject (hdcSrc, himl->hbmImage);
1734             SelectObject (hdcDst, hbmNewImage);
1735             BitBlt (hdcDst, 0, 0, i * himl->cx, himl->cy,
1736                       hdcSrc, 0, 0, SRCCOPY);
1737
1738             if (himl->hbmMask) {
1739                 SelectObject (hdcSrc, himl->hbmMask);
1740                 SelectObject (hdcDst, hbmNewMask);
1741                 BitBlt (hdcDst, 0, 0, i * himl->cx, himl->cy,
1742                           hdcSrc, 0, 0, SRCCOPY);
1743             }
1744         }
1745
1746         /* copy all images and masks behind the removed image */
1747         if (i < himl->cCurImage - 1) {
1748             TRACE("Post image copy!\n");
1749             SelectObject (hdcSrc, himl->hbmImage);
1750             SelectObject (hdcDst, hbmNewImage);
1751             BitBlt (hdcDst, i * himl->cx, 0, (himl->cCurImage - i - 1) * himl->cx,
1752                       himl->cy, hdcSrc, (i + 1) * himl->cx, 0, SRCCOPY);
1753
1754             if (himl->hbmMask) {
1755                 SelectObject (hdcSrc, himl->hbmMask);
1756                 SelectObject (hdcDst, hbmNewMask);
1757                 BitBlt (hdcDst, i * himl->cx, 0,
1758                           (himl->cCurImage - i - 1) * himl->cx,
1759                           himl->cy, hdcSrc, (i + 1) * himl->cx, 0, SRCCOPY);
1760             }
1761         }
1762
1763         DeleteDC (hdcSrc);
1764         DeleteDC (hdcDst);
1765
1766         /* delete old images and insert new ones */
1767         DeleteObject (himl->hbmImage);
1768         himl->hbmImage = hbmNewImage;
1769         if (himl->hbmMask) {
1770             DeleteObject (himl->hbmMask);
1771             himl->hbmMask = hbmNewMask;
1772         }
1773
1774         himl->cCurImage--;
1775         himl->cMaxImage = himl->cCurImage + himl->cGrow;
1776     }
1777
1778     return TRUE;
1779 }
1780
1781
1782 /*************************************************************************
1783  * ImageList_Replace [COMCTL32.68]
1784  *
1785  * Replaces an image in an image list with a new image.
1786  *
1787  * PARAMS
1788  *     himl     [I] handle to image list
1789  *     i        [I] image index
1790  *     hbmImage [I] handle to image bitmap
1791  *     hbmMask  [I] handle to mask bitmap. Can be NULL.
1792  *
1793  * RETURNS
1794  *     Success: TRUE
1795  *     Failure: FALSE
1796  */
1797
1798 BOOL WINAPI
1799 ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage,
1800                    HBITMAP hbmMask)
1801 {
1802     HDC hdcImageList, hdcImage;
1803     BITMAP bmp;
1804
1805     if (himl == NULL) {
1806         ERR("Invalid image list handle!\n");
1807         return FALSE;
1808     }
1809
1810     if ((i >= himl->cCurImage) || (i < 0)) {
1811         ERR("Invalid image index!\n");
1812         return FALSE;
1813     }
1814
1815     hdcImageList = CreateCompatibleDC (0);
1816     hdcImage = CreateCompatibleDC (0);
1817     GetObjectA (hbmImage, sizeof(BITMAP), (LPVOID)&bmp);
1818
1819     /* Replace Image */
1820     SelectObject (hdcImageList, himl->hbmImage);
1821     SelectObject (hdcImage, hbmImage);
1822
1823     StretchBlt (hdcImageList, i * himl->cx, 0, himl->cx, himl->cy,
1824                   hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
1825
1826     if (himl->hbmMask)
1827     {
1828         /* Replace Mask */
1829         SelectObject (hdcImageList, himl->hbmMask);
1830         SelectObject (hdcImage, hbmMask);
1831
1832         StretchBlt (hdcImageList, i * himl->cx, 0, himl->cx, himl->cy,
1833                       hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
1834     }
1835
1836     DeleteDC (hdcImage);
1837     DeleteDC (hdcImageList);
1838
1839     return TRUE;
1840 }
1841
1842
1843 /*************************************************************************
1844  * ImageList_ReplaceIcon [COMCTL32.69]
1845  *
1846  * Replaces an image in an image list using an icon.
1847  *
1848  * PARAMS
1849  *     himl  [I] handle to image list
1850  *     i     [I] image index
1851  *     hIcon [I] handle to icon
1852  *
1853  * RETURNS
1854  *     Success: index of the replaced image
1855  *     Failure: -1
1856  */
1857
1858 INT WINAPI
1859 ImageList_ReplaceIcon (HIMAGELIST himl, INT i, HICON hIcon)
1860 {
1861     HDC     hdcImageList, hdcImage;
1862     INT     nIndex;
1863     HBITMAP hbmOldSrc, hbmOldDst;
1864     ICONINFO  ii;
1865     BITMAP  bmp;
1866
1867     TRACE("(0x%lx 0x%x 0x%x)\n", (DWORD)himl, i, hIcon);
1868
1869     if (himl == NULL)
1870         return -1;
1871     if ((i >= himl->cCurImage) || (i < -1))
1872         return -1;
1873
1874     GetIconInfo (hIcon, &ii);
1875     if (ii.hbmMask == 0)
1876         ERR("no mask!\n");
1877     if (ii.hbmColor == 0)
1878         ERR("no color!\n");
1879     GetObjectA (ii.hbmMask, sizeof(BITMAP), (LPVOID)&bmp);
1880
1881     if (i == -1) {
1882         if (himl->cCurImage + 1 >= himl->cMaxImage)
1883             IMAGELIST_InternalExpandBitmaps (himl, 1);
1884
1885         nIndex = himl->cCurImage;
1886         himl->cCurImage++;
1887     }
1888     else
1889         nIndex = i;
1890
1891     hdcImageList = CreateCompatibleDC (0);
1892     TRACE("hdcImageList=0x%x!\n", hdcImageList);
1893     if (hdcImageList == 0)
1894         ERR("invalid hdcImageList!\n");
1895
1896     hdcImage = CreateCompatibleDC (0);
1897     TRACE("hdcImage=0x%x!\n", hdcImage);
1898     if (hdcImage == 0)
1899         ERR("invalid hdcImage!\n");
1900
1901     hbmOldDst = SelectObject (hdcImageList, himl->hbmImage);
1902     SetTextColor( hdcImageList, RGB(0,0,0));
1903     SetBkColor( hdcImageList, RGB(255,255,255));
1904     hbmOldSrc = SelectObject (hdcImage, ii.hbmColor);
1905     StretchBlt (hdcImageList, nIndex * himl->cx, 0, himl->cx, himl->cy,
1906                   hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
1907
1908     if (himl->hbmMask) {
1909         SelectObject (hdcImageList, himl->hbmMask);
1910         SelectObject (hdcImage, ii.hbmMask);
1911         StretchBlt (hdcImageList, nIndex * himl->cx, 0, himl->cx, himl->cy,
1912                       hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
1913     }
1914
1915     SelectObject (hdcImage, hbmOldSrc);
1916     SelectObject (hdcImageList, hbmOldDst);
1917
1918     if (hdcImageList)
1919         DeleteDC (hdcImageList);
1920     if (hdcImage)
1921         DeleteDC (hdcImage);
1922     if (ii.hbmColor)
1923         DeleteObject (ii.hbmColor);
1924     if (ii.hbmMask)
1925         DeleteObject (ii.hbmMask);
1926
1927     return nIndex;
1928 }
1929
1930
1931 /*************************************************************************
1932  * ImageList_SetBkColor [COMCTL32.70]
1933  *
1934  * Sets the background color of an image list.
1935  *
1936  * PARAMS
1937  *     himl  [I] handle to image list
1938  *     clrBk [I] background color
1939  *
1940  * RETURNS
1941  *     Success: previous background color
1942  *     Failure: CLR_NONE
1943  */
1944
1945 COLORREF WINAPI
1946 ImageList_SetBkColor (HIMAGELIST himl, COLORREF clrBk)
1947 {
1948     COLORREF clrOldBk;
1949
1950     if (himl == NULL)
1951         return CLR_NONE;
1952
1953     clrOldBk = himl->clrBk;
1954     himl->clrBk = clrBk;
1955     return clrOldBk;
1956 }
1957
1958
1959 /*************************************************************************
1960  * ImageList_SetDragCursorImage [COMCTL32.75]
1961  *
1962  * Combines the specified image with the current drag image
1963  *
1964  * PARAMS
1965  *     himlDrag  [I] handle to drag image list
1966  *     iDrag     [I] drag image index
1967  *     dxHotspot [I] X position of the hot spot
1968  *     dyHotspot [I] Y position of the hot spot
1969  *
1970  * RETURNS
1971  *     Success: TRUE
1972  *     Failure: FALSE
1973  *
1974  * BUGS
1975  *     semi-stub.
1976  */
1977
1978 BOOL WINAPI
1979 ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag,
1980                               INT dxHotspot, INT dyHotspot)
1981 {
1982     HIMAGELIST himlTemp;
1983
1984     FIXME("semi-stub!\n");
1985
1986     if (himlInternalDrag == NULL)
1987         return FALSE;
1988
1989     TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
1990            dxHotspot, dyHotspot, nInternalDragHotspotX, nInternalDragHotspotY);
1991
1992     himlTemp = ImageList_Merge (himlInternalDrag, 0, himlDrag, iDrag,
1993                                 dxHotspot, dyHotspot);
1994
1995     ImageList_Destroy (himlInternalDrag);
1996     himlInternalDrag = himlTemp;
1997
1998     nInternalDragHotspotX = dxHotspot;
1999     nInternalDragHotspotY = dyHotspot;
2000
2001     return FALSE;
2002 }
2003
2004
2005 /*************************************************************************
2006  * ImageList_SetFilter [COMCTL32.76]
2007  *
2008  * Sets a filter (or does something completely different)!!???
2009  *
2010  * PARAMS
2011  *     himl     [I] handle to image list
2012  *     i        [I] ???
2013  *     dwFilter [I] ???
2014  *
2015  * RETURNS
2016  *     Success: TRUE ???
2017  *     Failure: FALSE ???
2018  *
2019  * BUGS
2020  *     This is an UNDOCUMENTED function!!!!
2021  *     empty stub.
2022  */
2023
2024 BOOL WINAPI
2025 ImageList_SetFilter (HIMAGELIST himl, INT i, DWORD dwFilter)
2026 {
2027     FIXME("(%p 0x%x 0x%lx):empty stub!\n",
2028            himl, i, dwFilter);
2029
2030     return FALSE;
2031 }
2032
2033
2034 /*************************************************************************
2035  * ImageList_SetIconSize [COMCTL32.77]
2036  *
2037  * Sets the image size of the bitmap and deletes all images.
2038  *
2039  * PARAMS
2040  *     himl [I] handle to image list
2041  *     cx   [I] image width
2042  *     cy   [I] image height
2043  *
2044  * RETURNS
2045  *     Success: TRUE
2046  *     Failure: FALSE
2047  */
2048
2049 BOOL WINAPI
2050 ImageList_SetIconSize (HIMAGELIST himl, INT cx, INT cy)
2051 {
2052     INT nCount;
2053
2054     if (!himl)
2055         return FALSE;
2056
2057     /* remove all images*/
2058     himl->cMaxImage = himl->cInitial + himl->cGrow;
2059     himl->cCurImage = 0;
2060     himl->cx        = cx;
2061     himl->cy        = cy;
2062
2063     /* initialize overlay mask indices */
2064     for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
2065         himl->nOvlIdx[nCount] = -1;
2066
2067     DeleteObject (himl->hbmImage);
2068     himl->hbmImage =
2069         CreateBitmap (himl->cMaxImage * himl->cx, himl->cy,
2070                         1, himl->uBitsPixel, NULL);
2071
2072     if (himl->hbmMask) {
2073         DeleteObject (himl->hbmMask);
2074         himl->hbmMask =
2075             CreateBitmap (himl->cMaxImage * himl->cx, himl->cy,
2076                             1, 1, NULL);
2077     }
2078
2079     return TRUE;
2080 }
2081
2082
2083 /*************************************************************************
2084  * ImageList_SetImageCount [COMCTL32.78]
2085  *
2086  * Resizes an image list to the specified number of images.
2087  *
2088  * PARAMS
2089  *     himl        [I] handle to image list
2090  *     iImageCount [I] number of images in the image list
2091  *
2092  * RETURNS
2093  *     Success: TRUE
2094  *     Failure: FALSE
2095  */
2096
2097 BOOL WINAPI
2098 ImageList_SetImageCount (HIMAGELIST himl, INT iImageCount)
2099 {
2100     HDC     hdcImageList, hdcBitmap;
2101     HBITMAP hbmNewBitmap;
2102     INT     nNewCount, nCopyCount;
2103
2104     if (!himl)
2105         return FALSE;
2106     if (himl->cCurImage >= iImageCount)
2107         return FALSE;
2108     if (himl->cMaxImage > iImageCount)
2109         return TRUE;
2110
2111     nNewCount = iImageCount + himl->cGrow;
2112     nCopyCount = _MIN(himl->cCurImage, iImageCount);
2113
2114     hdcImageList = CreateCompatibleDC (0);
2115     hdcBitmap = CreateCompatibleDC (0);
2116
2117     hbmNewBitmap = CreateBitmap (nNewCount * himl->cx, himl->cy,
2118                                    1, himl->uBitsPixel, NULL);
2119     if (hbmNewBitmap != 0)
2120     {
2121         SelectObject (hdcImageList, himl->hbmImage);
2122         SelectObject (hdcBitmap, hbmNewBitmap);
2123
2124         /* copy images */
2125         BitBlt (hdcBitmap, 0, 0, nCopyCount * himl->cx, himl->cy,
2126                   hdcImageList, 0, 0, SRCCOPY);
2127
2128         /* delete 'empty' image space */
2129         SetBkColor (hdcBitmap, RGB(255, 255, 255));
2130         SetTextColor (hdcBitmap, RGB(0, 0, 0));
2131         PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0,
2132                   (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
2133
2134         DeleteObject (himl->hbmImage);
2135         himl->hbmImage = hbmNewBitmap;
2136     }
2137     else
2138         ERR("Could not create new image bitmap !\n");
2139
2140     if (himl->hbmMask)
2141     {
2142         hbmNewBitmap = CreateBitmap (nNewCount * himl->cx, himl->cy,
2143                                        1, 1, NULL);
2144         if (hbmNewBitmap != 0)
2145         {
2146             SelectObject (hdcImageList, himl->hbmMask);
2147             SelectObject (hdcBitmap, hbmNewBitmap);
2148
2149             /* copy images */
2150             BitBlt (hdcBitmap, 0, 0, nCopyCount * himl->cx, himl->cy,
2151                       hdcImageList, 0, 0, SRCCOPY);
2152
2153             /* delete 'empty' image space */
2154             SetBkColor (hdcBitmap, RGB(255, 255, 255));
2155             SetTextColor (hdcBitmap, RGB(0, 0, 0));
2156             PatBlt (hdcBitmap,  nCopyCount * himl->cx, 0,
2157                       (nNewCount - nCopyCount) * himl->cx, himl->cy, BLACKNESS);
2158
2159             DeleteObject (himl->hbmMask);
2160             himl->hbmMask = hbmNewBitmap;
2161         }
2162         else
2163             ERR("Could not create new mask bitmap!\n");
2164     }
2165
2166     DeleteDC (hdcImageList);
2167     DeleteDC (hdcBitmap);
2168
2169     /* Update max image count and current image count */
2170     himl->cMaxImage = nNewCount;
2171     if (himl->cCurImage > nCopyCount)
2172         himl->cCurImage = nCopyCount;
2173
2174     return TRUE;
2175 }
2176
2177
2178 /*************************************************************************
2179  * ImageList_SetOverlayImage [COMCTL32.79]
2180  *
2181  * Assigns an overlay mask index to an existing image in an image list.
2182  *
2183  * PARAMS
2184  *     himl     [I] handle to image list
2185  *     iImage   [I] image index
2186  *     iOverlay [I] overlay mask index
2187  *
2188  * RETURNS
2189  *     Success: TRUE
2190  *     Failure: FALSE
2191  */
2192
2193 BOOL WINAPI
2194 ImageList_SetOverlayImage (HIMAGELIST himl, INT iImage, INT iOverlay)
2195 {
2196     if (!himl)
2197         return FALSE;
2198     if ((iOverlay < 1) || (iOverlay > MAX_OVERLAYIMAGE))
2199         return FALSE;
2200     if ((iImage < 0) || (iImage > himl->cCurImage))
2201         return FALSE;
2202
2203     himl->nOvlIdx[iOverlay - 1] = iImage;
2204     return TRUE;
2205 }
2206
2207
2208 /*************************************************************************
2209  * ImageList_Write [COMCTL32.80]
2210  *
2211  * Writes an image list to a stream.
2212  *
2213  * PARAMS
2214  *     himl [I] handle to image list
2215  *     pstm [O] Pointer to a stream.
2216  *
2217  * RETURNS
2218  *     Success: TRUE
2219  *     Failure: FALSE
2220  *
2221  * NOTES
2222  *     This function can not be implemented yet, because
2223  *     IStream32::Write is not implemented.
2224  *
2225  * BUGS
2226  *     empty stub.
2227  */
2228
2229 BOOL WINAPI
2230 ImageList_Write (HIMAGELIST himl, LPSTREAM pstm)
2231 {
2232     if (!himl)
2233         return FALSE;
2234
2235     FIXME("empty stub!\n");
2236
2237     return FALSE;
2238 }
2239