/* 
 * tkWinColor.c --
 *
 *	Functions to map color names to system color values.
 *
 * Copyright (c) 1995 Sun Microsystems, Inc.
 * Copyright (c) 1994 Software Research Associates, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * SCCS: @(#) tkWinColor.c 1.12 96/07/30 18:52:26
 */

#include "tkWinInt.h"
#include "xcolors.h"

/*
 * This variable indicates whether the color table has been initialized.
 */

static int initialized = 0;

/*
 * colorTable is a hash table used to look up X colors by name.
 */

static Tcl_HashTable colorTable;

/*
 * The SystemColorEntries array contains the names and index values for the
 * Windows indirect system color names.
 */

typedef struct {
    char *name;
    int index;
} SystemColorEntry;

static SystemColorEntry sysColorEntries[] = {
    "SystemActiveBorder",		COLOR_ACTIVEBORDER,
    "SystemActiveCaption",		COLOR_ACTIVECAPTION,
    "SystemAppWorkspace",		COLOR_APPWORKSPACE,
    "SystemBackground",			COLOR_BACKGROUND,
    "SystemButtonFace",			COLOR_BTNFACE,
    "SystemButtonHighlight",		COLOR_BTNHIGHLIGHT,
    "SystemButtonShadow",		COLOR_BTNSHADOW,
    "SystemButtonText",			COLOR_BTNTEXT,
    "SystemCaptionText",		COLOR_CAPTIONTEXT,
    "SystemDisabledText",		COLOR_GRAYTEXT,
    "SystemHighlight",			COLOR_HIGHLIGHT,
    "SystemHighlightText",		COLOR_HIGHLIGHTTEXT,
    "SystemInactiveBorder",		COLOR_INACTIVEBORDER,
    "SystemInactiveCaption",		COLOR_INACTIVECAPTION,
    "SystemInactiveCaptionText",	COLOR_INACTIVECAPTIONTEXT,
    "SystemMenu",			COLOR_MENU,
    "SystemMenuText",			COLOR_MENUTEXT,
    "SystemScrollbar",			COLOR_SCROLLBAR,
    "SystemWindow",			COLOR_WINDOW,
    "SystemWindowFrame",		COLOR_WINDOWFRAME,
    "SystemWindowText",			COLOR_WINDOWTEXT,
    NULL,				0
};

/*
 * The sysColors array is initialized by SetSystemColors().
 */

static XColorEntry sysColors[] = {
    0, 0, 0, "SystemActiveBorder",
    0, 0, 0, "SystemActiveCaption",
    0, 0, 0, "SystemAppWorkspace",
    0, 0, 0, "SystemBackground",
    0, 0, 0, "SystemButtonFace",
    0, 0, 0, "SystemButtonHighlight",
    0, 0, 0, "SystemButtonShadow",
    0, 0, 0, "SystemButtonText",
    0, 0, 0, "SystemCaptionText",
    0, 0, 0, "SystemDisabledText",
    0, 0, 0, "SystemHighlight",
    0, 0, 0, "SystemHighlightText",
    0, 0, 0, "SystemInactiveBorder",
    0, 0, 0, "SystemInactiveCaption",
    0, 0, 0, "SystemInactiveCaptionText",
    0, 0, 0, "SystemMenu",
    0, 0, 0, "SystemMenuText",
    0, 0, 0, "SystemScrollbar",
    0, 0, 0, "SystemWindow",
    0, 0, 0, "SystemWindowFrame",
    0, 0, 0, "SystemWindowText",
    0, 0, 0, NULL
};

/*
 * Forward declarations for functions defined later in this file.
 */
static int GetColorByName _ANSI_ARGS_((char *name, XColor *color));
static int GetColorByValue _ANSI_ARGS_((char *value, XColor *color));
static void InitColorTable _ANSI_ARGS_((void));
static void SetSystemColors _ANSI_ARGS_((void));



/*
 *----------------------------------------------------------------------
 *
 * SetSystemColors --
 *
 *	Initializes the sysColors array with the current values for
 *	the system colors.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Changes the RGB values stored in the sysColors array.
 *
 *----------------------------------------------------------------------
 */

