imagelist.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "winerror.h"
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "commctrl.h"
#include "comctl32.h"
#include "commoncontrols.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "wine/heap.h"
#include "pshpack2.h"
#include "poppack.h"

Include dependency graph for imagelist.c:

Go to the source code of this file.

Classes
struct	_IMAGELIST
struct	_ILHEAD
struct	INTERNALDRAG

Macros
#define	COBJMACROS
#define	MAX_OVERLAYIMAGE   15
#define	IMAGELIST_MAGIC   0x53414D58
#define	TILE_COUNT   4

Typedefs
typedef struct _ILHEAD	ILHEAD

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imagelist)
static HIMAGELIST	impl_from_IImageList2 (IImageList2 *iface)
static HBITMAP	ImageList_CreateImage (HDC hdc, HIMAGELIST himl, UINT count)
static HRESULT	ImageListImpl_CreateInstance (const IUnknown *pUnkOuter, REFIID iid, void **ppv)
static BOOL	is_valid (HIMAGELIST himl)
static UINT	imagelist_height (UINT count)
static void	imagelist_point_from_index (HIMAGELIST himl, UINT index, LPPOINT pt)
static void	imagelist_get_bitmap_size (HIMAGELIST himl, UINT count, SIZE *sz)
static int	get_dib_stride (int width, int bpp)
static int	get_dib_image_size (const BITMAPINFO *info)
static void	imagelist_copy_images (HIMAGELIST himl, HDC hdcSrc, HDC hdcDest, UINT src, UINT count, UINT dest)
static void	add_dib_bits (HIMAGELIST himl, int pos, int count, int width, int height, BITMAPINFO *info, BITMAPINFO *mask_info, DWORD *bits, BYTE *mask_bits)
static BOOL	add_with_alpha (HIMAGELIST himl, HDC hdc, int pos, int count, int width, int height, HBITMAP hbmImage, HBITMAP hbmMask)
UINT WINAPI	ImageList_SetColorTable (HIMAGELIST himl, UINT uStartIndex, UINT cEntries, const RGBQUAD *prgb)
static void	IMAGELIST_InternalExpandBitmaps (HIMAGELIST himl, INT nImageCount)
INT WINAPI	ImageList_Add (HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)
INT WINAPI	ImageList_AddIcon (HIMAGELIST himl, HICON hIcon)
INT WINAPI	ImageList_AddMasked (HIMAGELIST himl, HBITMAP hBitmap, COLORREF clrMask)
BOOL WINAPI	ImageList_BeginDrag (HIMAGELIST himlTrack, INT iTrack, INT dxHotspot, INT dyHotspot)
BOOL WINAPI	ImageList_Copy (HIMAGELIST himlDst, INT iDst, HIMAGELIST himlSrc, INT iSrc, UINT uFlags)
HIMAGELIST WINAPI	ImageList_Create (INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
BOOL WINAPI	ImageList_Destroy (HIMAGELIST himl)
BOOL WINAPI	ImageList_DragEnter (HWND hwndLock, INT x, INT y)
BOOL WINAPI	ImageList_DragLeave (HWND hwndLock)
static void	ImageList_InternalDragDraw (HDC hdc, INT x, INT y)
BOOL WINAPI	ImageList_DragMove (INT x, INT y)
BOOL WINAPI	ImageList_DragShowNolock (BOOL bShow)
BOOL WINAPI	ImageList_Draw (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
BOOL WINAPI	ImageList_DrawEx (HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, INT dx, INT dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle)
static BOOL	alpha_blend_image (HIMAGELIST himl, HDC dest_dc, int dest_x, int dest_y, int src_x, int src_y, int cx, int cy, BLENDFUNCTION func, UINT style, COLORREF blend_col)
BOOL WINAPI	ImageList_DrawIndirect (IMAGELISTDRAWPARAMS *pimldp)
HIMAGELIST WINAPI	ImageList_Duplicate (HIMAGELIST himlSrc)
VOID WINAPI	ImageList_EndDrag (void)
COLORREF WINAPI	ImageList_GetBkColor (HIMAGELIST himl)
HIMAGELIST WINAPI	ImageList_GetDragImage (POINT *ppt, POINT *pptHotspot)
DWORD WINAPI	ImageList_GetFlags (HIMAGELIST himl)
HICON WINAPI	ImageList_GetIcon (HIMAGELIST himl, INT i, UINT fStyle)
BOOL WINAPI	ImageList_GetIconSize (HIMAGELIST himl, INT *cx, INT *cy)
INT WINAPI	ImageList_GetImageCount (HIMAGELIST himl)
BOOL WINAPI	ImageList_GetImageInfo (HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
BOOL WINAPI	ImageList_GetImageRect (HIMAGELIST himl, INT i, LPRECT lpRect)
HIMAGELIST WINAPI	ImageList_LoadImageA (HINSTANCE hi, LPCSTR lpbmp, INT cx, INT cGrow, COLORREF clrMask, UINT uType, UINT uFlags)
HIMAGELIST WINAPI	ImageList_LoadImageW (HINSTANCE hi, LPCWSTR lpbmp, INT cx, INT cGrow, COLORREF clrMask, UINT uType, UINT uFlags)
HIMAGELIST WINAPI	ImageList_Merge (HIMAGELIST himl1, INT i1, HIMAGELIST himl2, INT i2, INT dx, INT dy)
static void *	read_bitmap (IStream *pstm, BITMAPINFO *bmi)
HIMAGELIST WINAPI	ImageList_Read (IStream *pstm)
BOOL WINAPI	ImageList_Remove (HIMAGELIST himl, INT i)
BOOL WINAPI	ImageList_Replace (HIMAGELIST himl, INT i, HBITMAP hbmImage, HBITMAP hbmMask)
INT WINAPI	ImageList_ReplaceIcon (HIMAGELIST himl, INT nIndex, HICON hIcon)
COLORREF WINAPI	ImageList_SetBkColor (HIMAGELIST himl, COLORREF clrBk)
BOOL WINAPI	ImageList_SetDragCursorImage (HIMAGELIST himlDrag, INT iDrag, INT dxHotspot, INT dyHotspot)
BOOL WINAPI	ImageList_SetFilter (HIMAGELIST himl, INT i, DWORD dwFilter)
DWORD WINAPI	ImageList_SetFlags (HIMAGELIST himl, DWORD flags)
BOOL WINAPI	ImageList_SetIconSize (HIMAGELIST himl, INT cx, INT cy)
BOOL WINAPI	ImageList_SetImageCount (HIMAGELIST himl, UINT iImageCount)
BOOL WINAPI	ImageList_SetOverlayImage (HIMAGELIST himl, INT iImage, INT iOverlay)
static BOOL	_write_bitmap (HBITMAP hBitmap, IStream *pstm)
BOOL WINAPI	ImageList_Write (HIMAGELIST himl, IStream *pstm)
HRESULT WINAPI	ImageList_CoCreateInstance (REFCLSID rclsid, const IUnknown *punkOuter, REFIID riid, void **ppv)
static HRESULT WINAPI	ImageListImpl_QueryInterface (IImageList2 *iface, REFIID iid, void **ppv)
static ULONG WINAPI	ImageListImpl_AddRef (IImageList2 *iface)
static ULONG WINAPI	ImageListImpl_Release (IImageList2 *iface)
static HRESULT WINAPI	ImageListImpl_Add (IImageList2 *iface, HBITMAP hbmImage, HBITMAP hbmMask, int *pi)
static HRESULT WINAPI	ImageListImpl_ReplaceIcon (IImageList2 *iface, int i, HICON hicon, int *pi)
static HRESULT WINAPI	ImageListImpl_SetOverlayImage (IImageList2 *iface, int iImage, int iOverlay)
static HRESULT WINAPI	ImageListImpl_Replace (IImageList2 *iface, int i, HBITMAP hbmImage, HBITMAP hbmMask)
static HRESULT WINAPI	ImageListImpl_AddMasked (IImageList2 *iface, HBITMAP hbmImage, COLORREF crMask, int *pi)
static HRESULT WINAPI	ImageListImpl_Draw (IImageList2 *iface, IMAGELISTDRAWPARAMS *pimldp)
static HRESULT WINAPI	ImageListImpl_Remove (IImageList2 *iface, int i)
static HRESULT WINAPI	ImageListImpl_GetIcon (IImageList2 *iface, int i, UINT flags, HICON *picon)
static HRESULT WINAPI	ImageListImpl_GetImageInfo (IImageList2 *iface, int i, IMAGEINFO *pImageInfo)
static HRESULT WINAPI	ImageListImpl_Copy (IImageList2 *iface, int dst_index, IUnknown *unk_src, int src_index, UINT flags)
static HRESULT WINAPI	ImageListImpl_Merge (IImageList2 *iface, int i1, IUnknown *punk2, int i2, int dx, int dy, REFIID riid, void **ppv)
static HRESULT WINAPI	ImageListImpl_Clone (IImageList2 *iface, REFIID riid, void **ppv)
static HRESULT WINAPI	ImageListImpl_GetImageRect (IImageList2 *iface, int i, RECT *prc)
static HRESULT WINAPI	ImageListImpl_GetIconSize (IImageList2 *iface, int *cx, int *cy)
static HRESULT WINAPI	ImageListImpl_SetIconSize (IImageList2 *iface, int cx, int cy)
static HRESULT WINAPI	ImageListImpl_GetImageCount (IImageList2 *iface, int *pi)
static HRESULT WINAPI	ImageListImpl_SetImageCount (IImageList2 *iface, UINT count)
static HRESULT WINAPI	ImageListImpl_SetBkColor (IImageList2 *iface, COLORREF clrBk, COLORREF *pclr)
static HRESULT WINAPI	ImageListImpl_GetBkColor (IImageList2 *iface, COLORREF *pclr)
static HRESULT WINAPI	ImageListImpl_BeginDrag (IImageList2 *iface, int iTrack, int dxHotspot, int dyHotspot)
static HRESULT WINAPI	ImageListImpl_EndDrag (IImageList2 *iface)
static HRESULT WINAPI	ImageListImpl_DragEnter (IImageList2 *iface, HWND hwndLock, int x, int y)
static HRESULT WINAPI	ImageListImpl_DragLeave (IImageList2 *iface, HWND hwndLock)
static HRESULT WINAPI	ImageListImpl_DragMove (IImageList2 *iface, int x, int y)
static HRESULT WINAPI	ImageListImpl_SetDragCursorImage (IImageList2 *iface, IUnknown *punk, int iDrag, int dxHotspot, int dyHotspot)
static HRESULT WINAPI	ImageListImpl_DragShowNolock (IImageList2 *iface, BOOL fShow)
static HRESULT WINAPI	ImageListImpl_GetDragImage (IImageList2 *iface, POINT *ppt, POINT *pptHotspot, REFIID riid, PVOID *ppv)
static HRESULT WINAPI	ImageListImpl_GetItemFlags (IImageList2 *iface, int i, DWORD *dwFlags)
static HRESULT WINAPI	ImageListImpl_GetOverlayImage (IImageList2 *iface, int iOverlay, int *piIndex)
static HRESULT WINAPI	ImageListImpl_Resize (IImageList2 *iface, INT cx, INT cy)
static HRESULT WINAPI	ImageListImpl_GetOriginalSize (IImageList2 *iface, INT image, DWORD flags, INT *cx, INT *cy)
static HRESULT WINAPI	ImageListImpl_SetOriginalSize (IImageList2 *iface, INT image, INT cx, INT cy)
static HRESULT WINAPI	ImageListImpl_SetCallback (IImageList2 *iface, IUnknown *callback)
static HRESULT WINAPI	ImageListImpl_GetCallback (IImageList2 *iface, REFIID riid, void **ppv)
static HRESULT WINAPI	ImageListImpl_ForceImagePresent (IImageList2 *iface, INT image, DWORD flags)
static HRESULT WINAPI	ImageListImpl_DiscardImages (IImageList2 *iface, INT first_image, INT last_image, DWORD flags)
static HRESULT WINAPI	ImageListImpl_PreloadImages (IImageList2 *iface, IMAGELISTDRAWPARAMS *params)
static HRESULT WINAPI	ImageListImpl_GetStatistics (IImageList2 *iface, IMAGELISTSTATS *stats)
static HRESULT WINAPI	ImageListImpl_Initialize (IImageList2 *iface, INT cx, INT cy, UINT flags, INT initial, INT grow)
static HRESULT WINAPI	ImageListImpl_Replace2 (IImageList2 *iface, INT i, HBITMAP image, HBITMAP mask, IUnknown *unk, DWORD flags)
static HRESULT WINAPI	ImageListImpl_ReplaceFromImageList (IImageList2 *iface, INT i, IImageList *imagelist, INT src, IUnknown *unk, DWORD flags)
HRESULT WINAPI	HIMAGELIST_QueryInterface (HIMAGELIST himl, REFIID riid, void **ppv)

Variables
static INTERNALDRAG	InternalDrag = { 0, 0, 0, 0, 0, 0, 0, FALSE, 0 }
static const IImageList2Vtbl	ImageListImpl_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 35 of file imagelist.c.

IMAGELIST_MAGIC

#define IMAGELIST_MAGIC   0x53414D58

Definition at line 117 of file imagelist.c.

MAX_OVERLAYIMAGE

#define MAX_OVERLAYIMAGE   15

Definition at line 52 of file imagelist.c.

TILE_COUNT

#define TILE_COUNT   4

Definition at line 179 of file imagelist.c.

Typedef Documentation

ILHEAD

typedef struct _ILHEAD ILHEAD

Function Documentation

_write_bitmap()

static BOOL _write_bitmap ( HBITMAP  hBitmap, IStream *  pstm  )

static

Definition at line 3197 of file imagelist.c.

{
    LPBITMAPFILEHEADER bmfh;
    LPBITMAPINFOHEADER bmih;
    LPBYTE data = NULL, lpBits;
    BITMAP bm;
    INT bitCount, sizeImage, offBits, totalSize;
    HDC xdc;
    BOOL result = FALSE;
 
    if (!GetObjectW(hBitmap, sizeof(BITMAP), &bm))
        return FALSE;
 
    bitCount = bm.bmBitsPixel;
    sizeImage = get_dib_stride(bm.bmWidth, bitCount) * bm.bmHeight;
 
    totalSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    if(bitCount <= 8)
    totalSize += (1 << bitCount) * sizeof(RGBQUAD);
    offBits = totalSize;
    totalSize += sizeImage;
 
    data = heap_alloc_zero(totalSize);
    bmfh = (LPBITMAPFILEHEADER)data;
    bmih = (LPBITMAPINFOHEADER)(data + sizeof(BITMAPFILEHEADER));
    lpBits = data + offBits;
 
    /* setup BITMAPFILEHEADER */
    bmfh->bfType      = (('M' << 8) | 'B');
    bmfh->bfSize      = offBits;
    bmfh->bfReserved1 = 0;
    bmfh->bfReserved2 = 0;
    bmfh->bfOffBits   = offBits;
 
    /* setup BITMAPINFOHEADER */
    bmih->biSize          = sizeof(BITMAPINFOHEADER);
    bmih->biWidth         = bm.bmWidth;
    bmih->biHeight        = bm.bmHeight;
    bmih->biPlanes        = 1;
    bmih->biBitCount      = bitCount;
    bmih->biCompression   = BI_RGB;
    bmih->biSizeImage     = sizeImage;
    bmih->biXPelsPerMeter = 0;
    bmih->biYPelsPerMeter = 0;
    bmih->biClrUsed       = 0;
    bmih->biClrImportant  = 0;
 
    xdc = GetDC(0);
    result = GetDIBits(xdc, hBitmap, 0, bm.bmHeight, lpBits, (BITMAPINFO *)bmih, DIB_RGB_COLORS) == bm.bmHeight;
    ReleaseDC(0, xdc);
    if (!result)
    goto failed;
 
    TRACE("width %u, height %u, planes %u, bpp %u\n",
          bmih->biWidth, bmih->biHeight,
          bmih->biPlanes, bmih->biBitCount);
 
    if(FAILED(IStream_Write(pstm, data, totalSize, NULL)))
    goto failed;
 
    result = TRUE;
 
failed:
    heap_free(data);
 
    return result;
}

Referenced by ImageList_Write().

add_dib_bits()

static void add_dib_bits ( HIMAGELIST  himl, int  pos, int  count, int  width, int  height, BITMAPINFO *  info, BITMAPINFO *  mask_info, DWORD *  bits, BYTE *  mask_bits  )

static

Definition at line 234 of file imagelist.c.

{
    int i, j, n;
    POINT pt;
    int stride = info->bmiHeader.biWidth;
    int mask_stride = (info->bmiHeader.biWidth + 31) / 32 * 4;
 
    for (n = 0; n < count; n++)
    {
        BOOL has_alpha = FALSE;
 
        imagelist_point_from_index( himl, pos + n, &pt );
 
        /* check if bitmap has an alpha channel */
        for (i = 0; i < height && !has_alpha; i++)
            for (j = n * width; j < (n + 1) * width; j++)
                if ((has_alpha = ((bits[i * stride + j] & 0xff000000) != 0))) break;
 
        if (!has_alpha)  /* generate alpha channel from the mask */
        {
            for (i = 0; i < height; i++)
                for (j = n * width; j < (n + 1) * width; j++)
                    if (!mask_info || !((mask_bits[i * mask_stride + j / 8] << (j % 8)) & 0x80))
                        bits[i * stride + j] |= 0xff000000;
                    else
                        bits[i * stride + j] = 0;
        }
        else
        {
            himl->has_alpha[pos + n] = 1;
 
            if (mask_info && himl->hbmMask)  /* generate the mask from the alpha channel */
            {
                for (i = 0; i < height; i++)
                    for (j = n * width; j < (n + 1) * width; j++)
                        if ((bits[i * stride + j] >> 24) > 25) /* more than 10% alpha */
                            mask_bits[i * mask_stride + j / 8] &= ~(0x80 >> (j % 8));
                        else
                            mask_bits[i * mask_stride + j / 8] |= 0x80 >> (j % 8);
            }
        }
        StretchDIBits( himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
                       n * width, 0, width, height, bits, info, DIB_RGB_COLORS, SRCCOPY );
        if (mask_info)
            StretchDIBits( himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
                           n * width, 0, width, height, mask_bits, mask_info, DIB_RGB_COLORS, SRCCOPY );
    }
}

Referenced by add_with_alpha(), and ImageList_Read().

add_with_alpha()

static BOOL add_with_alpha ( HIMAGELIST  himl, HDC  hdc, int  pos, int  count, int  width, int  height, HBITMAP  hbmImage, HBITMAP  hbmMask  )

static

Definition at line 285 of file imagelist.c.

{
    BOOL ret = FALSE;
    BITMAP bm;
    BITMAPINFO *info, *mask_info = NULL;
    DWORD *bits = NULL;
    BYTE *mask_bits = NULL;
    DWORD mask_width;
 
    if (!GetObjectW( hbmImage, sizeof(bm), &bm )) return FALSE;
 
    /* if either the imagelist or the source bitmap don't have an alpha channel, bail out now */
    if (!himl->has_alpha) return FALSE;
    if (bm.bmBitsPixel != 32) return FALSE;
 
    SelectObject( hdc, hbmImage );
    mask_width = (bm.bmWidth + 31) / 32 * 4;
 
    if (!(info = heap_alloc( FIELD_OFFSET( BITMAPINFO, bmiColors[256] )))) goto done;
    info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    info->bmiHeader.biWidth = bm.bmWidth;
    info->bmiHeader.biHeight = -height;
    info->bmiHeader.biPlanes = 1;
    info->bmiHeader.biBitCount = 32;
    info->bmiHeader.biCompression = BI_RGB;
    info->bmiHeader.biSizeImage = bm.bmWidth * height * 4;
    info->bmiHeader.biXPelsPerMeter = 0;
    info->bmiHeader.biYPelsPerMeter = 0;
    info->bmiHeader.biClrUsed = 0;
    info->bmiHeader.biClrImportant = 0;
    if (!(bits = heap_alloc( info->bmiHeader.biSizeImage ))) goto done;
    if (!GetDIBits( hdc, hbmImage, 0, height, bits, info, DIB_RGB_COLORS )) goto done;
 
    if (hbmMask)
    {
        if (!(mask_info = heap_alloc( FIELD_OFFSET( BITMAPINFO, bmiColors[2] ))))
            goto done;
        mask_info->bmiHeader = info->bmiHeader;
        mask_info->bmiHeader.biBitCount = 1;
        mask_info->bmiHeader.biSizeImage = mask_width * height;
        if (!(mask_bits = heap_alloc_zero( mask_info->bmiHeader.biSizeImage )))
            goto done;
        if (!GetDIBits( hdc, hbmMask, 0, height, mask_bits, mask_info, DIB_RGB_COLORS )) goto done;
    }
 
    add_dib_bits( himl, pos, count, width, height, info, mask_info, bits, mask_bits );
    ret = TRUE;
 
done:
    heap_free( info );
    heap_free( mask_info );
    heap_free( bits );
    heap_free( mask_bits );
    return ret;
}

Referenced by ImageList_Add(), ImageList_Replace(), and ImageList_ReplaceIcon().

alpha_blend_image()

static BOOL alpha_blend_image ( HIMAGELIST  himl, HDC  dest_dc, int  dest_x, int  dest_y, int  src_x, int  src_y, int  cx, int  cy, BLENDFUNCTION  func, UINT  style, COLORREF  blend_col  )

static

Definition at line 1289 of file imagelist.c.

{
    BOOL ret = FALSE;
    HDC hdc;
    HBITMAP bmp = 0, mask = 0;
    BITMAPINFO *info;
    void *bits, *mask_bits;
    unsigned int *ptr;
    int i, j;
 
    if (!(hdc = CreateCompatibleDC( 0 ))) return FALSE;
    if (!(info = heap_alloc( FIELD_OFFSET( BITMAPINFO, bmiColors[256] )))) goto done;
    info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    info->bmiHeader.biWidth = cx;
    info->bmiHeader.biHeight = cy;
    info->bmiHeader.biPlanes = 1;
    info->bmiHeader.biBitCount = 32;
    info->bmiHeader.biCompression = BI_RGB;
    info->bmiHeader.biSizeImage = cx * cy * 4;
    info->bmiHeader.biXPelsPerMeter = 0;
    info->bmiHeader.biYPelsPerMeter = 0;
    info->bmiHeader.biClrUsed = 0;
    info->bmiHeader.biClrImportant = 0;
#ifdef __REACTOS__
    if (!(bmp = CreateDIBSection( srce_dc, info, DIB_RGB_COLORS, &bits, 0, 0 ))) goto done;
#else
    if (!(bmp = CreateDIBSection( himl->hdcImage, info, DIB_RGB_COLORS, &bits, 0, 0 ))) goto done;
#endif
    SelectObject( hdc, bmp );
#ifdef __REACTOS__
    if (!BitBlt(hdc, 0, 0, cx, cy, srce_dc, src_x, src_y, SRCCOPY))
    {
        TRACE("BitBlt failed\n");
        goto done;
    }
#else
    BitBlt( hdc, 0, 0, cx, cy, himl->hdcImage, src_x, src_y, SRCCOPY );
#endif
 
    if (blend_col != CLR_NONE)
    {
        BYTE r = GetRValue( blend_col );
        BYTE g = GetGValue( blend_col );
        BYTE b = GetBValue( blend_col );
 
        if (style & ILD_BLEND25)
        {
            for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
                *ptr = ((*ptr & 0xff000000) |
                        ((((*ptr & 0x00ff0000) * 3 + (r << 16)) / 4) & 0x00ff0000) |
                        ((((*ptr & 0x0000ff00) * 3 + (g << 8))  / 4) & 0x0000ff00) |
                        ((((*ptr & 0x000000ff) * 3 + (b << 0))  / 4) & 0x000000ff));
        }
        else if (style & ILD_BLEND50)
        {
            for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
                *ptr = ((*ptr & 0xff000000) |
                        ((((*ptr & 0x00ff0000) + (r << 16)) / 2) & 0x00ff0000) |
                        ((((*ptr & 0x0000ff00) + (g << 8))  / 2) & 0x0000ff00) |
                        ((((*ptr & 0x000000ff) + (b << 0))  / 2) & 0x000000ff));
        }
    }
 
    if (himl->has_alpha)  /* we already have an alpha channel in this case */
    {
        /* pre-multiply by the alpha channel */
        for (i = 0, ptr = bits; i < cx * cy; i++, ptr++)
        {
            DWORD alpha = *ptr >> 24;
            *ptr = ((*ptr & 0xff000000) |
                    (((*ptr & 0x00ff0000) * alpha / 255) & 0x00ff0000) |
                    (((*ptr & 0x0000ff00) * alpha / 255) & 0x0000ff00) |
                    (((*ptr & 0x000000ff) * alpha / 255)));
        }
    }
    else if (himl->hbmMask)
    {
        unsigned int width_bytes = (cx + 31) / 32 * 4;
        /* generate alpha channel from the mask */
        info->bmiHeader.biBitCount = 1;
        info->bmiHeader.biSizeImage = width_bytes * cy;
        info->bmiColors[0].rgbRed      = 0;
        info->bmiColors[0].rgbGreen    = 0;
        info->bmiColors[0].rgbBlue     = 0;
        info->bmiColors[0].rgbReserved = 0;
        info->bmiColors[1].rgbRed      = 0xff;
        info->bmiColors[1].rgbGreen    = 0xff;
        info->bmiColors[1].rgbBlue     = 0xff;
        info->bmiColors[1].rgbReserved = 0;
        if (!(mask = CreateDIBSection( srce_dcMask, info, DIB_RGB_COLORS, &mask_bits, 0, 0)))
        {
            TRACE("CreateDIBSection failed %i\n", GetLastError());
            goto done;
        }
        if (SelectObject(hdc, mask) == NULL)
        {
            TRACE("SelectObject failed %i\n", GetLastError());
            SelectObject(hdc, bmp);
            goto done;
        }
        if (!BitBlt( hdc, 0, 0, cx, cy, srce_dcMask, src_x, src_y, SRCCOPY))
        {
            TRACE("BitBlt failed %i\n", GetLastError());
            SelectObject(hdc, bmp);
            goto done;
        }
        if (SelectObject( hdc, bmp) == NULL)
        {
            TRACE("SelectObject failed %i\n", GetLastError());
            goto done;
        }
        for (i = 0, ptr = bits; i < cy; i++)
            for (j = 0; j < cx; j++, ptr++)
                if ((((BYTE *)mask_bits)[i * width_bytes + j / 8] << (j % 8)) & 0x80) *ptr = 0;
                else *ptr |= 0xff000000;
    }
 
    ret = GdiAlphaBlend( dest_dc, dest_x, dest_y, cx, cy, hdc, 0, 0, cx, cy, func );
 
done:
    DeleteDC( hdc );
    if (bmp) DeleteObject( bmp );
    if (mask) DeleteObject( mask );
    heap_free( info );
    return ret;
}

Referenced by ImageList_DrawIndirect().

get_dib_image_size()

static int get_dib_image_size ( const BITMAPINFO *  info )

inlinestatic

Definition at line 203 of file imagelist.c.

{
    return get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount )
        * abs( info->bmiHeader.biHeight );
}

Referenced by MFDRV_StretchBlt(), and read_bitmap().

get_dib_stride()

static int get_dib_stride ( int  width, int  bpp  )

inlinestatic

Definition at line 198 of file imagelist.c.

{
    return ((width * bpp + 31) >> 3) & ~3;
}

Referenced by _write_bitmap(), EMFDRV_StretchBlt(), get_dib_image_size(), MFDRV_CreateBrushIndirect(), and MFDRV_StretchBlt().

HIMAGELIST_QueryInterface()

HRESULT WINAPI HIMAGELIST_QueryInterface	(	HIMAGELIST	himl,
		REFIID	riid,
		void **	ppv
	)

Definition at line 4038 of file imagelist.c.

{
    TRACE("(%p,%s,%p)\n", himl, debugstr_guid(riid), ppv);
    return IImageList2_QueryInterface((IImageList2 *) himl, riid, ppv);
}

Referenced by ImageListImpl_Clone(), ImageListImpl_GetDragImage(), ImageListImpl_Merge(), init_functions(), and SHGetImageList().

ImageList_Add()

INT WINAPI ImageList_Add	(	HIMAGELIST	himl,
		HBITMAP	hbmImage,
		HBITMAP	hbmMask
	)

Definition at line 448 of file imagelist.c.

{
    HDC     hdcBitmap, hdcTemp = 0;
    INT     nFirstIndex, nImageCount, i;
    BITMAP  bmp;
    POINT   pt;
 
    TRACE("himl=%p hbmimage=%p hbmmask=%p\n", himl, hbmImage, hbmMask);
    if (!is_valid(himl))
        return -1;
 
    if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
        return -1;
 
    TRACE("himl %p, cCurImage %d, cMaxImage %d, cGrow %d, cx %d, cy %d\n",
          himl, himl->cCurImage, himl->cMaxImage, himl->cGrow, himl->cx, himl->cy);
 
    nImageCount = bmp.bmWidth / himl->cx;
 
    TRACE("%p has %d images (%d x %d) bpp %d\n", hbmImage, nImageCount, bmp.bmWidth, bmp.bmHeight,
          bmp.bmBitsPixel);
 
    IMAGELIST_InternalExpandBitmaps(himl, nImageCount);
 
    hdcBitmap = CreateCompatibleDC(0);
 
    SelectObject(hdcBitmap, hbmImage);
 
    if (add_with_alpha( himl, hdcBitmap, himl->cCurImage, nImageCount,
                        himl->cx, min( himl->cy, bmp.bmHeight), hbmImage, hbmMask ))
        goto done;
 
    if (himl->hbmMask)
    {
        hdcTemp = CreateCompatibleDC(0);
        SelectObject(hdcTemp, hbmMask);
    }
 
    if (himl->uBitsPixel <= 8 && bmp.bmBitsPixel <= 8 &&
        !himl->color_table_set && himl->cCurImage == 0)
    {
        RGBQUAD colors[256];
        UINT num = GetDIBColorTable( hdcBitmap, 0, 1 << bmp.bmBitsPixel, colors );
        if (num) ImageList_SetColorTable( himl, 0, num, colors );
    }
 
    for (i=0; i<nImageCount; i++)
    {
        imagelist_point_from_index( himl, himl->cCurImage + i, &pt );
 
        /* Copy result to the imagelist
        */
        BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
                hdcBitmap, i*himl->cx, 0, SRCCOPY );
 
        if (!himl->hbmMask)
             continue;
 
        BitBlt( himl->hdcMask, pt.x, pt.y, himl->cx, bmp.bmHeight,
                hdcTemp, i*himl->cx, 0, SRCCOPY );
 
        /* Remove the background from the image
        */
        BitBlt( himl->hdcImage, pt.x, pt.y, himl->cx, bmp.bmHeight,
                himl->hdcMask, pt.x, pt.y, 0x220326 ); /* NOTSRCAND */
    }
    if (hdcTemp) DeleteDC(hdcTemp);
 
done:
    DeleteDC(hdcBitmap);
 
    nFirstIndex = himl->cCurImage;
    himl->cCurImage += nImageCount;
 
    return nFirstIndex;
}

Referenced by Icon::add_to_imagelist(), AddContentTab(), HEADER_CreateDragImage(), ImageList_AddAlphaIcon(), ImageList_AddMasked(), ImageList_LoadImageW(), ImageListImpl_Add(), init_functions(), LISTVIEW_CreateCheckBoxIL(), LISTVIEW_CreateDragImage(), seltree_create_imagelist(), CRootNode::SetupNode(), and TREEVIEW_CreateDragImage().

ImageList_AddIcon()

INT WINAPI ImageList_AddIcon	(	HIMAGELIST	himl,
		HICON	hIcon
	)

Definition at line 540 of file imagelist.c.

{
    return ImageList_ReplaceIcon (himl, -1, hIcon);
}

ImageList_AddMasked()

INT WINAPI ImageList_AddMasked	(	HIMAGELIST	himl,
		HBITMAP	hBitmap,
		COLORREF	clrMask
	)

Definition at line 563 of file imagelist.c.

{
    HDC    hdcMask, hdcBitmap;
    INT    ret;
    BITMAP bmp;
    HBITMAP hMaskBitmap;
    COLORREF bkColor;
 
    TRACE("himl=%p hbitmap=%p clrmask=%x\n", himl, hBitmap, clrMask);
    if (!is_valid(himl))
        return -1;
 
    if (!GetObjectW(hBitmap, sizeof(BITMAP), &bmp))
        return -1;
 
    hdcBitmap = CreateCompatibleDC(0);
    SelectObject(hdcBitmap, hBitmap);
 
    /* Create a temp Mask so we can remove the background of the Image */
    hdcMask = CreateCompatibleDC(0);
    hMaskBitmap = CreateBitmap(bmp.bmWidth, bmp.bmHeight, 1, 1, NULL);
    SelectObject(hdcMask, hMaskBitmap);
 
    /* create monochrome image to the mask bitmap */
    bkColor = (clrMask != CLR_DEFAULT) ? clrMask : GetPixel (hdcBitmap, 0, 0);
    SetBkColor (hdcBitmap, bkColor);
    BitBlt (hdcMask, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcBitmap, 0, 0, SRCCOPY);
 
    /*
     * Remove the background from the image
     *
     * WINDOWS BUG ALERT!!!!!!
     *  The statement below should not be done in common practice
     *  but this is how ImageList_AddMasked works in Windows.
     *  It overwrites the original bitmap passed, this was discovered
     *  by using the same bitmap to iterate the different styles
     *  on windows where it failed (BUT ImageList_Add is OK)
     *  This is here in case some apps rely on this bug
     *
     *  Blt mode 0x220326 is NOTSRCAND
     */
    if (bmp.bmBitsPixel > 8)  /* NOTSRCAND can't work with palettes */
    {
        SetBkColor(hdcBitmap, RGB(255,255,255));
        BitBlt(hdcBitmap, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcMask, 0, 0, 0x220326);
    }
 
    DeleteDC(hdcBitmap);
    DeleteDC(hdcMask);
 
    ret = ImageList_Add( himl, hBitmap, hMaskBitmap );
 
    DeleteObject(hMaskBitmap);
    return ret;
}

Referenced by cert_mgr_advanced_dlg_proc(), cert_mgr_dlg_proc(), cert_properties_general_dlg_proc(), CreateDragImage(), CShellLink::CreateShortcutIcon(), CreateStateImageList(), CPaintToolBar::DoCreate(), ImageList_LoadImageW(), ImageListImpl_AddMasked(), init_hierarchy_page(), InitImageList(), LV_Init(), Preview_CreateToolBar(), SecurityPageProc(), select_cert_dlg_proc(), CBaseBarSite::SetDeskBarSite(), SetImageList(), ThemePageDlgProc(), TOOLBAR_AddBitmapToImageList(), TOOLBAR_ReplaceBitmap(), and TREEVIEW_InitCheckboxes().

ImageList_BeginDrag()

BOOL WINAPI ImageList_BeginDrag	(	HIMAGELIST	himlTrack,
		INT	iTrack,
		INT	dxHotspot,
		INT	dyHotspot
	)

Definition at line 638 of file imagelist.c.

{
    INT cx, cy;
    POINT src, dst;
 
    TRACE("(himlTrack=%p iTrack=%d dx=%d dy=%d)\n", himlTrack, iTrack,
      dxHotspot, dyHotspot);
 
    if (!is_valid(himlTrack))
    return FALSE;
 
    if (iTrack >= himlTrack->cCurImage)
        return FALSE;
 
    if (InternalDrag.himl)
        return FALSE;
 
    cx = himlTrack->cx;
    cy = himlTrack->cy;
 
    InternalDrag.himlNoCursor = InternalDrag.himl = ImageList_Create (cx, cy, himlTrack->flags, 1, 1);
    if (InternalDrag.himl == NULL) {
        WARN("Error creating drag image list!\n");
        return FALSE;
    }
 
    InternalDrag.dxHotspot = dxHotspot;
    InternalDrag.dyHotspot = dyHotspot;
 
    /* copy image */
    imagelist_point_from_index(InternalDrag.himl, 0, &dst);
    imagelist_point_from_index(himlTrack, iTrack, &src);
    BitBlt(InternalDrag.himl->hdcImage, dst.x, dst.y, cx, cy, himlTrack->hdcImage, src.x, src.y,
            SRCCOPY);
    BitBlt(InternalDrag.himl->hdcMask, dst.x, dst.y, cx, cy, himlTrack->hdcMask, src.x, src.y,
            SRCCOPY);
 
    InternalDrag.himl->cCurImage = 1;
 
    return TRUE;
}

Referenced by GROUP_GroupWndProc(), HEADER_MouseMove(), ImageListImpl_BeginDrag(), init_functions(), and CDefView::OnNotify().

ImageList_CoCreateInstance()

HRESULT WINAPI ImageList_CoCreateInstance	(	REFCLSID	rclsid,
		const IUnknown *	punkOuter,
		REFIID	riid,
		void **	ppv
	)

Definition at line 3430 of file imagelist.c.

{
    TRACE("(%s,%p,%s,%p)\n", debugstr_guid(rclsid), punkOuter, debugstr_guid(riid), ppv);
 
    if (!IsEqualCLSID(&CLSID_ImageList, rclsid))
        return E_NOINTERFACE;
 
    return ImageListImpl_CreateInstance(punkOuter, riid, ppv);
}

Referenced by init_functions().

ImageList_Copy()

BOOL WINAPI ImageList_Copy	(	HIMAGELIST	himlDst,
		INT	iDst,
		HIMAGELIST	himlSrc,
		INT	iSrc,
		UINT	uFlags
	)

Definition at line 706 of file imagelist.c.

{
    POINT ptSrc, ptDst;
 
    TRACE("himlDst=%p iDst=%d himlSrc=%p iSrc=%d\n", himlDst, iDst, himlSrc, iSrc);
 
    if (!is_valid(himlSrc) || !is_valid(himlDst))
    return FALSE;
    if ((iDst < 0) || (iDst >= himlDst->cCurImage))
    return FALSE;
    if ((iSrc < 0) || (iSrc >= himlSrc->cCurImage))
    return FALSE;
 
    imagelist_point_from_index( himlDst, iDst, &ptDst );
    imagelist_point_from_index( himlSrc, iSrc, &ptSrc );
 
    if (uFlags & ILCF_SWAP) {
        /* swap */
        HDC     hdcBmp;
        HBITMAP hbmTempImage, hbmTempMask;
 
        hdcBmp = CreateCompatibleDC (0);
 
        /* create temporary bitmaps */
        hbmTempImage = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
                                       himlSrc->uBitsPixel, NULL);
        hbmTempMask = CreateBitmap (himlSrc->cx, himlSrc->cy, 1,
                      1, NULL);
 
        /* copy (and stretch) destination to temporary bitmaps.(save) */
        /* image */
        SelectObject (hdcBmp, hbmTempImage);
        StretchBlt   (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
                      himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      SRCCOPY);
        /* mask */
        SelectObject (hdcBmp, hbmTempMask);
        StretchBlt   (hdcBmp, 0, 0, himlSrc->cx, himlSrc->cy,
                      himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      SRCCOPY);
 
        /* copy (and stretch) source to destination */
        /* image */
        StretchBlt   (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      SRCCOPY);
        /* mask */
        StretchBlt   (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      SRCCOPY);
 
        /* copy (without stretching) temporary bitmaps to source (restore) */
        /* mask */
        BitBlt       (himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      hdcBmp, 0, 0, SRCCOPY);
 
        /* image */
        BitBlt       (himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      hdcBmp, 0, 0, SRCCOPY);
        /* delete temporary bitmaps */
        DeleteObject (hbmTempMask);
        DeleteObject (hbmTempImage);
        DeleteDC(hdcBmp);
    }
    else {
        /* copy image */
        StretchBlt   (himlDst->hdcImage, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      himlSrc->hdcImage, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      SRCCOPY);
 
        /* copy mask */
        StretchBlt   (himlDst->hdcMask, ptDst.x, ptDst.y, himlDst->cx, himlDst->cy,
                      himlSrc->hdcMask, ptSrc.x, ptSrc.y, himlSrc->cx, himlSrc->cy,
                      SRCCOPY);
    }
 
    return TRUE;
}

