/*
 *  ImageList implementation
 *
 *  Copyright 1998 Eric Kohl
 *
 *  TODO:
 *    - Use device independent bitmaps (DIBs) instead of device
 *      dependent bitmaps (DDBs).
 *    - Fix image selection (ImageList_Draw).
 *    - Improve error checking.
 *    - Add missing functions.
 *    - Many many other things. (undocumented functions)
 */

/* This must be defined because the HIMAGELIST type is just a pointer
 * to the _IMAGELIST data structure. But MS does not want us to know
 * anything about its contents. Applications just see a pointer to
 * a struct without any content. It's just to keep compatibility.
 */
#define __WINE_IMAGELIST_C
 
/* This must be defined until "GetIconInfo" is implemented completely.
 * To do that the Cursor and Icon code in objects/cursoricon.c must
 * be rewritten.
 */
#define __GET_ICON_INFO_HACK__ 
 
#include <stdlib.h>
#include "windows.h"
#include "imagelist.h"
#include "commctrl.h"
#include "debug.h"

#ifdef __GET_ICON_INFO_HACK__
#include "bitmap.h"
#endif


static void
IMAGELIST_GrowBitmaps (HIMAGELIST himl, INT32 nImageCount)
{
    HDC32     hdcScreen, hdcImageList, hdcBitmap;
    HBITMAP32 hbmNewBitmap;
    INT32     nNewWidth;

    /* no space left for new Image(s) ==> create new Bitmap(s) */
    printf ("IMAGELIST_GrowBitmaps: Create grown bitmaps!!\n");

    nNewWidth = (himl->cCurImage + nImageCount + himl->cGrow) * himl->cx;

    hdcScreen = GetDC32 (GetDesktopWindow32 ());
    hdcImageList = CreateCompatibleDC32 (hdcScreen);
    hdcBitmap = CreateCompatibleDC32 (hdcScreen);
    ReleaseDC32 (hdcScreen, GetDesktopWindow32 ());

    hbmNewBitmap =
        CreateCompatibleBitmap32 (hdcImageList, nNewWidth, himl->cy);

    SelectObject32 (hdcImageList, himl->hbmImage);
    SelectObject32 (hdcBitmap, hbmNewBitmap);
    BitBlt32 (hdcBitmap, 0, 0, himl->cCurImage * himl->cx, himl->cy,
              hdcImageList, 0, 0, SRCCOPY);

    DeleteObject32 (himl->hbmImage);
    himl->hbmImage = hbmNewBitmap;

    if (himl->hbmMask) {
        hbmNewBitmap = 
            CreateCompatibleBitmap32 (hdcImageList, nNewWidth, himl->cy); 
        SelectObject32 (hdcImageList, himl->hbmMask);
        SelectObject32 (hdcBitmap, hbmNewBitmap);
        BitBlt32 (hdcBitmap, 0, 0, himl->cCurImage * himl->cx, himl->cy,
                  hdcImageList, 0, 0, SRCCOPY);
        DeleteObject32 (himl->hbmMask);
        himl->hbmMask = hbmNewBitmap;
    }

    DeleteDC32 (hdcImageList);
    DeleteDC32 (hdcBitmap);
}