static void
SetSystemColors()
{
    SystemColorEntry *sPtr;
    XColorEntry *ePtr;
    COLORREF color;

    for (ePtr = sysColors, sPtr = sysColorEntries;
	 sPtr->name != NULL; ePtr++, sPtr++)
    {
	color = GetSysColor(sPtr->index);
	ePtr->red = GetRValue(color);
	ePtr->green = GetGValue(color);
	ePtr->blue = GetBValue(color);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * InitColorTable --
 *
 *	Initialize color name database.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Builds a hash table of color names and RGB values.
 *
 *----------------------------------------------------------------------
 */

static void
InitColorTable()
{
    XColorEntry *colorPtr;
    Tcl_HashEntry *hPtr;
    int dummy;

    Tcl_InitHashTable(&colorTable, TCL_STRING_KEYS);

    /*
     * Add X colors to table.
     */

    for (colorPtr = xColors; colorPtr->name != NULL; colorPtr++) {
        hPtr = Tcl_CreateHashEntry(&colorTable, strlwr(colorPtr->name),
		&dummy);
        Tcl_SetHashValue(hPtr, colorPtr);
    }
    
    /*
     * Add Windows indirect system colors to table.
     */

    SetSystemColors();
    for (colorPtr = sysColors; colorPtr->name != NULL; colorPtr++) {
        hPtr = Tcl_CreateHashEntry(&colorTable, strlwr(colorPtr->name),
		&dummy);
        Tcl_SetHashValue(hPtr, colorPtr);
    }

    initialized = 1;
}

/*
 *----------------------------------------------------------------------
 *
 * GetColorByName --
 *
 *	Looks for a color in the color table by name, then finds the
 *	closest available color in the palette and converts it to an
 *	XColor structure.
 *
 * Results:
 *	If it finds a match, the color is returned in the color
 *	parameter and the return value is 1.  Otherwise the return
 *	value is 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static int
GetColorByName(name, color)
    char *name;			/* An X color name, e.g. "red" */
    XColor *color;		/* The closest available color. */
{
    Tcl_HashEntry *hPtr;
    XColorEntry *colorPtr;

    if (!initialized) {
	InitColorTable();
    }

    hPtr = Tcl_FindHashEntry(&colorTable, (char *) strlwr(name));

    if (hPtr == NULL) {
	return 0;
    }

    colorPtr = (XColorEntry *) Tcl_GetHashValue(hPtr);
    color->pixel = PALETTERGB(colorPtr->red, colorPtr->green, colorPtr->blue); 
    color->red = colorPtr->red << 8;
    color->green = colorPtr->green << 8;
    color->blue = colorPtr->blue << 8;
    color->flags = DoRed|DoGreen|DoBlue;
    color->pad = 0;

    return 1;
}      

/*
 *----------------------------------------------------------------------
 *
 * GetColorByValue --
 *
 *	Parses an X RGB color string and finds the closest available
 *	color in the palette and converts it to an XColor structure.
 *	The returned color will have RGB values in the range 0 to 255.
 *
 * Results:
 *	If it finds a match, the color is returned in the color
 *	parameter and the return value is 1.  Otherwise the return
 *	value is 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static int
GetColorByValue(value, color)
    char *value;		/* a string of the form "#RGB", "#RRGGBB", */
				/* "#RRRGGGBBB", or "#RRRRGGGGBBBB" */
    XColor *color;		/* The closest available color. */
{
    char fmt[16];
    int i;

    i = strlen(value+1);
    if (i % 3) {
	return 0;
    }
    i /= 3;
    if (i == 0) {
	return 0;
    }
    sprintf(fmt, "%%%dx%%%dx%%%dx", i, i, i);
    sscanf(value+1, fmt, &color->red, &color->green, &color->blue);
    /*
     * Scale the parse values into 8 bits.
     */
    if (i == 1) {
	color->red <<= 4;
	color->green <<= 4;
	color->blue <<= 4;
    } else if (i != 2) {
	color->red >>= (4*(i-2));
	color->green >>= (4*(i-2));
	color->blue >>= (4*(i-2));
    }	
    color->pad = 0;
    color->pixel = PALETTERGB(color->red, color->green, color->blue); 
    color->red = GetRValue(color->pixel) << 8;
    color->green = GetGValue(color->pixel) << 8;
    color->blue = GetBValue(color->pixel) << 8;

    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * XParseColor --
 *
 *	Decodes an X color specification.
 *
 * Results:
 *	Sets exact_def_return to the parsed color.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

int
XParseColor(display, colormap, spec, exact_def_return)
    Display* display;
    Colormap colormap;
    _Xconst char* spec;
    XColor* exact_def_return;
{
    /*
     * Note that we are violating the const-ness of spec.  This is
     * probably OK in most cases.  But this is a bug in general.
     */

    if (spec[0] == '#') {
	return GetColorByValue((char *) spec, exact_def_return);
    } else {
	return GetColorByName((char *) spec, exact_def_return);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XAllocColor --
 *
 *	Find the closest available color to the specified XColor.
 *
 * Results:
 *	Updates the color argument and returns 1 on success.  Otherwise
 *	returns 0.
 *
 * Side effects:
 *	Allocates a new color in the palette.
 *
 *----------------------------------------------------------------------
 */

int
XAllocColor(display, colormap, color)
    Display* display;
    Colormap colormap;
    XColor* color;
{
    TkWinColormap *cmap = (TkWinColormap *) colormap;
    PALETTEENTRY entry, closeEntry;
    HDC dc = GetDC(NULL);
    
    entry.peRed = (color->red) >> 8;
    entry.peGreen = (color->green) >> 8;
    entry.peBlue = (color->blue) >> 8;
    entry.peFlags = 0;

    if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE) {
	unsigned long sizePalette = GetDeviceCaps(dc, SIZEPALETTE);
	UINT newPixel, closePixel;
	int new, refCount;
	Tcl_HashEntry *entryPtr;

	/*
	 * Find the nearest existing palette entry.
	 */
	
	newPixel = RGB(entry.peRed, entry.peGreen, entry.peBlue);
	closePixel = GetNearestPaletteIndex(cmap->palette, newPixel);
	GetPaletteEntries(cmap->palette, closePixel, 1, &closeEntry);
	closePixel = RGB(closeEntry.peRed, closeEntry.peGreen,
		closeEntry.peBlue);

	/*
	 * If this is not a duplicate, allocate a new entry.
	 */
	
	if (newPixel != closePixel) {
	    /*
	     * Fails if the palette is full.
	     */

	    if (cmap->size == sizePalette) {
		return 0;
	    }
	
	    cmap->size++;
	    ResizePalette(cmap->palette, cmap->size);
	    SetPaletteEntries(cmap->palette, cmap->size - 1, 1, &entry);
	}
	color->pixel = PALETTERGB(entry.peRed, entry.peGreen, entry.peBlue);
	entryPtr = Tcl_CreateHashEntry(&cmap->refCounts,
		(char *) color->pixel, &new);
	if (new) {
	    refCount = 1;
	} else {
	    refCount = ((int) Tcl_GetHashValue(entryPtr)) + 1;
	}
	Tcl_SetHashValue(entryPtr, (ClientData)refCount);

    } else {
	
	/*
	 * Determine what color will actually be used on non-colormap systems.
	 */
	
	color->pixel = GetNearestColor(dc,
		RGB(entry.peRed, entry.peGreen, entry.peBlue));
	color->red = (GetRValue(color->pixel) << 8);
	color->green = (GetGValue(color->pixel) << 8);
	color->blue = (GetBValue(color->pixel) << 8);
    }

    ReleaseDC(NULL, dc);
    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * XAllocNamedColor --
 *
 *	Find the closest color of the given name.
 *
 * Results:
 *	Returns 1 on success with the resulting color in
 *	exact_def_return.  Returns 0 on failure.
 *
 * Side effects:
 *	Allocates a new color in the palette.
 *
 *----------------------------------------------------------------------
 */

int
XAllocNamedColor(display, colormap, color_name, screen_def_return,
	exact_def_return)
    Display* display;
    Colormap colormap;
    _Xconst char* color_name;
    XColor* screen_def_return;
    XColor* exact_def_return;
{
    int rval = GetColorByName((char *) color_name, exact_def_return);
    if (rval) {
	*screen_def_return = *exact_def_return;
	return XAllocColor(display, colormap, exact_def_return);
    } 
    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * XFreeColors --
 *
 *	Deallocate a block of colors.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes entries for the current palette and compacts the
 *	remaining set.
 *
 *----------------------------------------------------------------------
 */

void
XFreeColors(display, colormap, pixels, npixels, planes)
    Display* display;
    Colormap colormap;
    unsigned long* pixels;
    int npixels;
    unsigned long planes;
{
    TkWinColormap *cmap = (TkWinColormap *) colormap;
    COLORREF cref;
    UINT count, index, refCount;
    int i;
    PALETTEENTRY entry, *entries;
    Tcl_HashEntry *entryPtr;
    HDC dc = GetDC(NULL);

    /*
     * We don't have to do anything for non-palette devices.
     */
    
    if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE) {

	/*
	 * This is really slow for large values of npixels.
	 */

	for (i = 0; i < npixels; i++) {
	    entryPtr = Tcl_FindHashEntry(&cmap->refCounts,
		    (char *) pixels[i]);
	    if (!entryPtr) {
		panic("Tried to free a color that isn't allocated.");
	    }
	    refCount = (int) Tcl_GetHashValue(entryPtr) - 1;
	    if (refCount == 0) {
		cref = pixels[i] & 0x00ffffff;
		index = GetNearestPaletteIndex(cmap->palette, cref);
		GetPaletteEntries(cmap->palette, index, 1, &entry);
		if (cref == RGB(entry.peRed, entry.peGreen, entry.peBlue)) {
		    count = cmap->size - index;
		    entries = (PALETTEENTRY *) ckalloc(sizeof(PALETTEENTRY)
			    * count);
		    GetPaletteEntries(cmap->palette, index+1, count, entries);
		    SetPaletteEntries(cmap->palette, index, count, entries);
		    ckfree((char *) entries);
		    cmap->size--;
		} else {
		    panic("Tried to free a color that isn't allocated.");
		}
		Tcl_DeleteHashEntry(entryPtr);
	    }
	}
    }
    ReleaseDC(NULL, dc);
}

/*
 *----------------------------------------------------------------------
 *
 * XCreateColormap --
 *
 *	Allocate a new colormap.
 *
 * Results:
 *	Returns a newly allocated colormap.
 *
 * Side effects:
 *	Allocates an empty palette and color list.
 *
 *----------------------------------------------------------------------
 */

Colormap
XCreateColormap(display, w, visual, alloc)
    Display* display;
    Window w;
    Visual* visual;
    int alloc;
{
    LOGPALETTE logPalette;
    TkWinColormap *cmap = (TkWinColormap *) ckalloc(sizeof(TkWinColormap));

    logPalette.palVersion = 0x300;
    logPalette.palNumEntries = 1;
    logPalette.palPalEntry[0].peRed = 0;
    logPalette.palPalEntry[0].peGreen = 0;
    logPalette.palPalEntry[0].peBlue = 0;
    logPalette.palPalEntry[0].peFlags = 0;

    cmap->palette = CreatePalette(&logPalette);
    cmap->size = 0;
    cmap->stale = 0;
    Tcl_InitHashTable(&cmap->refCounts, TCL_ONE_WORD_KEYS);
    return (Colormap)cmap;
}

/*
 *----------------------------------------------------------------------
 *
 * XFreeColormap --
 *
 *	Frees the resources associated with the given colormap.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the palette associated with the colormap.  Note that
 *	the palette must not be selected into a device context when
 *	this occurs.
 *
 *----------------------------------------------------------------------
 */

void
XFreeColormap(display, colormap)
    Display* display;
    Colormap colormap;
{
    TkWinColormap *cmap = (TkWinColormap *) colormap;
    if (!DeleteObject(cmap->palette)) {
	panic("Unable to free colormap, palette is still selected.");
    }
    Tcl_DeleteHashTable(&cmap->refCounts);
    ckfree((char *) cmap);
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinSelectPalette --
 *
 *	This function sets up the specified device context with a
 *	given palette.  If the palette is stale, it realizes it in
 *	the background unless the palette is the current global
 *	palette.
 *
 * Results:
 *	Returns the previous palette selected into the device context.
 *
 * Side effects:
 *	May change the system palette.
 *
 *----------------------------------------------------------------------
 */

HPALETTE
TkWinSelectPalette(dc, colormap)
    HDC dc;
    Colormap colormap;
{
    TkWinColormap *cmap = (TkWinColormap *) colormap;
    HPALETTE oldPalette;

    oldPalette = SelectPalette(dc, cmap->palette,
	    (cmap->palette == TkWinGetSystemPalette()) ? FALSE : TRUE);
    RealizePalette(dc);
    return oldPalette;
}