Referenced by ImageListImpl_Copy(), and init_functions().

imagelist_copy_images()

static void imagelist_copy_images ( HIMAGELIST  himl, HDC  hdcSrc, HDC  hdcDest, UINT  src, UINT  count, UINT  dest  )

inlinestatic

Definition at line 215 of file imagelist.c.

{
    POINT ptSrc, ptDest;
    SIZE sz;
    UINT i;
 
    for ( i=0; i<TILE_COUNT; i++ )
    {
        imagelist_point_from_index( himl, src+i, &ptSrc );
        imagelist_point_from_index( himl, dest+i, &ptDest );
        sz.cx = himl->cx;
        sz.cy = himl->cy * imagelist_height( count - i );
 
        BitBlt( hdcDest, ptDest.x, ptDest.y, sz.cx, sz.cy,
                hdcSrc, ptSrc.x, ptSrc.y, SRCCOPY );
    }
}

Referenced by ImageList_Remove(), and ImageList_SetImageCount().

ImageList_Create()

HIMAGELIST WINAPI ImageList_Create	(	INT	cx,
		INT	cy,
		UINT	flags,
		INT	cInitial,
		INT	cGrow
	)

Definition at line 804 of file imagelist.c.

{
    HIMAGELIST himl;
    INT      nCount;
    HBITMAP  hbmTemp;
    UINT     ilc = (flags & 0xFE);
    static const WORD aBitBlend25[] =
        {0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00};
 
    static const WORD aBitBlend50[] =
        {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
 
    TRACE("(%d %d 0x%x %d %d)\n", cx, cy, flags, cInitial, cGrow);
 
    if (cx < 0 || cy < 0) return NULL;
    if (!((flags&ILC_COLORDDB) == ILC_COLORDDB) && (cx == 0 || cy == 0)) return NULL;
 
    /* Create the IImageList interface for the image list */
    if (FAILED(ImageListImpl_CreateInstance(NULL, &IID_IImageList, (void **)&himl)))
        return NULL;
 
    cGrow = (WORD)((max( cGrow, 1 ) + 3) & ~3);
 
    if (cGrow > 256)
    {
        /* Windows doesn't limit the size here, but X11 doesn't let us allocate such huge bitmaps */
        WARN( "grow %d too large, limiting to 256\n", cGrow );
        cGrow = 256;
    }
 
    himl->cx        = cx;
    himl->cy        = cy;
    himl->flags     = flags;
    himl->cMaxImage = cInitial + 1;
    himl->cInitial  = cInitial;
    himl->cGrow     = cGrow;
    himl->clrFg     = CLR_DEFAULT;
    himl->clrBk     = CLR_NONE;
    himl->color_table_set = FALSE;
 
    /* initialize overlay mask indices */
    for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
        himl->nOvlIdx[nCount] = -1;
 
    /* Create Image & Mask DCs */
    himl->hdcImage = CreateCompatibleDC (0);
    if (!himl->hdcImage)
        goto cleanup;
    if (himl->flags & ILC_MASK){
        himl->hdcMask = CreateCompatibleDC(0);
        if (!himl->hdcMask)
            goto cleanup;
    }
 
    /* Default to ILC_COLOR4 if none of the ILC_COLOR* flags are specified */
    if (ilc == ILC_COLOR)
    {
        ilc = ILC_COLOR4;
        himl->flags |= ILC_COLOR4;
    }
 
    if (ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32)
        himl->uBitsPixel = ilc;
    else
        himl->uBitsPixel = (UINT)GetDeviceCaps (himl->hdcImage, BITSPIXEL);
 
    if (himl->cMaxImage > 0) {
        himl->hbmImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
    SelectObject(himl->hdcImage, himl->hbmImage);
    } else
        himl->hbmImage = 0;
 
    if ((himl->cMaxImage > 0) && (himl->flags & ILC_MASK)) {
        SIZE sz;
 
        imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
        himl->hbmMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
        if (himl->hbmMask == 0) {
            ERR("Error creating mask bitmap!\n");
            goto cleanup;
        }
        SelectObject(himl->hdcMask, himl->hbmMask);
    }
    else
        himl->hbmMask = 0;
 
    if (ilc == ILC_COLOR32)
        himl->has_alpha = heap_alloc_zero( himl->cMaxImage );
    else
        himl->has_alpha = NULL;
 
    /* create blending brushes */
    hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend25);
    himl->hbrBlend25 = CreatePatternBrush (hbmTemp);
    DeleteObject (hbmTemp);
 
    hbmTemp = CreateBitmap (8, 8, 1, 1, aBitBlend50);
    himl->hbrBlend50 = CreatePatternBrush (hbmTemp);
    DeleteObject (hbmTemp);
 
    TRACE("created imagelist %p\n", himl);
    return himl;
 
cleanup:
    ImageList_Destroy(himl);
    return NULL;
}