INT32 WINAPI
ImageList_Add (HIMAGELIST himl, HBITMAP32 hbmImage, HBITMAP32 hbmMask)
{
    HDC32    hdcImageList, hdcImage, hdcMask;
    INT32    nFirstIndex, nImageCount;
    INT32    nStartX, nRunX, nRunY;
    COLORREF clrColor;
    BITMAP32 bmp;

    GetObject32A (hbmImage, sizeof(BITMAP32), (LPVOID)&bmp);
    nImageCount = bmp.bmWidth / himl->cx;

    if (himl->cCurImage + nImageCount >= himl->cMaxImage)
        IMAGELIST_GrowBitmaps (himl, nImageCount);

    hdcImageList = CreateCompatibleDC32 (0);
    hdcImage = CreateCompatibleDC32 (0);

    SelectObject32 (hdcImageList, himl->hbmImage);
    SelectObject32 (hdcImage, hbmImage);

    BitBlt32 (hdcImageList, himl->cCurImage * himl->cx, 0,
              bmp.bmWidth, himl->cy, hdcImage, 0, 0, SRCCOPY);
          
    if (himl->hbmMask) {
        if (hbmMask) {
            SelectObject32 (hdcImageList, himl->hbmMask);
            SelectObject32 (hdcImage, hbmMask);
            BitBlt32 (hdcImageList, himl->cCurImage * himl->cx, 0,
                      bmp.bmWidth, himl->cy, hdcImage, 0, 0, SRCCOPY);
        }
        else {
            /* create mask from the imagelist's background color */
            hdcMask = CreateCompatibleDC32 (0);
            SelectObject32 (hdcMask, himl->hbmMask);
            nStartX = himl->cCurImage * himl->cx;
            for (nRunY = 0; nRunY < himl->cy; nRunY++) {
                for (nRunX = 0; nRunX < bmp.bmWidth; nRunX++) {
                    clrColor = GetPixel32 (hdcImage, nRunX, nRunY);
                    if (clrColor == himl->clrBk) {
                        SetPixel32 (hdcImageList, nStartX + nRunX, nRunY, 
                                    RGB(0, 0, 0));
                        SetPixel32 (hdcMask, nStartX + nRunX, nRunY, 
                                    RGB(255, 255, 255));
                    }
                    else
                        SetPixel32 (hdcMask, nStartX + nRunX, nRunY, 
                                    RGB(0, 0, 0));        
                }
            }
            DeleteDC32 (hdcMask);
        }
    }

    DeleteDC32 (hdcImageList);
    DeleteDC32 (hdcImage);

    nFirstIndex = himl->cCurImage;
    himl->cCurImage += nImageCount;

    return (nFirstIndex);
}


INT32 WINAPI
ImageList_AddMasked (HIMAGELIST himl, HBITMAP32 hbmImage, COLORREF crMask)
{
    HDC32    hdcImageList, hdcImage, hdcMask;
    INT32    nIndex, nImageCount;
    BITMAP32 bmp;
    INT32    nStartX, nRunX, nRunY;
    COLORREF crColor;

    GetObject32A (hbmImage, sizeof(BITMAP32), &bmp);
    nImageCount = bmp.bmWidth / himl->cx;

    if (himl->cCurImage + nImageCount >= himl->cMaxImage)
        IMAGELIST_GrowBitmaps (himl, nImageCount);

    nIndex = himl->cCurImage;
    himl->cCurImage += nImageCount;

    hdcImageList = CreateCompatibleDC32 (0);
    hdcImage = CreateCompatibleDC32 (0);

    SelectObject32 (hdcImageList, himl->hbmImage);
    SelectObject32 (hdcImage, hbmImage);
    BitBlt32 (hdcImageList, nIndex * himl->cx, 0,
              bmp.bmWidth, himl->cy, hdcImage, 0, 0, SRCCOPY);

    if (himl->hbmMask) {
        /* create Mask */
        hdcMask = CreateCompatibleDC32 (0);
        SelectObject32 (hdcMask, himl->hbmMask);
        nStartX = nIndex * himl->cx;
        for (nRunY = 0; nRunY < himl->cy; nRunY++) {
            for (nRunX = 0; nRunX < bmp.bmWidth; nRunX++) {
                crColor = GetPixel32 (hdcImage, nRunX, nRunY);
                if (crColor == crMask) {
                    SetPixel32 (hdcImageList, nStartX + nRunX, nRunY,
                                RGB(0, 0, 0));
                    SetPixel32 (hdcMask, nStartX + nRunX, nRunY,
                                RGB(255, 255, 255));
                }
                else
                    SetPixel32 (hdcMask, nStartX + nRunX, nRunY, RGB(0, 0, 0));
            }
        }
        DeleteDC32 (hdcMask);
    }

    DeleteDC32 (hdcImageList);
    DeleteDC32 (hdcImage);
  
    return (nIndex);
}


