/*
 * The Python Imaging Library
 * $Id$
 *
 * imaging display object for Windows
 *
 * history:
 * 1996-05-12 fl  Created
 * 1996-05-17 fl  Up and running
 * 1996-05-21 fl  Added palette stuff
 * 1996-05-26 fl  Added query palette and mode inquery
 * 1997-09-21 fl  Added draw primitive
 * 1998-01-20 fl  Use StretchDIBits instead of StretchBlt
 * 1998-12-30 fl  Plugged a resource leak in DeleteDIB (from Roger Burnham)
 *
 * Copyright (c) Secret Labs AB 1997-2001.
 * Copyright (c) Fredrik Lundh 1996.
 *
 * See the README file for information on usage and redistribution.
 */


#include "Imaging.h"

#ifdef _WIN32

#include "ImDib.h"


char*
ImagingGetModeDIB(int size_out[2])
{
    /* Get device characteristics */

    HDC dc;
    char* mode;

    dc = CreateCompatibleDC(NULL);

    mode = "P";
    if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) {
	mode = "RGB";
	if (GetDeviceCaps(dc, BITSPIXEL) == 1)
	    mode = "1";
    }

    if (size_out) {
	size_out[0] = GetDeviceCaps(dc, HORZRES);
	size_out[1] = GetDeviceCaps(dc, VERTRES);
    }

    DeleteDC(dc);

    return mode;
}


ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize)
{
    /* Create a Windows bitmap */

    ImagingDIB dib;
    RGBQUAD *palette;
    int i;

    /* Check mode */
    if (strcmp(mode, "1") != 0 && strcmp(mode, "L") != 0 &&
	strcmp(mode, "RGB") != 0)
	return (ImagingDIB) ImagingError_ModeError();

    /* Create DIB context and info header */
    dib = (ImagingDIB) malloc(sizeof(*dib));
    if (!dib)
	return (ImagingDIB) ImagingError_MemoryError();
    dib->info = (BITMAPINFO*) malloc(sizeof(BITMAPINFOHEADER) +
                                     256 * sizeof(RGBQUAD));
    if (!dib->info) {
        free(dib);
	return (ImagingDIB) ImagingError_MemoryError();
    }

    memset(dib->info, 0, sizeof(BITMAPINFOHEADER));
    dib->info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    dib->info->bmiHeader.biWidth = xsize;
    dib->info->bmiHeader.biHeight = ysize;
    dib->info->bmiHeader.biPlanes = 1;
    dib->info->bmiHeader.biBitCount = strlen(mode)*8;
    dib->info->bmiHeader.biCompression = BI_RGB;

    /* Create DIB */
    dib->dc = CreateCompatibleDC(NULL);
    if (!dib->dc) {
	free(dib->info);
	free(dib);
	return (ImagingDIB) ImagingError_MemoryError();
    }

    dib->bitmap = CreateDIBSection(dib->dc, dib->info, DIB_RGB_COLORS,
                                   &dib->bits, NULL, 0);
    if (!dib->bitmap) {
        free(dib->info);
	free(dib);
	return (ImagingDIB) ImagingError_MemoryError();
    }

    strcpy(dib->mode, mode);
    dib->xsize = xsize;
    dib->ysize = ysize;

    dib->pixelsize = strlen(mode);
    dib->linesize = (xsize * dib->pixelsize + 3) & -4;

    if (dib->pixelsize == 1)
	dib->pack = dib->unpack = (ImagingShuffler) memcpy;
    else {
	dib->pack = ImagingPackBGR;
	dib->unpack = ImagingPackBGR;
    }

    /* Bind the DIB to the device context */
    dib->old_bitmap = SelectObject(dib->dc, dib->bitmap);

    palette = dib->info->bmiColors;

    /* Bind a palette to it as well (only required for 8-bit DIBs) */
    if (dib->pixelsize == 1) {
	for (i = 0; i < 256; i++) {
	    palette[i].rgbRed =
	    palette[i].rgbGreen =
	    palette[i].rgbBlue = i;
	    palette[i].rgbReserved = 0;
        }
	SetDIBColorTable(dib->dc, 0, 256, palette);
    }

    /* Create an associated palette (for 8-bit displays only) */
    if (strcmp(ImagingGetModeDIB(NULL), "P") == 0) {

	char palbuf[sizeof(LOGPALETTE)+256*sizeof(PALETTEENTRY)];
	LPLOGPALETTE pal = (LPLOGPALETTE) palbuf;
	int i, r, g, b;

	/* Load system palette */
	pal->palVersion = 0x300;
	pal->palNumEntries = 256;
	GetSystemPaletteEntries(dib->dc, 0, 256, pal->palPalEntry);

	if (strcmp(mode, "L") == 0) {

	    /* Greyscale DIB.  Fill all 236 slots with a greyscale ramp
	     * (this is usually overkill on Windows since VGA only offers
	     * 6 bits greyscale resolution).  Ignore the slots already
	     * allocated by Windows */

	    i = 10;
	    for (r = 0; r < 236; r++) {
		pal->palPalEntry[i].peRed =
		pal->palPalEntry[i].peGreen =
	        pal->palPalEntry[i].peBlue = i;
		i++;
	    }

	    dib->palette = CreatePalette(pal);

	} else if (strcmp(mode, "RGB") == 0) {

#ifdef CUBE216

	    /* Colour DIB.  Create a 6x6x6 colour cube (216 entries) and
	     * add 20 extra greylevels for best result with greyscale
	     * images. */

	    i = 10;
	    for (r = 0; r < 256; r += 51)
		for (g = 0; g < 256; g += 51)
		    for (b = 0; b < 256; b += 51) {
			pal->palPalEntry[i].peRed = r;
			pal->palPalEntry[i].peGreen = g;
			pal->palPalEntry[i].peBlue = b;
			i++;
		    }
	    for (r = 1; r < 22-1; r++) {
		/* Black and white are already provided by the cube. */
		pal->palPalEntry[i].peRed =
		pal->palPalEntry[i].peGreen =
		pal->palPalEntry[i].peBlue = r * 255 / (22-1);
		i++;
	    }

#else

	    /* Colour DIB.  Alternate palette. */

	    i = 10;
	    for (r = 0; r < 256; r += 37)
		for (g = 0; g < 256; g += 32)
		    for (b = 0; b < 256; b += 64) {
			pal->palPalEntry[i].peRed = r;
			pal->palPalEntry[i].peGreen = g;
			pal->palPalEntry[i].peBlue = b;
			i++;
		    }

#endif

	    dib->palette = CreatePalette(pal);

	}

    }

    return dib;
}