Referenced by AddContentTab(), AddListViewItems(), ApplicationPageWndProc(), cert_mgr_advanced_dlg_proc(), cert_mgr_dlg_proc(), cert_properties_general_dlg_proc(), Control_CreateListView(), CreateDragImage(), CShellLink::CreateShortcutIcon(), CreateStateImageList(), DesktopOnInitDialog(), dialog_listview(), CPaintToolBar::DoCreate(), EnumerateConnectedDrives(), FILEDLG95_InitControls(), FileTypesDlg_DoList(), GetGeneralGroupData(), CUIFIcon::GetImageList(), GetUserMembershipData(), GROUP_GroupWndProc(), HEADER_CreateDragImage(), ImageList_BeginDrag(), ImageList_Duplicate(), ImageList_LoadImageW(), ImageList_Merge(), ImageList_Read(), COpenWithDialog::Init(), init_functions(), init_hierarchy_page(), InitGroupMembersList(), CNotifyToolbar::Initialize(), CMainToolbar::InitImageList(), InitImageList(), InitInstance(), InitListViewImage(), InitListViewImageLists(), InitPartitionList(), InitTreeViewImageLists(), InitUserGroupsList(), ShellBrowser::invalidate_cache(), LISTVIEW_CreateCheckBoxIL(), LISTVIEW_CreateDragImage(), LV_Init(), MainFrameBase::MainFrameBase(), CTaskSwitchWnd::OnCreate(), OnGroupsPageInitDialog(), OnInitDialog(), OnInitSettingsPage(), Preview_CreateToolBar(), PROPSHEET_CollectPageInfo(), CNotifyToolbar::ResizeImagelist(), security_on_initdialog(), SecurityPageProc(), select_cert_dlg_proc(), seltree_create_imagelist(), CBaseBarSite::SetDeskBarSite(), CAppsListView::SetDisplayAppType(), SetImageList(), SetupDiGetClassImageListExW(), ShellBrowser::ShellBrowser(), SIC_Initialize(), ThemePageDlgProc(), TOOLBAR_AddBitmap(), TOOLBAR_CheckImageListIconSize(), TREEVIEW_CreateDragImage(), TREEVIEW_InitCheckboxes(), and UpgradeRepairDlgProc().