HIMAGELIST WINAPI
ImageList_Create (INT32 cx, INT32 cy, UINT32 flags, INT32 cInitial, INT32 cGrow)
{
    HIMAGELIST himl;
    HANDLE32 hHeap;
    HDC32 hdcDesktop;
    HWND32 hwndDesktop;

    hHeap = GetProcessHeap ();
    himl = (HIMAGELIST) HeapAlloc (hHeap, 0, sizeof(struct _IMAGELIST));
    if (!himl)
        return (0);
    himl->hHeap = hHeap;
    himl->cx = cx;
    himl->cy = cy;
    himl->flags = flags;
    himl->cMaxImage = cInitial + cGrow;
    himl->cGrow = cGrow;
    himl->cCurImage = 0;
    himl->clrBk = CLR_NONE;  /* ??? or CLR_DEFAULT */
    himl->nOvlIdx[0] = -1;
    himl->nOvlIdx[1] = -1;
    himl->nOvlIdx[2] = -1;
    himl->nOvlIdx[3] = -1;

    hwndDesktop = GetDesktopWindow32();
    hdcDesktop = GetDC32 (hwndDesktop);
    
    himl->hbmImage =
        CreateCompatibleBitmap32 (hdcDesktop, himl->cx * himl->cMaxImage, 
                                  himl->cy);
    if (himl->flags & ILC_MASK)
        himl->hbmMask = 
            CreateCompatibleBitmap32 (hdcDesktop, himl->cx * himl->cMaxImage, 
                                      himl->cy); 
    else
        himl->hbmMask = 0;

    ReleaseDC32 (hwndDesktop, hdcDesktop);
    
    return (himl);    
}


BOOL32 WINAPI
ImageList_Destroy (HIMAGELIST himl)
{
    if (himl->hbmImage)
        DeleteObject32 (himl->hbmImage);
    if (himl->hbmMask)
        DeleteObject32 (himl->hbmMask);
        
    HeapFree (himl->hHeap, 0, (LPVOID)himl);
    return (TRUE);
}


BOOL32 WINAPI
ImageList_Draw (HIMAGELIST himl, INT32 i, HDC32 hdc, 
                INT32 x, INT32 y, UINT32 fStyle)
{
    HDC32     hdcImageList,hdcMask;
    HBITMAP32 hbmMask;
    HBRUSH32 hBrush, hOldBrush;
    INT32 nOvlIdx;

    hdcImageList = CreateCompatibleDC32 (0);
  
    if (himl->hbmMask) {  
        SelectObject32 (hdcImageList, himl->hbmMask);
        BitBlt32 (hdc, x, y, himl->cx, himl->cy, hdcImageList,
                  himl->cx * i, 0, SRCAND);  
    }  

    SelectObject32 (hdcImageList, himl->hbmImage);

    BitBlt32 (hdc, x, y, himl->cx, himl->cy, hdcImageList,
              himl->cx * i, 0, SRCPAINT);

    /* Draw overlay image */
    if (fStyle & 0x0700) {
        nOvlIdx = (fStyle & 0x0700) >> 8;
        if ((nOvlIdx >= 1) && (nOvlIdx <= 4)) {
            nOvlIdx = himl->nOvlIdx[nOvlIdx - 1];
            if ((nOvlIdx >= 0) && (nOvlIdx <= himl->cCurImage)) {

                if (himl->hbmMask) {  
                    SelectObject32 (hdcImageList, himl->hbmMask);
                    BitBlt32 (hdc, x, y, himl->cx, himl->cy, hdcImageList,
                              himl->cx * nOvlIdx, 0, SRCAND);  
                }  
                SelectObject32 (hdcImageList, himl->hbmImage);
                BitBlt32 (hdc, x, y, himl->cx, himl->cy, hdcImageList,
                          himl->cx * nOvlIdx, 0, SRCPAINT);

            }
        }
    }

    DeleteDC32 (hdcImageList);
  
    return (TRUE);
}


COLORREF WINAPI
ImageList_GetBkColor (HIMAGELIST himl)
{
    return (himl->clrBk);
}


HICON32 WINAPI
ImageList_GetIcon (HIMAGELIST himl, INT32 i, UINT32 flags)
{


    return (0);
}


BOOL32 WINAPI
ImageList_GetIconSize (HIMAGELIST himl, INT32 *cx, INT32 *cy)
{
    *cx = himl->cx;
    *cy = himl->cy;
    return (TRUE);
}


INT32 WINAPI
ImageList_GetImageCount (HIMAGELIST himl)
{
    return (himl->cCurImage);
}