void
ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4])
{
    /* Paste image data into a bitmap */

    /* FIXME: check size! */

    int y;
    for (y = 0; y < im->ysize; y++)
	dib->pack(dib->bits + dib->linesize*(dib->ysize-(xy[1]+y)-1) +
		  xy[0]*dib->pixelsize, im->image[y], im->xsize);

}

void
ImagingExposeDIB(ImagingDIB dib, void *dc)
{
    /* Copy bitmap to display */

    if (dib->palette != 0)
	SelectPalette((HDC) dc, dib->palette, FALSE);
    BitBlt((HDC) dc, 0, 0, dib->xsize, dib->ysize, dib->dc, 0, 0, SRCCOPY);
}

void
ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4])
{
    /* Copy bitmap to printer/display */

    if (GetDeviceCaps((HDC) dc, RASTERCAPS) & RC_STRETCHDIB) {
        /* stretchdib (printers) */
        StretchDIBits((HDC) dc, dst[0], dst[1], dst[2]-dst[0], dst[3]-dst[1],
                      src[0], src[1], src[2]-src[0], src[3]-src[1], dib->bits,
                      dib->info, DIB_RGB_COLORS, SRCCOPY);
    } else {
        /* stretchblt (displays) */
        if (dib->palette != 0)
            SelectPalette((HDC) dc, dib->palette, FALSE);
        StretchBlt((HDC) dc, dst[0], dst[1], dst[2]-dst[0], dst[3]-dst[1],
                   dib->dc, src[0], src[1], src[2]-src[0], src[3]-src[1],
                   SRCCOPY);
    }
}

int
ImagingQueryPaletteDIB(ImagingDIB dib, void *dc)
{
    /* Install bitmap palette */

    int n;

    if (dib->palette != 0) {

	/* Realize associated palette */
	HPALETTE now = SelectPalette((HDC) dc, dib->palette, FALSE);
	n = RealizePalette((HDC) dc);

	/* Restore palette */
	SelectPalette((HDC) dc, now, FALSE);

    } else
	n = 0;

    return n; /* number of colours that was changed */
}

void
ImagingDeleteDIB(ImagingDIB dib)
{
    /* Clean up */

    if (dib->palette)
	DeleteObject(dib->palette);
    if (dib->bitmap) {
        SelectObject(dib->dc, dib->old_bitmap);
	DeleteObject(dib->bitmap);
    }
    if (dib->dc)
	DeleteDC(dib->dc);
    free(dib->info);
}

#endif /* _WIN32 */