ImageList_CreateImage()

static HBITMAP ImageList_CreateImage ( HDC  hdc, HIMAGELIST  himl, UINT  count  )

static

Definition at line 3326 of file imagelist.c.

{
    HBITMAP hbmNewBitmap;
    UINT ilc = (himl->flags & 0xFE);
    SIZE sz;
 
    imagelist_get_bitmap_size( himl, count, &sz );
 
    if ((ilc >= ILC_COLOR4 && ilc <= ILC_COLOR32) || ilc == ILC_COLOR)
    {
        char buffer[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
        BITMAPINFO *bmi = (BITMAPINFO *)buffer;
 
        TRACE("Creating DIBSection %d x %d, %d Bits per Pixel\n",
              sz.cx, sz.cy, himl->uBitsPixel);
 
        memset( buffer, 0, sizeof(buffer) );
    bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi->bmiHeader.biWidth = sz.cx;
    bmi->bmiHeader.biHeight = sz.cy;
    bmi->bmiHeader.biPlanes = 1;
    bmi->bmiHeader.biBitCount = himl->uBitsPixel;
    bmi->bmiHeader.biCompression = BI_RGB;
 
    if (himl->uBitsPixel <= ILC_COLOR8)
    {
            if (!himl->color_table_set)
            {
                /* retrieve the default color map */
                HBITMAP tmp = CreateBitmap( 1, 1, 1, 1, NULL );
                GetDIBits( hdc, tmp, 0, 0, NULL, bmi, DIB_RGB_COLORS );
                DeleteObject( tmp );
                if (ilc == ILC_COLOR4)
                {
                    RGBQUAD tmp;
                    tmp = bmi->bmiColors[7];
                    bmi->bmiColors[7] = bmi->bmiColors[8];
                    bmi->bmiColors[8] = tmp;
                }
            }
            else
            {
                GetDIBColorTable(himl->hdcImage, 0, 1 << himl->uBitsPixel, bmi->bmiColors);
            }
        }
    hbmNewBitmap = CreateDIBSection(hdc, bmi, DIB_RGB_COLORS, NULL, 0, 0);
    }
    else /*if (ilc == ILC_COLORDDB)*/
    {
        TRACE("Creating Bitmap: %d Bits per Pixel\n", himl->uBitsPixel);
 
        hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, himl->uBitsPixel, NULL);
    }
    TRACE("returning %p\n", hbmNewBitmap);
    return hbmNewBitmap;
}

Referenced by ImageList_Create(), IMAGELIST_InternalExpandBitmaps(), ImageList_Remove(), ImageList_SetIconSize(), and ImageList_SetImageCount().

ImageList_Destroy()

BOOL WINAPI ImageList_Destroy

(

HIMAGELIST

himl

)

Definition at line 928 of file imagelist.c.

{
    if (!is_valid(himl))
    return FALSE;
 
    IImageList_Release((IImageList *) himl);
    return TRUE;
}

Referenced by cert_mgr_advanced_dlg_proc(), cert_mgr_dlg_proc(), cert_properties_general_callback(), CleanupPartitionList(), CAddressBand::CloseDW(), CToolsBand::CloseDW(), CMainToolbar::Create(), CShellLink::CreateShortcutIcon(), CreateStateImageList(), DependenciesPageProc(), DesktopOnDestroyDialog(), destroy_control(), CSideTreeView::DestroyImageList(), DestroyTreeView(), FileOpenDlgProc95(), GROUP_GroupWndProc(), HEADER_MouseMove(), hierarchy_callback(), iewnd_OnDestroy(), ImageList_Create(), ImageList_EndDrag(), ImageList_SetDragCursorImage(), ImageListImpl_Clone(), ImageListImpl_Merge(), init_functions(), InitImageList(), InitTreeViewImageLists(), ShellBrowser::invalidate_cache(), LISTVIEW_NCDestroy(), LISTVIEW_SetExtendedListViewStyle(), OnInitSettingsPage(), CUIFIcon::operator=(), pCreateToolbar(), Preview_CreateToolBar(), PROPSHEET_CleanUp(), ReleaseHelpViewer(), CNotifyToolbar::ResizeImagelist(), security_on_destroy(), select_cert_dlg_proc(), CAppsListView::SetDisplayAppType(), SetImageList(), SetupDiDestroyClassImageList(), SHGetImageList(), SIC_Destroy(), SIC_Initialize(), SoundsDlgProc(), TOOLBAR_CheckImageListIconSize(), TOOLBAR_Destroy(), TreeListProc(), TreeView_Cleanup(), TV1_Initialize(), TV2_Initialize(), UpgradeRepairDlgProc(), CAppsListView::~CAppsListView(), COpenWithDialog::~COpenWithDialog(), CStartButton::~CStartButton(), CUIFButton::~CUIFButton(), MainFrameBase::~MainFrameBase(), Pane::~Pane(), ShellBrowser::~ShellBrowser(), and TrayNotifyDlg::~TrayNotifyDlg().

ImageList_DragEnter()

BOOL WINAPI ImageList_DragEnter	(	HWND	hwndLock,
		INT	x,
		INT	y
	)

Definition at line 958 of file imagelist.c.

{
    TRACE("(hwnd=%p x=%d y=%d)\n", hwndLock, x, y);
 
    if (!is_valid(InternalDrag.himl))
    return FALSE;
 
    if (hwndLock)
    InternalDrag.hwnd = hwndLock;
    else
    InternalDrag.hwnd = GetDesktopWindow ();
 
    InternalDrag.x = x;
    InternalDrag.y = y;
 
    /* draw the drag image and save the background */
    return ImageList_DragShowNolock(TRUE);
}

Referenced by CDefView::DragEnter(), GROUP_GroupWndProc(), and ImageListImpl_DragEnter().

ImageList_DragLeave()

BOOL WINAPI ImageList_DragLeave

(

HWND

hwndLock

)

Definition at line 992 of file imagelist.c.

{
    /* As we don't save drag info in the window this can lead to problems if
       an app does not supply the same window as DragEnter */
    /* if (hwndLock)
    InternalDrag.hwnd = hwndLock;
    else
    InternalDrag.hwnd = GetDesktopWindow (); */
    if(!hwndLock)
    hwndLock = GetDesktopWindow();
    if(InternalDrag.hwnd != hwndLock)
    FIXME("DragLeave hWnd != DragEnter hWnd\n");
 
    ImageList_DragShowNolock (FALSE);
 
    return TRUE;
}

Referenced by CDefView::DragLeave(), CDefView::Drop(), GROUP_GroupWndProc(), and ImageListImpl_DragLeave().

ImageList_DragMove()

BOOL WINAPI ImageList_DragMove	(	INT	x,
		INT	y
	)

Definition at line 1070 of file imagelist.c.

{
    TRACE("(x=%d y=%d)\n", x, y);
 
    if (!is_valid(InternalDrag.himl))
    return FALSE;
 
    /* draw/update the drag image */
    if (InternalDrag.bShow) {
    HDC hdcDrag;
    HDC hdcOffScreen;
    HDC hdcBg;
    HBITMAP hbmOffScreen;
    INT origNewX, origNewY;
    INT origOldX, origOldY;
    INT origRegX, origRegY;
    INT sizeRegX, sizeRegY;
 
 
    /* calculate the update region */
    origNewX = x - InternalDrag.dxHotspot;
    origNewY = y - InternalDrag.dyHotspot;
    origOldX = InternalDrag.x - InternalDrag.dxHotspot;
    origOldY = InternalDrag.y - InternalDrag.dyHotspot;
    origRegX = min(origNewX, origOldX);
    origRegY = min(origNewY, origOldY);
    sizeRegX = InternalDrag.himl->cx + abs(x - InternalDrag.x);
    sizeRegY = InternalDrag.himl->cy + abs(y - InternalDrag.y);
 
    hdcDrag = GetDCEx(InternalDrag.hwnd, 0,
              DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
        hdcOffScreen = CreateCompatibleDC(hdcDrag);
        hdcBg = CreateCompatibleDC(hdcDrag);
 
    hbmOffScreen = CreateCompatibleBitmap(hdcDrag, sizeRegX, sizeRegY);
    SelectObject(hdcOffScreen, hbmOffScreen);
    SelectObject(hdcBg, InternalDrag.hbmBg);
 
    /* get the actual background of the update region */
    BitBlt(hdcOffScreen, 0, 0, sizeRegX, sizeRegY, hdcDrag,
           origRegX, origRegY, SRCCOPY);
    /* erase the old image */
    BitBlt(hdcOffScreen, origOldX - origRegX, origOldY - origRegY,
           InternalDrag.himl->cx, InternalDrag.himl->cy, hdcBg, 0, 0,
           SRCCOPY);
    /* save the background */
    BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
           hdcOffScreen, origNewX - origRegX, origNewY - origRegY, SRCCOPY);
    /* draw the image */
    ImageList_InternalDragDraw(hdcOffScreen, origNewX - origRegX, 
                   origNewY - origRegY);
    /* draw the update region to the screen */
    BitBlt(hdcDrag, origRegX, origRegY, sizeRegX, sizeRegY,
           hdcOffScreen, 0, 0, SRCCOPY);
 
    DeleteDC(hdcBg);
    DeleteDC(hdcOffScreen);
    DeleteObject(hbmOffScreen);
    ReleaseDC(InternalDrag.hwnd, hdcDrag);
    }
 
    /* update the image position */
    InternalDrag.x = x;
    InternalDrag.y = y;
 
    return TRUE;
}

Referenced by CDefView::DragOver(), GROUP_GroupWndProc(), HEADER_MouseMove(), and ImageListImpl_DragMove().

ImageList_DragShowNolock()

BOOL WINAPI ImageList_DragShowNolock

(

BOOL

bShow

)

Definition at line 1153 of file imagelist.c.