BOOL32 WINAPI
ImageList_GetImageInfo (HIMAGELIST himl, INT32 i, IMAGEINFO *pImageInfo)
{
    pImageInfo->hbmImage = himl->hbmImage;
    pImageInfo->hbmMask  = himl->hbmMask;
    
    pImageInfo->rcImage.top    = 0;
    pImageInfo->rcImage.bottom = himl->cy;
    pImageInfo->rcImage.left   = i * himl->cx;
    pImageInfo->rcImage.right  = (i+1) * himl->cx;
    
    return (TRUE);
}


HIMAGELIST WINAPI
ImageList_LoadImage32A (HINSTANCE32 hi, LPCSTR lpbmp, INT32 cx, INT32 cGrow, 
                        COLORREF clrMask, UINT32 uType, UINT32 uFlags)
{
    HIMAGELIST himl = NULL;
    HANDLE32   handle;
    INT32      nImageCount;

    handle = LoadImage32A (hi, lpbmp, uType, 0, 0, uFlags);

    if (uType == IMAGE_BITMAP) {
        BITMAP32 bmp;
        GetObject32A (handle, sizeof(BITMAP32), &bmp);
        nImageCount = bmp.bmWidth / cx;

        himl = ImageList_Create (cx, bmp.bmHeight, ILC_MASK | ILC_COLOR,
                                 nImageCount, cGrow);
        ImageList_AddMasked (himl, (HBITMAP32)handle, clrMask);
    }
    else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
#ifdef __GET_ICON_INFO_HACK__
        HBITMAP32 hbmImage;
        HBITMAP32 hbmMask;
        CURSORICONINFO *ptr;

        if (!(ptr = (CURSORICONINFO *)GlobalLock16(handle))) return (NULL);
        hbmMask  = CreateBitmap32 (ptr->nWidth, ptr->nHeight, 1, 1, 
                                   (char *)(ptr + 1));
        hbmImage = CreateBitmap32 (ptr->nWidth, ptr->nHeight, ptr->bPlanes,
                                   ptr->bBitsPerPixel,
                                   (char *)(ptr + 1) + ptr->nHeight * 
                                   BITMAP_WIDTH_BYTES(ptr->nWidth, 1));
        himl = ImageList_Create (ptr->nWidth, ptr->nHeight,
                                 ILC_MASK | ILC_COLOR, 1, cGrow);
        ImageList_Add (himl, hbmImage, hbmMask);
        DeleteObject32 (hbmImage);
        DeleteObject32 (hbmMask);
        GlobalUnlock16 (handle);
#else
        ICONINFO32 ii;
        BITMAP32 bmp;

        GetIconInfo (hIcon, &ii);
        GetObject32A (ii->hbmMask, sizeof(BITMAP32), (LPVOID)&bmp);
        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight, 
                                 ILC_MASK | ILC_COLOR, 1, cGrow);
        ImageList_Add (himl, ii->hbmColor, ii->hbmMask);
#endif
    }

    DeleteObject32 (handle);
    
    return (himl);
}


HIMAGELIST WINAPI
ImageList_LoadImage32W (HINSTANCE32 hi, LPCWSTR lpbmp, INT32 cx, INT32 cGrow, 
                        COLORREF clrMask, UINT32 uType, UINT32 uFlags)
{
    HIMAGELIST himl = NULL;
    HANDLE32   handle;
    INT32      nImageCount;

    handle = LoadImage32W (hi, lpbmp, uType, 0, 0, uFlags);

    if (uType == IMAGE_BITMAP) {
        BITMAP32 bmp;
        GetObject32A (handle, sizeof(BITMAP32), &bmp);
        nImageCount = bmp.bmWidth / cx;

        himl = ImageList_Create (cx, bmp.bmHeight, ILC_MASK | ILC_COLOR,
                                 nImageCount, cGrow);
        ImageList_AddMasked (himl, (HBITMAP32)handle, clrMask);
    }
    else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
#ifdef __GET_ICON_INFO_HACK__
        HBITMAP32 hbmImage;
        HBITMAP32 hbmMask;
        CURSORICONINFO *ptr;

        if (!(ptr = (CURSORICONINFO *)GlobalLock16(handle))) return (NULL);
        hbmMask  = CreateBitmap32 (ptr->nWidth, ptr->nHeight, 1, 1, 
                                   (char *)(ptr + 1));
        hbmImage = CreateBitmap32 (ptr->nWidth, ptr->nHeight, ptr->bPlanes,
                                   ptr->bBitsPerPixel,
                                   (char *)(ptr + 1) + ptr->nHeight * 
                                   BITMAP_WIDTH_BYTES(ptr->nWidth, 1));
        himl = ImageList_Create (ptr->nWidth, ptr->nHeight,
                                 ILC_MASK | ILC_COLOR, 1, cGrow);
        ImageList_Add (himl, hbmImage, hbmMask);
        DeleteObject32 (hbmImage);
        DeleteObject32 (hbmMask);
        GlobalUnlock16 (handle);
#else
        ICONINFO32 ii;
        BITMAP32 bmp;

        GetIconInfo (hIcon, &ii);
        GetObject32A (ii->hbmMask, sizeof(BITMAP32), (LPVOID)&bmp);
        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight, 
                                 ILC_MASK | ILC_COLOR, 1, cGrow);
        ImageList_Add (himl, ii->hbmColor, ii->hbmMask);