{
    HDC hdcDrag;
    HDC hdcBg;
    INT x, y;
 
    if (!is_valid(InternalDrag.himl))
        return FALSE;
    
    TRACE("bShow=0x%X!\n", bShow);
 
    /* DragImage is already visible/hidden */
    if ((InternalDrag.bShow && bShow) || (!InternalDrag.bShow && !bShow)) {
    return FALSE;
    }
 
    /* position of the origin of the DragImage */
    x = InternalDrag.x - InternalDrag.dxHotspot;
    y = InternalDrag.y - InternalDrag.dyHotspot;
 
    hdcDrag = GetDCEx (InternalDrag.hwnd, 0,
             DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
    if (!hdcDrag) {
    return FALSE;
    }
 
    hdcBg = CreateCompatibleDC(hdcDrag);
    if (!InternalDrag.hbmBg) {
    InternalDrag.hbmBg = CreateCompatibleBitmap(hdcDrag,
            InternalDrag.himl->cx, InternalDrag.himl->cy);
    }
    SelectObject(hdcBg, InternalDrag.hbmBg);
 
    if (bShow) {
    /* save the background */
    BitBlt(hdcBg, 0, 0, InternalDrag.himl->cx, InternalDrag.himl->cy,
           hdcDrag, x, y, SRCCOPY);
    /* show the image */
    ImageList_InternalDragDraw(hdcDrag, x, y);
    } else {
    /* hide the image */
    BitBlt(hdcDrag, x, y, InternalDrag.himl->cx, InternalDrag.himl->cy,
           hdcBg, 0, 0, SRCCOPY);
    }
 
    InternalDrag.bShow = !InternalDrag.bShow;
 
    DeleteDC(hdcBg);
    ReleaseDC (InternalDrag.hwnd, hdcDrag);
    return TRUE;
}

Referenced by HEADER_LButtonUp(), HEADER_MouseMove(), HEADER_Refresh(), ImageList_DragEnter(), ImageList_DragLeave(), ImageList_SetDragCursorImage(), and ImageListImpl_DragShowNolock().

ImageList_Draw()

BOOL WINAPI ImageList_Draw	(	HIMAGELIST	himl,
		INT	i,
		HDC	hdc,
		INT	x,
		INT	y,
		UINT	fStyle
	)

Definition at line 1228 of file imagelist.c.

{
    return ImageList_DrawEx (himl, i, hdc, x, y, 0, 0, 
                     CLR_DEFAULT, CLR_DEFAULT, fStyle);
}

Referenced by CFn_WMDrawItem(), CreateDragImage(), FILEDLG95_LOOKIN_DrawItem(), FileMenu_DrawItem(), init_functions(), LISTVIEW_DrawItemPart(), REBAR_DrawBand(), TAB_DrawItemInterior(), TOOLBAR_CustomizeDialogProc(), TOOLBAR_DrawImage(), TreeListDraw(), TREEVIEW_CreateDragImage(), and TREEVIEW_DrawItem().

ImageList_DrawEx()

BOOL WINAPI ImageList_DrawEx	(	HIMAGELIST	himl,
		INT	i,
		HDC	hdc,
		INT	x,
		INT	y,
		INT	dx,
		INT	dy,
		COLORREF	rgbBk,
		COLORREF	rgbFg,
		UINT	fStyle
	)

Definition at line 1264 of file imagelist.c.

{
    IMAGELISTDRAWPARAMS imldp;
 
    ZeroMemory (&imldp, sizeof(imldp));
    imldp.cbSize  = sizeof(imldp);
    imldp.himl    = himl;
    imldp.i       = i;
    imldp.hdcDst  = hdc;
    imldp.x       = x;
    imldp.y       = y;
    imldp.cx      = dx;
    imldp.cy      = dy;
    imldp.rgbBk   = rgbBk;
    imldp.rgbFg   = rgbFg;
    imldp.fStyle  = fStyle;
 
    return ImageList_DrawIndirect (&imldp);
}

Referenced by Icon::add_to_imagelist(), Icon::create_bitmap(), Icon::draw(), Pane::draw_item(), HEADER_DrawItem(), ImageList_Draw(), LISTVIEW_DrawItemPart(), TOOLBAR_DrawMasked(), and TREEVIEW_DrawItem().

ImageList_DrawIndirect()

BOOL WINAPI ImageList_DrawIndirect

(

IMAGELISTDRAWPARAMS *

pimldp

)

Definition at line 1525 of file imagelist.c.

{
    INT cx, cy, nOvlIdx;
    DWORD fState, dwRop;
    UINT fStyle;
    COLORREF oldImageBk, oldImageFg;
    HDC hImageDC, hImageListDC, hMaskListDC;
    HBITMAP hImageBmp, hOldImageBmp, hBlendMaskBmp;
    BOOL bIsTransparent, bBlend, bResult = FALSE, bMask;
    HIMAGELIST himl;
    HBRUSH hOldBrush;
    POINT pt;
    BOOL has_alpha;
#ifdef __REACTOS__
    HDC hdcSaturated = NULL, hdcSaturatedMask = NULL;
#endif
 
    if (!pimldp || !(himl = pimldp->himl)) return FALSE;
    if (!is_valid(himl)) return FALSE;
    if ((pimldp->i < 0) || (pimldp->i >= himl->cCurImage)) return FALSE;
 
    imagelist_point_from_index( himl, pimldp->i, &pt );
    pt.x += pimldp->xBitmap;
    pt.y += pimldp->yBitmap;
 
    fState = pimldp->cbSize < sizeof(IMAGELISTDRAWPARAMS) ? ILS_NORMAL : pimldp->fState;
    fStyle = pimldp->fStyle & ~ILD_OVERLAYMASK;
    cx = (pimldp->cx == 0) ? himl->cx : pimldp->cx;
    cy = (pimldp->cy == 0) ? himl->cy : pimldp->cy;
 
    bIsTransparent = (fStyle & ILD_TRANSPARENT);
    if( pimldp->rgbBk == CLR_NONE )
        bIsTransparent = TRUE;
    if( ( pimldp->rgbBk == CLR_DEFAULT ) && ( himl->clrBk == CLR_NONE ) )
        bIsTransparent = TRUE;
    bMask = (himl->flags & ILC_MASK) && (fStyle & ILD_MASK) ;
    bBlend = (fStyle & (ILD_BLEND25 | ILD_BLEND50) ) && !bMask;
 
    TRACE("himl(%p) hbmMask(%p) iImage(%d) x(%d) y(%d) cx(%d) cy(%d)\n",
          himl, himl->hbmMask, pimldp->i, pimldp->x, pimldp->y, cx, cy);
 
    /* we will use these DCs to access the images and masks in the ImageList */
    hImageListDC = himl->hdcImage;
    hMaskListDC  = himl->hdcMask;
 
    /* these will accumulate the image and mask for the image we're drawing */
    hImageDC = CreateCompatibleDC( pimldp->hdcDst );
    hImageBmp = CreateCompatibleBitmap( pimldp->hdcDst, cx, cy );
    hBlendMaskBmp = bBlend ? CreateBitmap(cx, cy, 1, 1, NULL) : 0;
 
    /* Create a compatible DC. */
    if (!hImageListDC || !hImageDC || !hImageBmp ||
    (bBlend && !hBlendMaskBmp) || (himl->hbmMask && !hMaskListDC))
    goto cleanup;
    
    hOldImageBmp = SelectObject(hImageDC, hImageBmp);
  
    /*
     * To obtain a transparent look, background color should be set
     * to white and foreground color to black when blitting the
     * monochrome mask.
     */
    oldImageFg = SetTextColor( hImageDC, RGB( 0, 0, 0 ) );
    oldImageBk = SetBkColor( hImageDC, RGB( 0xff, 0xff, 0xff ) );
 
#ifdef __REACTOS__
    /*
     * If the ILS_SATURATE bit is enabled we should multiply the
     * RGB colors of the original image by the contents of rgbFg.
     */
    if (fState & ILS_SATURATE)
    {
        if (saturate_image(himl, pimldp->hdcDst, pimldp->x, pimldp->y,
                           pt.x, pt.y, cx, cy, pimldp->rgbFg,
                           &hdcSaturated, &hdcSaturatedMask))
        {
            hImageListDC = hdcSaturated;
            hMaskListDC = hdcSaturatedMask;
            /* shitty way of getting subroutines to blit at the right place (top left corner),
               as our modified imagelist only contains a single image for performance reasons */
            pt.x = 0;
            pt.y = 0;
        }
    }
#endif
 
    has_alpha = (himl->has_alpha && himl->has_alpha[pimldp->i]);
    if (!bMask && (has_alpha || (fState & ILS_ALPHA)))
    {
        COLORREF colour, blend_col = CLR_NONE;
        BLENDFUNCTION func;
 
        if (bBlend)
        {
            blend_col = pimldp->rgbFg;
            if (blend_col == CLR_DEFAULT) blend_col = GetSysColor( COLOR_HIGHLIGHT );
            else if (blend_col == CLR_NONE) blend_col = GetTextColor( pimldp->hdcDst );
        }
 
        func.BlendOp = AC_SRC_OVER;
        func.BlendFlags = 0;
        func.SourceConstantAlpha = (fState & ILS_ALPHA) ? pimldp->Frame : 255;
        func.AlphaFormat = AC_SRC_ALPHA;
 
        if (bIsTransparent)
        {
#ifdef __REACTOS__
            bResult = alpha_blend_image( himl, hImageListDC, hMaskListDC, pimldp->hdcDst, pimldp->x, pimldp->y,
#else
            bResult = alpha_blend_image( himl, pimldp->hdcDst, pimldp->x, pimldp->y,
#endif
                                         pt.x, pt.y, cx, cy, func, fStyle, blend_col );
            goto end;
        }
        colour = pimldp->rgbBk;
        if (colour == CLR_DEFAULT) colour = himl->clrBk;
        if (colour == CLR_NONE) colour = GetBkColor( pimldp->hdcDst );
 
        hOldBrush = SelectObject (hImageDC, CreateSolidBrush (colour));
        PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
#ifdef __REACTOS__
        alpha_blend_image( himl, hImageListDC, hMaskListDC, hImageDC, 0, 0, pt.x, pt.y, cx, cy, func, fStyle, blend_col );
#else
        alpha_blend_image( himl, hImageDC, 0, 0, pt.x, pt.y, cx, cy, func, fStyle, blend_col );
#endif
        DeleteObject (SelectObject (hImageDC, hOldBrush));
        bResult = BitBlt( pimldp->hdcDst, pimldp->x,  pimldp->y, cx, cy, hImageDC, 0, 0, SRCCOPY );
        goto end;
    }
 
    /*
     * Draw the initial image
     */
    if( bMask ) {
    if (himl->hbmMask) {
            hOldBrush = SelectObject (hImageDC, CreateSolidBrush (GetTextColor(pimldp->hdcDst)));
            PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
            BitBlt(hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCPAINT);
            DeleteObject (SelectObject (hImageDC, hOldBrush));
            if( bIsTransparent )
            {
                BitBlt ( pimldp->hdcDst, pimldp->x,  pimldp->y, cx, cy, hImageDC, 0, 0, SRCAND);
                bResult = TRUE;
                goto end;
            }
    } else {
        hOldBrush = SelectObject (hImageDC, GetStockObject(BLACK_BRUSH));
        PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY);
        SelectObject(hImageDC, hOldBrush);
    }
    } else {
    /* blend the image with the needed solid background */
        COLORREF colour = RGB(0,0,0);
 
        if( !bIsTransparent )
        {
            colour = pimldp->rgbBk;
            if( colour == CLR_DEFAULT )
                colour = himl->clrBk;
            if( colour == CLR_NONE )
                colour = GetBkColor(pimldp->hdcDst);
        }
 
        hOldBrush = SelectObject (hImageDC, CreateSolidBrush (colour));
        PatBlt( hImageDC, 0, 0, cx, cy, PATCOPY );
        if (himl->hbmMask)
        {
            BitBlt( hImageDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND );
            BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCPAINT );
        }
        else
            BitBlt( hImageDC, 0, 0, cx, cy, hImageListDC, pt.x, pt.y, SRCCOPY);
        DeleteObject (SelectObject (hImageDC, hOldBrush));
    }
 
    /* Time for blending, if required */
    if (bBlend) {
    HBRUSH hBlendBrush;
        COLORREF clrBlend = pimldp->rgbFg;
    HDC hBlendMaskDC = hImageListDC;
    HBITMAP hOldBitmap;
 
    /* Create the blend Mask */
        hOldBitmap = SelectObject(hBlendMaskDC, hBlendMaskBmp);
    hBlendBrush = fStyle & ILD_BLEND50 ? himl->hbrBlend50 : himl->hbrBlend25;
        hOldBrush = SelectObject(hBlendMaskDC, hBlendBrush);
        PatBlt(hBlendMaskDC, 0, 0, cx, cy, PATCOPY);
        SelectObject(hBlendMaskDC, hOldBrush);
 
        /* Modify the blend mask if an Image Mask exist */
        if(himl->hbmMask) {
        BitBlt(hBlendMaskDC, 0, 0, cx, cy, hMaskListDC, pt.x, pt.y, 0x220326); /* NOTSRCAND */
        BitBlt(hBlendMaskDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, NOTSRCCOPY);
    }
 
    /* now apply blend to the current image given the BlendMask */
        if (clrBlend == CLR_DEFAULT) clrBlend = GetSysColor (COLOR_HIGHLIGHT);
        else if (clrBlend == CLR_NONE) clrBlend = GetTextColor (pimldp->hdcDst);
    hOldBrush = SelectObject (hImageDC, CreateSolidBrush(clrBlend));
    BitBlt (hImageDC, 0, 0, cx, cy, hBlendMaskDC, 0, 0, 0xB8074A); /* PSDPxax */
    DeleteObject(SelectObject(hImageDC, hOldBrush));
    SelectObject(hBlendMaskDC, hOldBitmap);
    }
 
    /* Now do the overlay image, if any */
    nOvlIdx = (pimldp->fStyle & ILD_OVERLAYMASK) >> 8;
    if ( (nOvlIdx >= 1) && (nOvlIdx <= MAX_OVERLAYIMAGE)) {
    nOvlIdx = himl->nOvlIdx[nOvlIdx - 1];
    if ((nOvlIdx >= 0) && (nOvlIdx < himl->cCurImage)) {
            POINT ptOvl;
            imagelist_point_from_index( himl, nOvlIdx, &ptOvl );
            ptOvl.x += pimldp->xBitmap;
        if (himl->hbmMask && !(fStyle & ILD_IMAGE))
        BitBlt (hImageDC, 0, 0, cx, cy, hMaskListDC, ptOvl.x, ptOvl.y, SRCAND);
        BitBlt (hImageDC, 0, 0, cx, cy, hImageListDC, ptOvl.x, ptOvl.y, SRCPAINT);
    }
    }
 
#ifndef __REACTOS__
    if (fState & ILS_SATURATE) FIXME("ILS_SATURATE: unimplemented!\n");
#endif
    if (fState & ILS_GLOW) FIXME("ILS_GLOW: unimplemented!\n");
    if (fState & ILS_SHADOW) FIXME("ILS_SHADOW: unimplemented!\n");
 
    if (fStyle & ILD_PRESERVEALPHA) FIXME("ILD_PRESERVEALPHA: unimplemented!\n");
    if (fStyle & ILD_SCALE) FIXME("ILD_SCALE: unimplemented!\n");
    if (fStyle & ILD_DPISCALE) FIXME("ILD_DPISCALE: unimplemented!\n");
 
    /* now copy the image to the screen */
    dwRop = SRCCOPY;
    if (himl->hbmMask && bIsTransparent ) {
    COLORREF oldDstFg = SetTextColor(pimldp->hdcDst, RGB( 0, 0, 0 ) );
    COLORREF oldDstBk = SetBkColor(pimldp->hdcDst, RGB( 0xff, 0xff, 0xff ));
        BitBlt (pimldp->hdcDst, pimldp->x,  pimldp->y, cx, cy, hMaskListDC, pt.x, pt.y, SRCAND);
    SetBkColor(pimldp->hdcDst, oldDstBk);
    SetTextColor(pimldp->hdcDst, oldDstFg);
    dwRop = SRCPAINT;
    }
    if (fStyle & ILD_ROP) dwRop = pimldp->dwRop;
    BitBlt (pimldp->hdcDst, pimldp->x,  pimldp->y, cx, cy, hImageDC, 0, 0, dwRop);
 
    bResult = TRUE;
end:
    /* cleanup the mess */
    SetBkColor(hImageDC, oldImageBk);
    SetTextColor(hImageDC, oldImageFg);
    SelectObject(hImageDC, hOldImageBmp);
cleanup:
#ifdef __REACTOS__
    if (hdcSaturated)
        DeleteDC(hdcSaturated);
    if (hdcSaturatedMask)
        DeleteDC(hdcSaturatedMask);
#endif
    DeleteObject(hBlendMaskBmp);
    DeleteObject(hImageBmp);
    DeleteDC(hImageDC);
 
    return bResult;
}

Referenced by ImageList_DrawEx(), ImageList_InternalDragDraw(), ImageListImpl_Draw(), init_functions(), and TOOLBAR_DrawImage().

ImageList_Duplicate()

HIMAGELIST WINAPI ImageList_Duplicate

(

HIMAGELIST

himlSrc

)

Definition at line 1801 of file imagelist.c.

{
    HIMAGELIST himlDst;
 
    if (!is_valid(himlSrc)) {
        ERR("Invalid image list handle!\n");
        return NULL;
    }
 
    himlDst = ImageList_Create (himlSrc->cx, himlSrc->cy, himlSrc->flags,
                                himlSrc->cCurImage, himlSrc->cGrow);
 
    if (himlDst)
    {
        SIZE sz;
 
        imagelist_get_bitmap_size(himlSrc, himlSrc->cCurImage, &sz);
        BitBlt (himlDst->hdcImage, 0, 0, sz.cx, sz.cy,
                himlSrc->hdcImage, 0, 0, SRCCOPY);
 
        if (himlDst->hbmMask)
            BitBlt (himlDst->hdcMask, 0, 0, sz.cx, sz.cy,
                    himlSrc->hdcMask, 0, 0, SRCCOPY);
 
    himlDst->cCurImage = himlSrc->cCurImage;
        if (himlSrc->has_alpha && himlDst->has_alpha)
            memcpy( himlDst->has_alpha, himlSrc->has_alpha, himlDst->cCurImage );
    }
    return himlDst;
}

Referenced by ImageListImpl_Clone(), CNetConnectionPropertyUi::InitializeLANPropertiesUIDlg(), and SHGetImageList().

ImageList_EndDrag()

VOID WINAPI ImageList_EndDrag

(

void

)

Definition at line 1847 of file imagelist.c.

{
    /* cleanup the InternalDrag struct */
    InternalDrag.hwnd = 0;
    if (InternalDrag.himl != InternalDrag.himlNoCursor)
        ImageList_Destroy (InternalDrag.himlNoCursor);
    ImageList_Destroy (InternalDrag.himl);
    InternalDrag.himlNoCursor = InternalDrag.himl = 0;
    InternalDrag.x= 0;
    InternalDrag.y= 0;
    InternalDrag.dxHotspot = 0;
    InternalDrag.dyHotspot = 0;
    InternalDrag.bShow = FALSE;
    DeleteObject(InternalDrag.hbmBg);
    InternalDrag.hbmBg = 0;
}

Referenced by CDefView::Drop(), GROUP_GroupWndProc(), HEADER_LButtonUp(), ImageListImpl_EndDrag(), and init_functions().

imagelist_get_bitmap_size()

static void imagelist_get_bitmap_size ( HIMAGELIST  himl, UINT  count, SIZE *  sz  )

inlinestatic

Definition at line 192 of file imagelist.c.

{
    sz->cx = himl->cx * TILE_COUNT;
    sz->cy = imagelist_height( count ) * himl->cy;
}

Referenced by check_iml_data(), ImageList_Create(), ImageList_CreateImage(), ImageList_Duplicate(), IMAGELIST_InternalExpandBitmaps(), ImageList_Remove(), ImageList_SetIconSize(), and ImageList_SetImageCount().

ImageList_GetBkColor()

COLORREF WINAPI ImageList_GetBkColor

(

HIMAGELIST

himl

)

Definition at line 1879 of file imagelist.c.

{
    return himl ? himl->clrBk : CLR_NONE;
}

Referenced by ImageListImpl_GetBkColor().

ImageList_GetDragImage()

HIMAGELIST WINAPI ImageList_GetDragImage	(	POINT *	ppt,
		POINT *	pptHotspot
	)

Definition at line 1900 of file imagelist.c.

{
    if (is_valid(InternalDrag.himl)) {
    if (ppt) {
        ppt->x = InternalDrag.x;
        ppt->y = InternalDrag.y;
    }
    if (pptHotspot) {
        pptHotspot->x = InternalDrag.dxHotspot;
        pptHotspot->y = InternalDrag.dyHotspot;
    }
        return (InternalDrag.himl);
    }
 
    return NULL;
}

Referenced by ImageListImpl_GetDragImage(), and init_functions().

ImageList_GetFlags()

DWORD WINAPI ImageList_GetFlags

(

HIMAGELIST

himl

)

Definition at line 1934 of file imagelist.c.

{
    TRACE("%p\n", himl);
#ifdef __REACTOS__
    if(!is_valid2(himl))
        return 0;
    return himl->flags;
#else
    return is_valid(himl) ? himl->flags : 0;
#endif
}

Referenced by init_functions().

ImageList_GetIcon()

HICON WINAPI ImageList_GetIcon	(	HIMAGELIST	himl,
		INT	i,
		UINT	fStyle
	)

Definition at line 1963 of file imagelist.c.

{
    ICONINFO ii;
    HICON hIcon;
    HBITMAP hOldDstBitmap;
    HDC hdcDst;
    POINT pt;
 
    TRACE("%p %d %d\n", himl, i, fStyle);
    if (!is_valid(himl) || (i < 0) || (i >= himl->cCurImage)) return NULL;
 
    ii.fIcon = TRUE;
    ii.xHotspot = 0;
    ii.yHotspot = 0;
 
    /* create colour bitmap */
    hdcDst = GetDC(0);
    ii.hbmColor = CreateCompatibleBitmap(hdcDst, himl->cx, himl->cy);
    ReleaseDC(0, hdcDst);
 
    hdcDst = CreateCompatibleDC(0);
 
    imagelist_point_from_index( himl, i, &pt );
 
    /* draw mask*/
    ii.hbmMask  = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
    hOldDstBitmap = SelectObject (hdcDst, ii.hbmMask);
    if (himl->hbmMask) {
        BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
                himl->hdcMask, pt.x, pt.y, SRCCOPY);
    }
    else
        PatBlt (hdcDst, 0, 0, himl->cx, himl->cy, BLACKNESS);
 
    /* draw image*/
    SelectObject (hdcDst, ii.hbmColor);
    BitBlt (hdcDst, 0, 0, himl->cx, himl->cy,
            himl->hdcImage, pt.x, pt.y, SRCCOPY);
 
    /*
     * CreateIconIndirect requires us to deselect the bitmaps from
     * the DCs before calling
     */
    SelectObject(hdcDst, hOldDstBitmap);
 
    hIcon = CreateIconIndirect (&ii);
 
    DeleteObject (ii.hbmMask);
    DeleteObject (ii.hbmColor);
    DeleteDC (hdcDst);
 
    return hIcon;
}

Referenced by CShellBrowser::BrowseToPath(), CShellLink::CreateShortcutIcon(), ImageListImpl_GetIcon(), SHGetFileInfoW(), and SIC_OverlayShortcutImage().

ImageList_GetIconSize()

BOOL WINAPI ImageList_GetIconSize	(	HIMAGELIST	himl,
		INT *	cx,
		INT *	cy
	)

Definition at line 2037 of file imagelist.c.

{
    if (!is_valid(himl) || !cx || !cy)
    return FALSE;
 
    *cx = himl->cx;
    *cy = himl->cy;
 
    return TRUE;
}

Referenced by Icon::add_to_imagelist(), CFn_WMDrawItem(), CFn_WMMeasureItem(), Icon::create_bitmap(), HEADER_DrawItem(), ImageListImpl_GetIconSize(), init_functions(), LISTVIEW_SetColumnWidth(), LISTVIEW_SetIconSpacing(), REBAR_SetBarInfo(), CNotifyToolbar::ResizeImagelist(), set_icon_size(), TAB_DrawItemInterior(), TAB_SetItemBounds(), TOOLBAR_AddBitmapToImageList(), TOOLBAR_CheckImageListIconSize(), TOOLBAR_DrawMasked(), TOOLBAR_SetImageList(), TREEVIEW_CreateDragImage(), TREEVIEW_SetImageList(), and CTaskSwitchWnd::UpdateButtonsSize().

ImageList_GetImageCount()

INT WINAPI ImageList_GetImageCount

(

HIMAGELIST

himl

)

Definition at line 2063 of file imagelist.c.

{
    if (!is_valid(himl))
    return 0;
 
    return himl->cCurImage;
}

Referenced by DisplayImageList(), ImageListImpl_GetImageCount(), init_functions(), InitListViewImageLists(), InitTreeViewImageLists(), TOOLBAR_AddBitmapToImageList(), TOOLBAR_CheckImageListIconSize(), TOOLBAR_DrawButton(), TOOLBAR_IsValidBitmapIndex(), TOOLBAR_IsValidImageList(), TOOLBAR_Refresh(), TOOLBAR_ReplaceBitmap(), TOOLBAR_SetBitmapSize(), and TOOLBAR_SetImageList().

ImageList_GetImageInfo()

BOOL WINAPI ImageList_GetImageInfo	(	HIMAGELIST	himl,
		INT	i,
		IMAGEINFO *	pImageInfo
	)

Definition at line 2088 of file imagelist.c.

{
    POINT pt;
 
    if (!is_valid(himl) || (pImageInfo == NULL))
    return FALSE;
    if ((i < 0) || (i >= himl->cCurImage))
    return FALSE;
 
    pImageInfo->hbmImage = himl->hbmImage;
    pImageInfo->hbmMask  = himl->hbmMask;
 
    imagelist_point_from_index( himl, i, &pt );
    pImageInfo->rcImage.top    = pt.y;
    pImageInfo->rcImage.bottom = pt.y + himl->cy;
    pImageInfo->rcImage.left   = pt.x;
    pImageInfo->rcImage.right  = pt.x + himl->cx;
 
    return TRUE;
}

Referenced by ImageList_GetImageRect(), ImageListImpl_GetImageInfo(), ImageListImpl_GetImageRect(), init_functions(), TOOLBAR_DrawImage(), and TreeListProc().

ImageList_GetImageRect()

BOOL WINAPI ImageList_GetImageRect	(	HIMAGELIST	himl,
		INT	i,
		LPRECT	lpRect
	)

Definition at line 2129 of file imagelist.c.

{
#ifdef __REACTOS__
    IMAGEINFO ImageInfo;
    if (!ImageList_GetImageInfo(himl, i, &ImageInfo))
        return FALSE;
    *lpRect = ImageInfo.rcImage;
#else
    POINT pt;
 
    if (!is_valid(himl) || (lpRect == NULL))
    return FALSE;
    if ((i < 0) || (i >= himl->cCurImage))
    return FALSE;
 
    imagelist_point_from_index( himl, i, &pt );
    lpRect->left   = pt.x;
    lpRect->top    = pt.y;
    lpRect->right  = pt.x + himl->cx;
    lpRect->bottom = pt.y + himl->cy;
#endif
    return TRUE;
}

imagelist_height()

static UINT imagelist_height ( UINT  count )

inlinestatic

Definition at line 181 of file imagelist.c.

{
    return ((count + TILE_COUNT - 1)/TILE_COUNT);
}

Referenced by imagelist_copy_images(), and imagelist_get_bitmap_size().

ImageList_InternalDragDraw()

static void ImageList_InternalDragDraw ( HDC  hdc, INT  x, INT  y  )

inlinestatic

Definition at line 1032 of file imagelist.c.

{
    IMAGELISTDRAWPARAMS imldp;
 
    ZeroMemory (&imldp, sizeof(imldp));
    imldp.cbSize  = sizeof(imldp);
    imldp.himl    = InternalDrag.himl;
    imldp.i       = 0;
    imldp.hdcDst  = hdc;
    imldp.x       = x;
    imldp.y       = y;
    imldp.rgbBk   = CLR_DEFAULT;
    imldp.rgbFg   = CLR_DEFAULT;
    imldp.fStyle  = ILD_NORMAL;
    imldp.fState  = ILS_ALPHA;
    imldp.Frame   = 192;
    ImageList_DrawIndirect (&imldp);
}

Referenced by ImageList_DragMove(), and ImageList_DragShowNolock().

IMAGELIST_InternalExpandBitmaps()

static void IMAGELIST_InternalExpandBitmaps ( HIMAGELIST  himl, INT  nImageCount  )

static

Definition at line 361 of file imagelist.c.

{
    HDC     hdcBitmap;
    HBITMAP hbmNewBitmap, hbmNull;
    INT     nNewCount;
    SIZE    sz;
 
    TRACE("%p has allocated %d, max %d, grow %d images\n", himl, himl->cCurImage, himl->cMaxImage, himl->cGrow);
 
    if (himl->cCurImage + nImageCount < himl->cMaxImage)
        return;
 
    nNewCount = himl->cMaxImage + max(nImageCount, himl->cGrow) + 1;
 
    imagelist_get_bitmap_size(himl, nNewCount, &sz);
 
    TRACE("Create expanded bitmaps : himl=%p x=%d y=%d count=%d\n", himl, sz.cx, sz.cy, nNewCount);
    hdcBitmap = CreateCompatibleDC (0);
 
    hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount);
 
    if (hbmNewBitmap == 0)
        ERR("creating new image bitmap (x=%d y=%d)!\n", sz.cx, sz.cy);
 
    if (himl->cCurImage)
    {
        hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
        BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
                himl->hdcImage, 0, 0, SRCCOPY);
        SelectObject (hdcBitmap, hbmNull);
    }
    SelectObject (himl->hdcImage, hbmNewBitmap);
    DeleteObject (himl->hbmImage);
    himl->hbmImage = hbmNewBitmap;
 
    if (himl->flags & ILC_MASK)
    {
        hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
 
        if (hbmNewBitmap == 0)
            ERR("creating new mask bitmap!\n");
 
    if(himl->cCurImage)
    {
        hbmNull = SelectObject (hdcBitmap, hbmNewBitmap);
        BitBlt (hdcBitmap, 0, 0, sz.cx, sz.cy,
            himl->hdcMask, 0, 0, SRCCOPY);
        SelectObject (hdcBitmap, hbmNull);
    }
        SelectObject (himl->hdcMask, hbmNewBitmap);
        DeleteObject (himl->hbmMask);
        himl->hbmMask = hbmNewBitmap;
    }
 
    if (himl->has_alpha)
    {
        char *new_alpha = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, himl->has_alpha, nNewCount );
        if (new_alpha) himl->has_alpha = new_alpha;
        else
        {
            heap_free( himl->has_alpha );
            himl->has_alpha = NULL;
        }
    }
 
    himl->cMaxImage = nNewCount;
 
    DeleteDC (hdcBitmap);
}

Referenced by ImageList_Add(), and ImageList_ReplaceIcon().

ImageList_LoadImageA()

HIMAGELIST WINAPI ImageList_LoadImageA	(	HINSTANCE	hi,
		LPCSTR	lpbmp,
		INT	cx,
		INT	cGrow,
		COLORREF	clrMask,
		UINT	uType,
		UINT	uFlags
	)

Definition at line 2164 of file imagelist.c.

{
    HIMAGELIST himl;
    LPWSTR lpbmpW;
    DWORD len;
 
    if (IS_INTRESOURCE(lpbmp))
        return ImageList_LoadImageW(hi, (LPCWSTR)lpbmp, cx, cGrow, clrMask,
                                    uType, uFlags);
 
    len = MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, NULL, 0);
    lpbmpW = heap_alloc(len * sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, lpbmp, -1, lpbmpW, len);
 
    himl = ImageList_LoadImageW(hi, lpbmpW, cx, cGrow, clrMask, uType, uFlags);
    heap_free (lpbmpW);
    return himl;
}

Referenced by init_functions().

ImageList_LoadImageW()

HIMAGELIST WINAPI ImageList_LoadImageW	(	HINSTANCE	hi,
		LPCWSTR	lpbmp,
		INT	cx,
		INT	cGrow,
		COLORREF	clrMask,
		UINT	uType,
		UINT	uFlags
	)

Definition at line 2208 of file imagelist.c.

{
    HIMAGELIST himl = NULL;
    HANDLE   handle;
    INT      nImageCount;
 
    handle = LoadImageW (hi, lpbmp, uType, 0, 0, uFlags);
    if (!handle) {
        WARN("Couldn't load image\n");
        return NULL;
    }
 
    if (uType == IMAGE_BITMAP) {
        DIBSECTION dib;
        UINT color;
 
        if (GetObjectW (handle, sizeof(dib), &dib) == sizeof(BITMAP)) color = ILC_COLOR;
        else color = dib.dsBm.bmBitsPixel;
 
        /* To match windows behavior, if cx is set to zero and
         the flag DI_DEFAULTSIZE is specified, cx becomes the
         system metric value for icons. If the flag is not specified
         the function sets the size to the height of the bitmap */
        if (cx == 0)
        {
            if (uFlags & DI_DEFAULTSIZE)
                cx = GetSystemMetrics (SM_CXICON);
            else
                cx = dib.dsBm.bmHeight;
        }
 
        nImageCount = dib.dsBm.bmWidth / cx;
 
        if (clrMask != CLR_NONE) color |= ILC_MASK;
        himl = ImageList_Create (cx, dib.dsBm.bmHeight, color, nImageCount, cGrow);
        if (!himl) {
            DeleteObject (handle);
            return NULL;
        }
        ImageList_AddMasked (himl, handle, clrMask);
    }
    else if ((uType == IMAGE_ICON) || (uType == IMAGE_CURSOR)) {
        ICONINFO ii;
        BITMAP bmp;
 
        GetIconInfo (handle, &ii);
        GetObjectW (ii.hbmColor, sizeof(BITMAP), &bmp);
        himl = ImageList_Create (bmp.bmWidth, bmp.bmHeight,
                                 ILC_MASK | ILC_COLOR, 1, cGrow);
        if (!himl) {
            DeleteObject (ii.hbmColor);
            DeleteObject (ii.hbmMask);
            DeleteObject (handle);
            return NULL;
        }
        ImageList_Add (himl, ii.hbmColor, ii.hbmMask);
        DeleteObject (ii.hbmColor);
        DeleteObject (ii.hbmMask);
    }
 
    DeleteObject (handle);
 
    return himl;
}

Referenced by CFn_WMInitDialog(), CFn_WMMeasureItem(), create_rebar(), CAddressBand::CreateGoButton(), ImageList_LoadImageA(), init_functions(), CStartButton::Initialize(), CToolsBand::SetSite(), and wWinMain().

ImageList_Merge()

HIMAGELIST WINAPI ImageList_Merge	(	HIMAGELIST	himl1,
		INT	i1,
		HIMAGELIST	himl2,
		INT	i2,
		INT	dx,
		INT	dy
	)

Definition at line 2300 of file imagelist.c.