#endif
    }

    DeleteObject32 (handle);
    
    return (himl);
}


HIMAGELIST WINAPI
ImageList_Merge (HIMAGELIST himl1, INT32 i1, HIMAGELIST himl2, INT32 i2,
                 INT32 xOffs, INT32 yOffs)
{
    HIMAGELIST himlDst = NULL;
    HDC32      hdcSrcImage, hdcDstImage;
    INT32      nX1, nX2;

    himlDst = ImageList_Create (himl1->cx, himl1->cy,
                                ILC_MASK | ILC_COLOR, 1, 1);
    if (himlDst) {
        hdcSrcImage = CreateCompatibleDC32 (0);
        hdcDstImage = CreateCompatibleDC32 (0);
        nX1 = i1 * himl1->cx;
        nX2 = i2 * himl2->cx;
        
        /* copy image */
        SelectObject32 (hdcSrcImage, himl1->hbmImage);
        SelectObject32 (hdcDstImage, himlDst->hbmImage);
        BitBlt32 (hdcDstImage, 0, 0, himlDst->cx, himlDst->cy, 
                  hdcSrcImage, nX1, 0, SRCCOPY);  /* SRCCOPY */

        SelectObject32 (hdcSrcImage, himl2->hbmMask);
        BitBlt32 (hdcDstImage, xOffs, yOffs, 
                  himlDst->cx - xOffs, himlDst->cy - yOffs, 
                  hdcSrcImage, nX2, 0, SRCAND);

        SelectObject32 (hdcSrcImage, himl2->hbmImage);
        BitBlt32 (hdcDstImage, xOffs, yOffs, 
                  himlDst->cx - xOffs, himlDst->cy - yOffs, 
                  hdcSrcImage, nX2, 0, SRCPAINT);

        /* copy mask */
        SelectObject32 (hdcSrcImage, himl1->hbmMask);
        SelectObject32 (hdcDstImage, himlDst->hbmMask);
        BitBlt32 (hdcDstImage, 0, 0, himlDst->cx, himlDst->cy, 
                  hdcSrcImage, nX1, 0, SRCCOPY);

        SelectObject32 (hdcSrcImage, himl2->hbmMask);
        BitBlt32 (hdcDstImage, xOffs, yOffs, 
                  himlDst->cx - xOffs, himlDst->cy - yOffs, 
                  hdcSrcImage, nX2, 0, SRCAND);

        DeleteDC32 (hdcSrcImage);
        DeleteDC32 (hdcDstImage);
    }
   
    return (himlDst);
}