{
    HIMAGELIST himlDst = NULL;
    INT      cxDst, cyDst;
    INT      xOff1, yOff1, xOff2, yOff2;
    POINT    pt1, pt2;
    INT      newFlags;
 
    TRACE("(himl1=%p i1=%d himl2=%p i2=%d dx=%d dy=%d)\n", himl1, i1, himl2,
       i2, dx, dy);
 
    if (!is_valid(himl1) || !is_valid(himl2))
    return NULL;
 
    if (dx > 0) {
        cxDst = max (himl1->cx, dx + himl2->cx);
        xOff1 = 0;
        xOff2 = dx;
    }
    else if (dx < 0) {
        cxDst = max (himl2->cx, himl1->cx - dx);
        xOff1 = -dx;
        xOff2 = 0;
    }
    else {
        cxDst = max (himl1->cx, himl2->cx);
        xOff1 = 0;
        xOff2 = 0;
    }
 
    if (dy > 0) {
        cyDst = max (himl1->cy, dy + himl2->cy);
        yOff1 = 0;
        yOff2 = dy;
    }
    else if (dy < 0) {
        cyDst = max (himl2->cy, himl1->cy - dy);
        yOff1 = -dy;
        yOff2 = 0;
    }
    else {
        cyDst = max (himl1->cy, himl2->cy);
        yOff1 = 0;
        yOff2 = 0;
    }
 
    newFlags = (himl1->flags > himl2->flags ? himl1->flags : himl2->flags) & ILC_COLORDDB;
    if (newFlags == ILC_COLORDDB && (himl1->flags & ILC_COLORDDB) == ILC_COLOR16)
        newFlags = ILC_COLOR16; /* this is what native (at least v5) does, don't know why */
    himlDst = ImageList_Create (cxDst, cyDst, ILC_MASK | newFlags, 1, 1);
 
    if (himlDst)
    {
        imagelist_point_from_index( himl1, i1, &pt1 );
        imagelist_point_from_index( himl2, i2, &pt2 );
 
        /* copy image */
        BitBlt (himlDst->hdcImage, 0, 0, cxDst, cyDst, himl1->hdcImage, 0, 0, BLACKNESS);
        if (i1 >= 0 && i1 < himl1->cCurImage)
            BitBlt (himlDst->hdcImage, xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcImage, pt1.x, pt1.y, SRCCOPY);
        if (i2 >= 0 && i2 < himl2->cCurImage)
        {
            if (himl2->flags & ILC_MASK)
            {
                BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask , pt2.x, pt2.y, SRCAND);
                BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcImage, pt2.x, pt2.y, SRCPAINT);
            }
            else
                BitBlt (himlDst->hdcImage, xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcImage, pt2.x, pt2.y, SRCCOPY);
        }
 
        /* copy mask */
        BitBlt (himlDst->hdcMask, 0, 0, cxDst, cyDst, himl1->hdcMask, 0, 0, WHITENESS);
        if (i1 >= 0 && i1 < himl1->cCurImage)
            BitBlt (himlDst->hdcMask,  xOff1, yOff1, himl1->cx, himl1->cy, himl1->hdcMask,  pt1.x, pt1.y, SRCCOPY);
        if (i2 >= 0 && i2 < himl2->cCurImage)
            BitBlt (himlDst->hdcMask,  xOff2, yOff2, himl2->cx, himl2->cy, himl2->hdcMask,  pt2.x, pt2.y, SRCAND);
 
    himlDst->cCurImage = 1;
    }
 
    return himlDst;
}

Referenced by GROUP_GroupWndProc(), ImageList_SetDragCursorImage(), ImageListImpl_Merge(), and init_functions().

imagelist_point_from_index()

static void imagelist_point_from_index ( HIMAGELIST  himl, UINT  index, LPPOINT  pt  )

inlinestatic

Definition at line 186 of file imagelist.c.

{
    pt->x = (index%TILE_COUNT) * himl->cx;
    pt->y = (index/TILE_COUNT) * himl->cy;
}

Referenced by add_dib_bits(), ImageList_Add(), ImageList_BeginDrag(), ImageList_Copy(), imagelist_copy_images(), ImageList_DrawIndirect(), ImageList_GetIcon(), ImageList_GetImageInfo(), ImageList_GetImageRect(), ImageList_Merge(), ImageList_Replace(), and ImageList_ReplaceIcon().

ImageList_Read()

HIMAGELIST WINAPI ImageList_Read

(

IStream *

pstm

)

Definition at line 2463 of file imagelist.c.

{
    char image_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
    char mask_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
    BITMAPINFO *image_info = (BITMAPINFO *)image_buf;
    BITMAPINFO *mask_info = (BITMAPINFO *)mask_buf;
    void *image_bits, *mask_bits = NULL;
    ILHEAD  ilHead;
    HIMAGELIST  himl;
    unsigned int i;
 
    TRACE("%p\n", pstm);
 
    if (FAILED(IStream_Read (pstm, &ilHead, sizeof(ILHEAD), NULL)))
    return NULL;
    if (ilHead.usMagic != (('L' << 8) | 'I'))
    return NULL;
    if (ilHead.usVersion != 0x101) /* probably version? */
    return NULL;
 
    TRACE("cx %u, cy %u, flags 0x%04x, cCurImage %u, cMaxImage %u\n",
          ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
 
    himl = ImageList_Create(ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cMaxImage, ilHead.cGrow);
    if (!himl)
    return NULL;
 
    if (!(image_bits = read_bitmap(pstm, image_info)))
    {
    WARN("failed to read bitmap from stream\n");
    return NULL;
    }
    if (ilHead.flags & ILC_MASK)
    {
        if (!(mask_bits = read_bitmap(pstm, mask_info)))
        {
            WARN("failed to read mask bitmap from stream\n");
        return NULL;
    }
    }
    else mask_info = NULL;
 
    if (himl->has_alpha && image_info->bmiHeader.biBitCount == 32)
    {
        DWORD *ptr = image_bits;
        BYTE *mask_ptr = mask_bits;
        int stride = himl->cy * image_info->bmiHeader.biWidth;
 
        if (image_info->bmiHeader.biHeight > 0)  /* bottom-up */
        {
            ptr += image_info->bmiHeader.biHeight * image_info->bmiHeader.biWidth - stride;
            mask_ptr += (image_info->bmiHeader.biHeight * image_info->bmiHeader.biWidth - stride) / 8;
            stride = -stride;
            image_info->bmiHeader.biHeight = himl->cy;
        }
        else image_info->bmiHeader.biHeight = -himl->cy;
 
        for (i = 0; i < ilHead.cCurImage; i += TILE_COUNT)
        {
            add_dib_bits( himl, i, min( ilHead.cCurImage - i, TILE_COUNT ),
                          himl->cx, himl->cy, image_info, mask_info, ptr, mask_ptr );
            ptr += stride;
            mask_ptr += stride / 8;
        }
    }
    else
    {
        StretchDIBits( himl->hdcImage, 0, 0, image_info->bmiHeader.biWidth, image_info->bmiHeader.biHeight,
                       0, 0, image_info->bmiHeader.biWidth, image_info->bmiHeader.biHeight,
                       image_bits, image_info, DIB_RGB_COLORS, SRCCOPY);
        if (mask_info)
            StretchDIBits( himl->hdcMask, 0, 0, mask_info->bmiHeader.biWidth, mask_info->bmiHeader.biHeight,
                           0, 0, mask_info->bmiHeader.biWidth, mask_info->bmiHeader.biHeight,
                           mask_bits, mask_info, DIB_RGB_COLORS, SRCCOPY);
    }
    heap_free( image_bits );
    heap_free( mask_bits );
 
    himl->cCurImage = ilHead.cCurImage;
    himl->cMaxImage = ilHead.cMaxImage;
 
    ImageList_SetBkColor(himl,ilHead.bkcolor);
    for (i=0;i<4;i++)
    ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
    return himl;
}

Referenced by init_functions().

ImageList_Remove()

BOOL WINAPI ImageList_Remove	(	HIMAGELIST	himl,
		INT	i
	)

Definition at line 2568 of file imagelist.c.

{
    HBITMAP hbmNewImage, hbmNewMask;
    HDC     hdcBmp;
    SIZE    sz;
 
    TRACE("(himl=%p i=%d)\n", himl, i);
 
    if (!is_valid(himl)) {
        ERR("Invalid image list handle!\n");
        return FALSE;
    }
 
    if ((i < -1) || (i >= himl->cCurImage)) {
        TRACE("index out of range! %d\n", i);
        return FALSE;
    }
 
    if (i == -1) {
        INT nCount;
 
        /* remove all */
    if (himl->cCurImage == 0) {
        /* remove all on empty ImageList is allowed */
        TRACE("remove all on empty ImageList!\n");
        return TRUE;
    }
 
        himl->cMaxImage = himl->cGrow;
        himl->cCurImage = 0;
        for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
             himl->nOvlIdx[nCount] = -1;
 
        if (himl->has_alpha)
        {
            heap_free( himl->has_alpha );
            himl->has_alpha = heap_alloc_zero( himl->cMaxImage );
        }
 
        hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
        SelectObject (himl->hdcImage, hbmNewImage);
        DeleteObject (himl->hbmImage);
        himl->hbmImage = hbmNewImage;
 
        if (himl->hbmMask) {
 
            imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
            hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
            SelectObject (himl->hdcMask, hbmNewMask);
            DeleteObject (himl->hbmMask);
            himl->hbmMask = hbmNewMask;
        }
    }
    else {
        /* delete one image */
        TRACE("Remove single image! %d\n", i);
 
        /* create new bitmap(s) */
        TRACE(" - Number of images: %d / %d (Old/New)\n",
                 himl->cCurImage, himl->cCurImage - 1);
 
        hbmNewImage = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
 
        imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz );
        if (himl->hbmMask)
            hbmNewMask = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
        else
            hbmNewMask = 0;  /* Just to keep compiler happy! */
 
        hdcBmp = CreateCompatibleDC (0);
 
        /* copy all images and masks prior to the "removed" image */
        if (i > 0) {
            TRACE("Pre image copy: Copy %d images\n", i);
 
            SelectObject (hdcBmp, hbmNewImage);
            imagelist_copy_images( himl, himl->hdcImage, hdcBmp, 0, i, 0 );
 
            if (himl->hbmMask) {
                SelectObject (hdcBmp, hbmNewMask);
                imagelist_copy_images( himl, himl->hdcMask, hdcBmp, 0, i, 0 );
            }
        }
 
        /* copy all images and masks behind the removed image */
        if (i < himl->cCurImage - 1) {
            TRACE("Post image copy!\n");
 
            SelectObject (hdcBmp, hbmNewImage);
            imagelist_copy_images( himl, himl->hdcImage, hdcBmp, i + 1,
                                   (himl->cCurImage - i), i );
 
            if (himl->hbmMask) {
                SelectObject (hdcBmp, hbmNewMask);
                imagelist_copy_images( himl, himl->hdcMask, hdcBmp, i + 1,
                                       (himl->cCurImage - i), i );
            }
        }
 
        DeleteDC (hdcBmp);
 
        /* delete old images and insert new ones */
        SelectObject (himl->hdcImage, hbmNewImage);
        DeleteObject (himl->hbmImage);
        himl->hbmImage = hbmNewImage;
        if (himl->hbmMask) {
            SelectObject (himl->hdcMask, hbmNewMask);
            DeleteObject (himl->hbmMask);
            himl->hbmMask = hbmNewMask;
        }
 
        himl->cCurImage--;
    }
 
    return TRUE;
}

Referenced by ApplicationPageRefreshThread(), ImageListImpl_Remove(), init_functions(), CNotifyToolbar::RemoveButton(), CTaskSwitchWnd::RemoveIcon(), SIC_IconAppend(), TAB_RemoveImage(), and TOOLBAR_ReplaceBitmap().

ImageList_Replace()

BOOL WINAPI ImageList_Replace	(	HIMAGELIST	himl,
		INT	i,
		HBITMAP	hbmImage,
		HBITMAP	hbmMask
	)

Definition at line 2703 of file imagelist.c.

{
    HDC hdcImage;
    BITMAP bmp;
    POINT pt;
 
    TRACE("%p %d %p %p\n", himl, i, hbmImage, hbmMask);
 
    if (!is_valid(himl)) {
        ERR("Invalid image list handle!\n");
        return FALSE;
    }
 
    if ((i >= himl->cMaxImage) || (i < 0)) {
        ERR("Invalid image index!\n");
        return FALSE;
    }
 
    if (!GetObjectW(hbmImage, sizeof(BITMAP), &bmp))
        return FALSE;
 
    hdcImage = CreateCompatibleDC (0);
 
    /* Replace Image */
    SelectObject (hdcImage, hbmImage);
 
    if (add_with_alpha( himl, hdcImage, i, 1, bmp.bmWidth, bmp.bmHeight, hbmImage, hbmMask ))
        goto done;
 
    imagelist_point_from_index(himl, i, &pt);
    StretchBlt (himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy,
                  hdcImage, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
 
    if (himl->hbmMask)
    {
        HDC hdcTemp;
        HBITMAP hOldBitmapTemp;
 
        hdcTemp   = CreateCompatibleDC(0);
        hOldBitmapTemp = SelectObject(hdcTemp, hbmMask);
 
        StretchBlt (himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy,
                      hdcTemp, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY);
        SelectObject(hdcTemp, hOldBitmapTemp);
        DeleteDC(hdcTemp);
 
        /* Remove the background from the image
        */
        BitBlt (himl->hdcImage, pt.x, pt.y, bmp.bmWidth, bmp.bmHeight,
                himl->hdcMask, pt.x, pt.y, 0x220326); /* NOTSRCAND */
    }
 
done:
    DeleteDC (hdcImage);
 
    return TRUE;
}

Referenced by ImageListImpl_Replace(), and init_functions().

ImageList_ReplaceIcon()

INT WINAPI ImageList_ReplaceIcon	(	HIMAGELIST	himl,
		INT	nIndex,
		HICON	hIcon
	)

Definition at line 2779 of file imagelist.c.

{
    HICON   hBestFitIcon;
    ICONINFO  ii;
    BITMAP  bmp;
    BOOL    ret;
    POINT   pt;
 
    TRACE("(%p %d %p)\n", himl, nIndex, hIcon);
 
    if (!is_valid(himl)) {
        ERR("invalid image list\n");
        return -1;
    }
    if ((nIndex >= himl->cMaxImage) || (nIndex < -1)) {
        ERR("invalid image index %d / %d\n", nIndex, himl->cMaxImage);
        return -1;
    }
 
    hBestFitIcon = CopyImage(
        hIcon, IMAGE_ICON,
        himl->cx, himl->cy,
        LR_COPYFROMRESOURCE);
    /* the above will fail if the icon wasn't loaded from a resource, so try
     * again without LR_COPYFROMRESOURCE flag */
    if (!hBestFitIcon)
        hBestFitIcon = CopyImage(
            hIcon, IMAGE_ICON,
            himl->cx, himl->cy,
            0);
    if (!hBestFitIcon)
        return -1;
 
    if (nIndex == -1) {
        if (himl->cCurImage + 1 >= himl->cMaxImage)
            IMAGELIST_InternalExpandBitmaps(himl, 1);
 
        nIndex = himl->cCurImage;
        himl->cCurImage++;
    }
 
    if (himl->has_alpha && GetIconInfo (hBestFitIcon, &ii))
    {
        HDC hdcImage = CreateCompatibleDC( 0 );
        GetObjectW (ii.hbmMask, sizeof(BITMAP), &bmp);
 
        if (!ii.hbmColor)
        {
            UINT height = bmp.bmHeight / 2;
            HDC hdcMask = CreateCompatibleDC( 0 );
            HBITMAP color = CreateBitmap( bmp.bmWidth, height, 1, 1, NULL );
            SelectObject( hdcImage, color );
            SelectObject( hdcMask, ii.hbmMask );
            BitBlt( hdcImage, 0, 0, bmp.bmWidth, height, hdcMask, 0, height, SRCCOPY );
            ret = add_with_alpha( himl, hdcImage, nIndex, 1, bmp.bmWidth, height, color, ii.hbmMask );
            DeleteDC( hdcMask );
            DeleteObject( color );
        }
        else ret = add_with_alpha( himl, hdcImage, nIndex, 1, bmp.bmWidth, bmp.bmHeight,
                                   ii.hbmColor, ii.hbmMask );
 
        DeleteDC( hdcImage );
        DeleteObject (ii.hbmMask);
        if (ii.hbmColor) DeleteObject (ii.hbmColor);
        if (ret) goto done;
    }
 
    imagelist_point_from_index(himl, nIndex, &pt);
 
    if (himl->hbmMask)
    {
        DrawIconEx( himl->hdcImage, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_IMAGE );
        PatBlt( himl->hdcMask, pt.x, pt.y, himl->cx, himl->cy, WHITENESS );
        DrawIconEx( himl->hdcMask, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_MASK );
    }
    else
    {
        COLORREF color = himl->clrBk != CLR_NONE ? himl->clrBk : comctl32_color.clrWindow;
        HBRUSH brush = CreateSolidBrush( GetNearestColor( himl->hdcImage, color ));
 
        SelectObject( himl->hdcImage, brush );
        PatBlt( himl->hdcImage, pt.x, pt.y, himl->cx, himl->cy, PATCOPY );
        SelectObject( himl->hdcImage, GetStockObject(BLACK_BRUSH) );
        DeleteObject( brush );
        DrawIconEx( himl->hdcImage, pt.x, pt.y, hBestFitIcon, himl->cx, himl->cy, 0, 0, DI_NORMAL );
    }
 
done:
    DestroyIcon(hBestFitIcon);
 
    TRACE("Insert index = %d, himl->cCurImage = %d\n", nIndex, himl->cCurImage);
    return nIndex;
}

Referenced by AddOrUpdateHwnd(), CTaskSwitchWnd::AddTaskItemButton(), DesktopPageProc(), CUIFIcon::GetImageList(), ImageList_AddIcon(), ImageListImpl_ReplaceIcon(), init_functions(), PROGRAM_AddProgram(), CNotifyToolbar::UpdateButton(), and CTaskSwitchWnd::UpdateTaskItemButton().

ImageList_SetBkColor()

COLORREF WINAPI ImageList_SetBkColor	(	HIMAGELIST	himl,
		COLORREF	clrBk
	)

Definition at line 2889 of file imagelist.c.

{
    COLORREF clrOldBk;
 
    if (!is_valid(himl))
    return CLR_NONE;
 
    clrOldBk = himl->clrBk;
    himl->clrBk = clrBk;
    return clrOldBk;
}

Referenced by cert_mgr_advanced_dlg_proc(), cert_mgr_dlg_proc(), cert_properties_general_dlg_proc(), ImageList_Read(), ImageListImpl_SetBkColor(), init_hierarchy_page(), ShellBrowser::invalidate_cache(), LISTVIEW_SetImageList(), select_cert_dlg_proc(), SetupDiGetClassImageListExW(), and ShellBrowser::ShellBrowser().

ImageList_SetColorTable()

UINT WINAPI ImageList_SetColorTable	(	HIMAGELIST	himl,
		UINT	uStartIndex,
		UINT	cEntries,
		const RGBQUAD *	prgb
	)

Definition at line 3403 of file imagelist.c.

{
#ifdef __REACTOS__
    if(!is_valid2(himl))
        return 0;
#endif
    TRACE("(%p, %d, %d, %p)\n", himl, uStartIndex, cEntries, prgb);
    himl->color_table_set = TRUE;
    return SetDIBColorTable(himl->hdcImage, uStartIndex, cEntries, prgb);
}

Referenced by ImageList_Add(), and init_functions().

ImageList_SetDragCursorImage()

BOOL WINAPI ImageList_SetDragCursorImage	(	HIMAGELIST	himlDrag,
		INT	iDrag,
		INT	dxHotspot,
		INT	dyHotspot
	)

Definition at line 2928 of file imagelist.c.

{
    HIMAGELIST himlTemp;
    BOOL visible;
 
    if (!is_valid(InternalDrag.himl) || !is_valid(himlDrag))
    return FALSE;
 
    TRACE(" dxH=%d dyH=%d nX=%d nY=%d\n",
       dxHotspot, dyHotspot, InternalDrag.dxHotspot, InternalDrag.dyHotspot);
 
    visible = InternalDrag.bShow;
 
    himlTemp = ImageList_Merge (InternalDrag.himlNoCursor, 0, himlDrag, iDrag,
                                dxHotspot, dyHotspot);
 
    if (visible) {
    /* hide the drag image */
    ImageList_DragShowNolock(FALSE);
    }
    if ((InternalDrag.himl->cx != himlTemp->cx) ||
       (InternalDrag.himl->cy != himlTemp->cy)) {
    /* the size of the drag image changed, invalidate the buffer */
    DeleteObject(InternalDrag.hbmBg);
    InternalDrag.hbmBg = 0;
    }
 
    if (InternalDrag.himl != InternalDrag.himlNoCursor)
        ImageList_Destroy (InternalDrag.himl);
    InternalDrag.himl = himlTemp;
 
    if (visible) {
    /* show the drag image */
    ImageList_DragShowNolock(TRUE);
    }
 
    return TRUE;
}

Referenced by ImageListImpl_SetDragCursorImage(), and init_functions().

ImageList_SetFilter()

BOOL WINAPI ImageList_SetFilter	(	HIMAGELIST	himl,
		INT	i,
		DWORD	dwFilter
	)

Definition at line 2990 of file imagelist.c.

{
    FIXME("(%p 0x%x 0x%x):empty stub!\n", himl, i, dwFilter);
 
    return FALSE;
}

ImageList_SetFlags()

DWORD WINAPI ImageList_SetFlags	(	HIMAGELIST	himl,
		DWORD	flags
	)

Definition at line 3015 of file imagelist.c.

{
    FIXME("(%p %08x):empty stub\n", himl, flags);
    return 0;
}

ImageList_SetIconSize()

BOOL WINAPI ImageList_SetIconSize	(	HIMAGELIST	himl,
		INT	cx,
		INT	cy
	)

Definition at line 3038 of file imagelist.c.

{
    INT nCount;
    HBITMAP hbmNew;
 
    if (!is_valid(himl))
    return FALSE;
 
    /* remove all images */
    himl->cMaxImage = himl->cInitial + 1;
    himl->cCurImage = 0;
    himl->cx        = cx;
    himl->cy        = cy;
 
    /* initialize overlay mask indices */
    for (nCount = 0; nCount < MAX_OVERLAYIMAGE; nCount++)
        himl->nOvlIdx[nCount] = -1;
 
    hbmNew = ImageList_CreateImage(himl->hdcImage, himl, himl->cMaxImage);
    SelectObject (himl->hdcImage, hbmNew);
    DeleteObject (himl->hbmImage);
    himl->hbmImage = hbmNew;
 
    if (himl->hbmMask) {
        SIZE sz;
        imagelist_get_bitmap_size(himl, himl->cMaxImage, &sz);
        hbmNew = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
        SelectObject (himl->hdcMask, hbmNew);
        DeleteObject (himl->hbmMask);
        himl->hbmMask = hbmNew;
    }
 
    return TRUE;
}

Referenced by ImageListImpl_SetIconSize(), TOOLBAR_SetBitmapSize(), and CTaskSwitchWnd::UpdateButtonsSize().

ImageList_SetImageCount()

BOOL WINAPI ImageList_SetImageCount	(	HIMAGELIST	himl,
		UINT	iImageCount
	)

Definition at line 3089 of file imagelist.c.

{
    HDC     hdcBitmap;
    HBITMAP hbmNewBitmap, hbmOld;
    INT     nNewCount, nCopyCount;
 
    TRACE("%p %d\n",himl,iImageCount);
 
    if (!is_valid(himl))
    return FALSE;
 
    nNewCount = iImageCount + 1;
    nCopyCount = min(himl->cCurImage, iImageCount);
 
    hdcBitmap = CreateCompatibleDC (0);
 
    hbmNewBitmap = ImageList_CreateImage(hdcBitmap, himl, nNewCount);
 
    if (hbmNewBitmap != 0)
    {
        hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
        imagelist_copy_images( himl, himl->hdcImage, hdcBitmap, 0, nCopyCount, 0 );
        SelectObject (hdcBitmap, hbmOld);
 
    /* FIXME: delete 'empty' image space? */
 
        SelectObject (himl->hdcImage, hbmNewBitmap);
    DeleteObject (himl->hbmImage);
    himl->hbmImage = hbmNewBitmap;
    }
    else
    ERR("Could not create new image bitmap!\n");
 
    if (himl->hbmMask)
    {
        SIZE sz;
        imagelist_get_bitmap_size( himl, nNewCount, &sz );
        hbmNewBitmap = CreateBitmap (sz.cx, sz.cy, 1, 1, NULL);
        if (hbmNewBitmap != 0)
        {
            hbmOld = SelectObject (hdcBitmap, hbmNewBitmap);
            imagelist_copy_images( himl, himl->hdcMask, hdcBitmap, 0, nCopyCount, 0 );
            SelectObject (hdcBitmap, hbmOld);
 
        /* FIXME: delete 'empty' image space? */
 
            SelectObject (himl->hdcMask, hbmNewBitmap);
            DeleteObject (himl->hbmMask);
            himl->hbmMask = hbmNewBitmap;
        }
        else
            ERR("Could not create new mask bitmap!\n");
    }
 
    DeleteDC (hdcBitmap);
 
    if (himl->has_alpha)
    {
        char *new_alpha = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, himl->has_alpha, nNewCount );
        if (new_alpha) himl->has_alpha = new_alpha;
        else
        {
            heap_free( himl->has_alpha );
            himl->has_alpha = NULL;
        }
    }
 
    /* Update max image count and current image count */
    himl->cMaxImage = nNewCount;
    himl->cCurImage = iImageCount;
 
    return TRUE;
}

Referenced by ImageListImpl_SetImageCount(), init_functions(), and TOOLBAR_AddBitmapToImageList().

ImageList_SetOverlayImage()

BOOL WINAPI ImageList_SetOverlayImage	(	HIMAGELIST	himl,
		INT	iImage,
		INT	iOverlay
	)

Definition at line 3180 of file imagelist.c.

{
    if (!is_valid(himl))
    return FALSE;
    if ((iOverlay < 1) || (iOverlay > MAX_OVERLAYIMAGE))
    return FALSE;
    if ((iImage!=-1) && ((iImage < 0) || (iImage > himl->cCurImage)))
    return FALSE;
    himl->nOvlIdx[iOverlay - 1] = iImage;
    return TRUE;
}

Referenced by ImageList_Read(), ImageListImpl_SetOverlayImage(), and SetupDiGetClassImageListExW().

ImageList_Write()

BOOL WINAPI ImageList_Write	(	HIMAGELIST	himl,
		IStream *	pstm
	)

Definition at line 3283 of file imagelist.c.

{
    ILHEAD ilHead;
    int i;
 
    TRACE("%p %p\n", himl, pstm);
 
    if (!is_valid(himl))
    return FALSE;
 
    ilHead.usMagic   = (('L' << 8) | 'I');
    ilHead.usVersion = 0x101;
    ilHead.cCurImage = himl->cCurImage;
    ilHead.cMaxImage = himl->cMaxImage;
    ilHead.cGrow     = himl->cGrow;
    ilHead.cx        = himl->cx;
    ilHead.cy        = himl->cy;
    ilHead.bkcolor   = himl->clrBk;
    ilHead.flags     = himl->flags;
    for(i = 0; i < 4; i++) {
    ilHead.ovls[i] = himl->nOvlIdx[i];
    }
 
    TRACE("cx %u, cy %u, flags 0x04%x, cCurImage %u, cMaxImage %u\n",
          ilHead.cx, ilHead.cy, ilHead.flags, ilHead.cCurImage, ilHead.cMaxImage);
 
    if(FAILED(IStream_Write(pstm, &ilHead, sizeof(ILHEAD), NULL)))
    return FALSE;
 
    /* write the bitmap */
    if(!_write_bitmap(himl->hbmImage, pstm))
    return FALSE;
 
    /* write the mask if we have one */
    if(himl->flags & ILC_MASK) {
    if(!_write_bitmap(himl->hbmMask, pstm))
        return FALSE;
    }
 
    return TRUE;
}

Referenced by init_functions().

ImageListImpl_Add()

static HRESULT WINAPI ImageListImpl_Add ( IImageList2 *  iface, HBITMAP  hbmImage, HBITMAP  hbmMask, int *  pi  )

static

Definition at line 3511 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    int ret;
 
    if (!pi)
        return E_FAIL;
 
    ret = ImageList_Add(imgl, hbmImage, hbmMask);
 
    if (ret == -1)
        return E_FAIL;
 
    *pi = ret;
    return S_OK;
}

ImageListImpl_AddMasked()

static HRESULT WINAPI ImageListImpl_AddMasked ( IImageList2 *  iface, HBITMAP  hbmImage, COLORREF  crMask, int *  pi  )

static

Definition at line 3561 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    int ret;
 
    if (!pi)
        return E_FAIL;
 
    ret = ImageList_AddMasked(imgl, hbmImage, crMask);
 
    if (ret == -1)
        return E_FAIL;
 
    *pi = ret;
    return S_OK;
}

ImageListImpl_AddRef()

static ULONG WINAPI ImageListImpl_AddRef ( IImageList2 *  iface )

static

Definition at line 3470 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    ULONG ref = InterlockedIncrement(&imgl->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
    return ref;
}

ImageListImpl_BeginDrag()

static HRESULT WINAPI ImageListImpl_BeginDrag ( IImageList2 *  iface, int  iTrack, int  dxHotspot, int  dyHotspot  )

static

Definition at line 3771 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    return ImageList_BeginDrag(imgl, iTrack, dxHotspot, dyHotspot) ? S_OK : E_FAIL;
}

ImageListImpl_Clone()

static HRESULT WINAPI ImageListImpl_Clone ( IImageList2 *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 3692 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    HIMAGELIST clone;
    HRESULT ret = E_FAIL;
 
    TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 
    clone = ImageList_Duplicate(imgl);
 
    /* Get the interface for the new image list */
    if (clone)
    {
        ret = HIMAGELIST_QueryInterface(clone, riid, ppv);
        ImageList_Destroy(clone);
    }
 
    return ret;
}

ImageListImpl_Copy()

static HRESULT WINAPI ImageListImpl_Copy ( IImageList2 *  iface, int  dst_index, IUnknown *  unk_src, int  src_index, UINT  flags  )

static

Definition at line 3628 of file imagelist.c.

{
    HIMAGELIST imgl = impl_from_IImageList2(iface);
    IImageList *src = NULL;
    HRESULT ret;
 
    if (!unk_src)
        return E_FAIL;
 
#ifdef __REACTOS__
    /* Make sure that the second image list uses the same implementation with the first */
    if (!is_valid2((HIMAGELIST)unk_src))
        return E_FAIL;
#endif
 
    /* TODO: Add test for IID_ImageList2 too */
    if (FAILED(IUnknown_QueryInterface(unk_src, &IID_IImageList,
            (void **) &src)))
        return E_FAIL;
 
    if (ImageList_Copy(imgl, dst_index, (HIMAGELIST) src, src_index, flags))
        ret = S_OK;
    else
        ret = E_FAIL;
 
    IImageList_Release(src);
    return ret;
}

ImageListImpl_CreateInstance()

static HRESULT ImageListImpl_CreateInstance ( const IUnknown *  pUnkOuter, REFIID  iid, void **  ppv  )

static

Definition at line 4044 of file imagelist.c.

{
    HIMAGELIST This;
    HRESULT ret;
 
    TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
 
    *ppv = NULL;
 
    if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 
    This = heap_alloc_zero(sizeof(struct _IMAGELIST));
    if (!This) return E_OUTOFMEMORY;
 
    This->IImageList2_iface.lpVtbl = &ImageListImpl_Vtbl;
#ifdef __REACTOS__
    This->usMagic = IMAGELIST_MAGIC;
#endif
    This->ref = 1;
 
    ret = IImageList2_QueryInterface(&This->IImageList2_iface, iid, ppv);
    IImageList2_Release(&This->IImageList2_iface);
 
    return ret;
}

Referenced by ImageList_CoCreateInstance(), and ImageList_Create().

ImageListImpl_DiscardImages()

static HRESULT WINAPI ImageListImpl_DiscardImages ( IImageList2 *  iface, INT  first_image, INT  last_image, DWORD  flags  )

static

Definition at line 3914 of file imagelist.c.

{
    FIXME("(%p)->(%d %d %x): stub\n", iface, first_image, last_image, flags);
    return E_NOTIMPL;
}

ImageListImpl_DragEnter()

static HRESULT WINAPI ImageListImpl_DragEnter ( IImageList2 *  iface, HWND  hwndLock, int  x, int  y  )

static

Definition at line 3784 of file imagelist.c.

{
    return <