BOOL32 WINAPI
ImageList_Replace (HIMAGELIST himl, INT32 i,  HBITMAP32 hbmImage, 
                   HBITMAP32 hbmMask)
{
    HDC32 hdcImageList, hdcImage;

    if ((i >= himl->cCurImage) || (i < 0)) return (FALSE);

    hdcImageList = CreateCompatibleDC32 (0);
    hdcImage = CreateCompatibleDC32 (0);

    /* Replace Image */
    SelectObject32 (hdcImageList, himl->hbmImage);
    SelectObject32 (hdcImage, hbmImage);

    BitBlt32 (hdcImageList, i * himl->cx, 0,
              himl->cx, himl->cy, hdcImage, 0, 0, SRCCOPY);

    if (himl->hbmMask) {
        /* Replace Mask */
        SelectObject32 (hdcImageList, himl->hbmMask);
        SelectObject32 (hdcImage, hbmMask);

        BitBlt32 (hdcImageList, i * himl->cx, 0,
                  himl->cx, himl->cy, hdcImage, 0, 0, SRCCOPY);
    }

    DeleteDC32 (hdcImage);
    DeleteDC32 (hdcImageList);

    return (TRUE);
}


INT32 WINAPI
ImageList_ReplaceIcon (HIMAGELIST himl, INT32 i, HICON32 hIcon)
{
    HDC32     hdcImageList, hdcImage;
    INT32     nIndex;
#ifdef __GET_ICON_INFO_HACK__
    HBITMAP32 hbmImage;
    HBITMAP32 hbmMask;
    CURSORICONINFO *ptr;
#else    
    ICONINFO32 ii;
    BITMAP32 bmp;
#endif

    if ((i >= himl->cCurImage) || (i < -1)) return (-1);

#ifdef __GET_ICON_INFO_HACK__
    if (!(ptr = (CURSORICONINFO *)GlobalLock16(hIcon))) return (-1);
    hbmMask  = CreateBitmap32 (ptr->nWidth, ptr->nHeight, 1, 1, 
                               (char *)(ptr + 1));
    hbmImage = CreateBitmap32 (ptr->nWidth, ptr->nHeight, ptr->bPlanes,
                               ptr->bBitsPerPixel,
                               (char *)(ptr + 1) + ptr->nHeight * 
                               BITMAP_WIDTH_BYTES(ptr->nWidth, 1));
#else
    GetIconInfo (hIcon, &ii);
    GetObject32A (ii->hbmMask, sizeof(BITMAP32), (LPVOID)&bmp);
#endif

    if (i == -1) {
        if (himl->cCurImage + 1 >= himl->cMaxImage)
            IMAGELIST_GrowBitmaps (himl, 1);
        nIndex = himl->cCurImage;
        himl->cCurImage ++;
    }
    else
        nIndex = i;

    hdcImageList = CreateCompatibleDC32 (0);
    hdcImage = CreateCompatibleDC32 (0);

#ifdef __GET_ICON_INFO_HACK__
    SelectObject32 (hdcImageList, himl->hbmImage);
    SelectObject32 (hdcImage, hbmImage);
#else
    SelectObject32 (hdcImage, ii->hbmColor);
#endif

    BitBlt32 (hdcImageList, nIndex * himl->cx, 0,
              himl->cx, himl->cy, hdcImage, 0, 0, SRCCOPY);

    if (himl->hbmMask) {
#ifdef __GET_ICON_INFO_HACK__
        SelectObject32 (hdcImageList, himl->hbmMask);
        SelectObject32 (hdcImage, hbmMask);
#else
        SelectObject32 (hdcImage, ii->hbmMask);
#endif
        BitBlt32 (hdcImageList, nIndex * himl->cx, 0,
                  himl->cx, himl->cy, hdcImage, 0, 0, SRCCOPY);
    }

    DeleteDC32 (hdcImageList);
    DeleteDC32 (hdcImage);
#ifdef __GET_ICON_INFO_HACK        
    DeleteObject32 (hbmImage);
    DeleteObject32 (hbmMask);
    GlobalUnlock16 (hIcon);
#endif
    return (nIndex);
}


COLORREF WINAPI
ImageList_SetBkColor (HIMAGELIST himl, COLORREF clrBk)
{
    COLORREF clrOldBk;

    clrOldBk = himl->clrBk;
    himl->clrBk = clrBk;
    return (clrOldBk);
}


BOOL32 WINAPI
ImageList_SetOverlayImage (HIMAGELIST himl, INT32 iImage, INT32 iOverlay)
{
    if ((iOverlay < 1) || (iOverlay > 4)) return (FALSE);
    if ((iImage < 0) || (iImage > himl->cCurImage)) return (FALSE);
    
    himl->nOvlIdx[iOverlay - 1] = iImage;
    return (TRUE);
}