/*
* tkColor.c --
*
* This file maintains a database of color values for the Tk
* toolkit, in order to avoid round-trips to the server to
* map color names to pixel values.
*
* Copyright (c) 1990-1994 The Regents of the University of California.
* Copyright (c) 1994-1997 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* RCS: @(#) $Id: tkColor.c,v 1.9 2002/08/05 04:30:38 dgp Exp $
*/
#include "tkColor.h"
/*
* Structures of the following following type are used as keys for
* colorValueTable (in TkDisplay).
*/
typedef struct {
int red, green, blue; /* Values for desired color. */
Colormap colormap; /* Colormap from which color will be
* allocated. */
Display *display; /* Display for colormap. */
} ValueKey;
/*
* The structure below is used to allocate thread-local data.
*/
typedef struct ThreadSpecificData {
char rgbString[20]; /* */
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;
/*
* Forward declarations for procedures defined in this file:
*/
static void ColorInit _ANSI_ARGS_((TkDisplay *dispPtr));
static void DupColorObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr,
Tcl_Obj *dupObjPtr));
static void FreeColorObjProc _ANSI_ARGS_((Tcl_Obj *objPtr));
static void InitColorObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
* The following structure defines the implementation of the "color" Tcl
* object, which maps a string color name to a TkColor object. The
* ptr1 field of the Tcl_Obj points to a TkColor object.
*/
Tcl_ObjType tkColorObjType = {
"color", /* name */
FreeColorObjProc, /* freeIntRepProc */
DupColorObjProc, /* dupIntRepProc */
NULL, /* updateStringProc */
NULL /* setFromAnyProc */
};
/*
*----------------------------------------------------------------------
*
* Tk_AllocColorFromObj --
*
* Given a Tcl_Obj *, map the value to a corresponding
* XColor structure based on the tkwin given.
*
* Results:
* The return value is a pointer to an XColor structure that
* indicates the red, blue, and green intensities for the color
* given by the string in objPtr, and also specifies a pixel value
* to use to draw in that color. If an error occurs, NULL is
* returned and an error message will be left in interp's result
* (unless interp is NULL).
*
* Side effects:
* The color is added to an internal database with a reference count.
* For each call to this procedure, there should eventually be a call
* to Tk_FreeColorFromObj so that the database is cleaned up when colors
* aren't in use anymore.
*
*----------------------------------------------------------------------
*/
XColor *
Tk_AllocColorFromObj(interp, tkwin, objPtr)
Tcl_Interp *interp; /* Used only for error reporting. If NULL,
* then no messages are provided. */
Tk_Window tkwin; /* Window in which the color will be used.*/
Tcl_Obj *objPtr; /* Object that describes the color; string
* value is a color name such as "red" or
* "#ff0000".*/
{
TkColor *tkColPtr;
if (objPtr->typePtr != &tkColorObjType) {
InitColorObj(objPtr);
}
tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
/*
* If the object currently points to a TkColor, see if it's the
* one we want. If so, increment its reference count and return.
*/
if (tkColPtr != NULL) {
if (tkColPtr->resourceRefCount == 0) {
/*
* This is a stale reference: it refers to a TkColor that's
* no longer in use. Clear the reference.
*/
FreeColorObjProc(objPtr);
tkColPtr = NULL;
} else if ((Tk_Screen(tkwin) == tkColPtr->screen)
&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
tkColPtr->resourceRefCount++;
return (XColor *) tkColPtr;
}
}
/*
* The object didn't point to the TkColor that we wanted. Search
* the list of TkColors with the same name to see if one of the
* other TkColors is the right one.
*/
if (tkColPtr != NULL) {
TkColor *firstColorPtr =
(TkColor *) Tcl_GetHashValue(tkColPtr->hashPtr);
FreeColorObjProc(objPtr);
for (tkColPtr = firstColorPtr; tkColPtr != NULL;
tkColPtr = tkColPtr->nextPtr) {
if ((Tk_Screen(tkwin) == tkColPtr->screen)
&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
tkColPtr->resourceRefCount++;
tkColPtr->objRefCount++;
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
return (XColor *) tkColPtr;
}
}
}
/*
* Still no luck. Call Tk_GetColor to allocate a new TkColor object.
*/
tkColPtr = (TkColor *) Tk_GetColor(interp, tkwin, Tcl_GetString(objPtr));
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
if (tkColPtr != NULL) {
tkColPtr->objRefCount++;
}
return (XColor *) tkColPtr;
}
/*
*----------------------------------------------------------------------
*
* Tk_GetColor --
*
* Given a string name for a color, map the name to a corresponding
* XColor structure.
*
* Results:
* The return value is a pointer to an XColor structure that
* indicates the red, blue, and green intensities for the color
* given by "name", and also specifies a pixel value to use to
* draw in that color. If an error occurs, NULL is returned and
* an error message will be left in the interp's result.
*
* Side effects:
* The color is added to an internal database with a reference count.
* For each call to this procedure, there should eventually be a call
* to Tk_FreeColor so that the database is cleaned up when colors
* aren't in use anymore.
*
*----------------------------------------------------------------------
*/
XColor *
Tk_GetColor(interp, tkwin, name)
Tcl_Interp *interp; /* Place to leave error message if
* color can't be found. */
Tk_Window tkwin; /* Window in which color will be used. */
Tk_Uid name; /* Name of color to be allocated (in form
* suitable for passing to XParseColor). */
{
Tcl_HashEntry *nameHashPtr;
int new;
TkColor *tkColPtr;
TkColor *existingColPtr;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (!dispPtr->colorInit) {
ColorInit(dispPtr);
}
/*
* First, check to see if there's already a mapping for this color
* name.
*/
nameHashPtr = Tcl_CreateHashEntry(&dispPtr->colorNameTable, name, &new);
if (!new) {
existingColPtr = (TkColor *) Tcl_GetHashValue(nameHashPtr);
for (tkColPtr = existingColPtr; tkColPtr != NULL;
tkColPtr = tkColPtr->nextPtr) {
if ((tkColPtr->screen == Tk_Screen(tkwin))
&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
tkColPtr->resourceRefCount++;
return &tkColPtr->color;
}
}
} else {
existingColPtr = NULL;
}
/*
* The name isn't currently known. Map from the name to a pixel
* value.
*/
tkColPtr = TkpGetColor(tkwin, name);
if (tkColPtr == NULL) {
if (interp != NULL) {
if (*name == '#') {
Tcl_AppendResult(interp, "invalid color name \"", name,
"\"", (char *) NULL);
} else {
Tcl_AppendResult(interp, "unknown color name \"", name,
"\"", (char *) NULL);
}
}
if (new) {
Tcl_DeleteHashEntry(nameHashPtr);
}
return (XColor *) NULL;
}
/*
* Now create a new TkColor structure and add it to colorNameTable
* (in TkDisplay).
*/
tkColPtr->magic = COLOR_MAGIC;
tkColPtr->gc = None;
tkColPtr->screen = Tk_Screen(tkwin);
tkColPtr->colormap = Tk_Colormap(tkwin);
tkColPtr->visual = Tk_Visual(tkwin);
tkColPtr->resourceRefCount = 1;
tkColPtr->objRefCount = 0;
tkColPtr->type = TK_COLOR_BY_NAME;
tkColPtr->hashPtr = nameHashPtr;
tkColPtr->nextPtr = existingColPtr;
Tcl_SetHashValue(nameHashPtr, tkColPtr);
return &tkColPtr->color;
}
/*
*----------------------------------------------------------------------
*
* Tk_GetColorByValue --
*
* Given a desired set of red-green-blue intensities for a color,
* locate a pixel value to use to draw that color in a given
* window.
*
* Results:
* The return value is a pointer to an XColor structure that
* indicates the closest red, blue, and green intensities available
* to those specified in colorPtr, and also specifies a pixel
* value to use to draw in that color.
*
* Side effects:
* The color is added to an internal database with a reference count.
* For each call to this procedure, there should eventually be a call
* to Tk_FreeColor, so that the database is cleaned up when colors
* aren't in use anymore.
*
*----------------------------------------------------------------------
*/
XColor *
Tk_GetColorByValue(tkwin, colorPtr)
Tk_Window tkwin; /* Window where color will be used. */
XColor *colorPtr; /* Red, green, and blue fields indicate
* desired color. */
{
ValueKey valueKey;
Tcl_HashEntry *valueHashPtr;
int new;
TkColor *tkColPtr;
Display *display = Tk_Display(tkwin);
TkDisplay *dispPtr = TkGetDisplay(display);
if (!dispPtr->colorInit) {
ColorInit(dispPtr);
}
/*
* First, check to see if there's already a mapping for this color
* name.
*/
valueKey.red = colorPtr->red;
valueKey.green = colorPtr->green;
valueKey.blue = colorPtr->blue;
valueKey.colormap = Tk_Colormap(tkwin);
valueKey.display = display;
valueHashPtr = Tcl_CreateHashEntry(&dispPtr->colorValueTable,
(char *) &valueKey, &new);
if (!new) {
tkColPtr = (TkColor *) Tcl_GetHashValue(valueHashPtr);
tkColPtr->resourceRefCount++;
return &tkColPtr->color;
}
/*
* The name isn't currently known. Find a pixel value for this
* color and add a new structure to colorValueTable (in TkDisplay).
*/
tkColPtr = TkpGetColorByValue(tkwin, colorPtr);
tkColPtr->magic = COLOR_MAGIC;
tkColPtr->gc = None;
tkColPtr->screen = Tk_Screen(tkwin);
tkColPtr->colormap = valueKey.colormap;
tkColPtr->visual = Tk_Visual(tkwin);
tkColPtr->resourceRefCount = 1;
tkColPtr->objRefCount = 0;
tkColPtr->type = TK_COLOR_BY_VALUE;
tkColPtr->hashPtr = valueHashPtr;
tkColPtr->nextPtr = NULL;
Tcl_SetHashValue(valueHashPtr, tkColPtr);
return &tkColPtr->color;
}
/*
*--------------------------------------------------------------
*
* Tk_NameOfColor --
*
* Given a color, return a textual string identifying
* the color.
*
* Results:
* If colorPtr was created by Tk_GetColor, then the return
* value is the "string" that was used to create it.
* Otherwise the return value is a string that could have
* been passed to Tk_GetColor to allocate that color. The
* storage for the returned string is only guaranteed to
* persist up until the next call to this procedure.
*
* Side effects:
* None.
*
*--------------------------------------------------------------
*/
CONST char *
Tk_NameOfColor(colorPtr)
XColor *colorPtr; /* Color whose name is desired. */
{
register TkColor *tkColPtr = (TkColor *) colorPtr;
if ((tkColPtr->magic == COLOR_MAGIC) &&
(tkColPtr->type == TK_COLOR_BY_NAME)) {
return tkColPtr->hashPtr->key.string;
} else {
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
sprintf(tsdPtr->rgbString, "#%04x%04x%04x", colorPtr->red,
colorPtr->green, colorPtr->blue);
return tsdPtr->rgbString;
}
}
/*
*----------------------------------------------------------------------
*
* Tk_GCForColor --
*
* Given a color allocated from this module, this procedure
* returns a GC that can be used for simple drawing with that
* color.
*
* Results:
* The return value is a GC with color set as its foreground
* color and all other fields defaulted. This GC is only valid
* as long as the color exists; it is freed automatically when
* the last reference to the color is freed.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
GC
Tk_GCForColor(colorPtr, drawable)
XColor *colorPtr; /* Color for which a GC is desired. Must
* have been allocated by Tk_GetColor. */
Drawable drawable; /* Drawable in which the color will be
* used (must have same screen and depth
* as the one for which the color was
* allocated). */
{
TkColor *tkColPtr = (TkColor *) colorPtr;
XGCValues gcValues;
/*
* Do a quick sanity check to make sure this color was really
* allocated by Tk_GetColor.
*/
if (tkColPtr->magic != COLOR_MAGIC) {
panic("Tk_GCForColor called with bogus color");
}
if (tkColPtr->gc == None) {
gcValues.foreground = tkColPtr->color.pixel;
tkColPtr->gc = XCreateGC(DisplayOfScreen(tkColPtr->screen),
drawable, GCForeground, &gcValues);
}
return tkColPtr->gc;
}
/*
*----------------------------------------------------------------------
*
* Tk_FreeColor --
*
* This procedure is called to release a color allocated by
* Tk_GetColor.
*
* Results:
* None.
*
* Side effects:
* The reference count associated with colorPtr is deleted, and
* the color is released to X if there are no remaining uses
* for it.
*
*----------------------------------------------------------------------
*/
void
Tk_FreeColor(colorPtr)
XColor *colorPtr; /* Color to be released. Must have been
* allocated by Tk_GetColor or
* Tk_GetColorByValue. */
{
TkColor *tkColPtr = (TkColor *) colorPtr;
Screen *screen = tkColPtr->screen;
TkColor *prevPtr;
/*
* Do a quick sanity check to make sure this color was really
* allocated by Tk_GetColor.
*/
if (tkColPtr->magic != COLOR_MAGIC) {
panic("Tk_FreeColor called with bogus color");
}
tkColPtr->resourceRefCount--;
if (tkColPtr->resourceRefCount > 0) {
return;
}
/*
* This color is no longer being actively used, so free the color
* resources associated with it and remove it from the hash table.
* no longer any objects referencing it.
*/
if (tkColPtr->gc != None) {
XFreeGC(DisplayOfScreen(screen), tkColPtr->gc);
tkColPtr->gc = None;
}
TkpFreeColor(tkColPtr);
prevPtr = (TkColor *) Tcl_GetHashValue(tkColPtr->hashPtr);
if (prevPtr == tkColPtr) {
if (tkColPtr->nextPtr == NULL) {
Tcl_DeleteHashEntry(tkColPtr->hashPtr);
} else {
Tcl_SetHashValue(tkColPtr->hashPtr, tkColPtr->nextPtr);
}
} else {
while (prevPtr->nextPtr != tkColPtr) {
prevPtr = prevPtr->nextPtr;
}
prevPtr->nextPtr = tkColPtr->nextPtr;
}
/*
* Free the TkColor structure if there are no objects referencing
* it. However, if there are objects referencing it then keep the
* structure around; it will get freed when the last reference is
* cleared
*/
if (tkColPtr->objRefCount == 0) {
ckfree((char *) tkColPtr);
}
}
/*
*----------------------------------------------------------------------
*
* Tk_FreeColorFromObj --
*
* This procedure is called to release a color allocated by
* Tk_AllocColorFromObj. It does not throw away the Tcl_Obj *;
* it only gets rid of the hash table entry for this color
* and clears the cached value that is normally stored in the object.
*
* Results:
* None.
*
* Side effects:
* The reference count associated with the color represented by
* objPtr is decremented, and the color is released to X if there are
* no remaining uses for it.
*
*----------------------------------------------------------------------
*/
void
Tk_FreeColorFromObj(tkwin, objPtr)
Tk_Window tkwin; /* The window this color lives in. Needed
* for the screen and colormap values. */
Tcl_Obj *objPtr; /* The Tcl_Obj * to be freed. */
{
Tk_FreeColor(Tk_GetColorFromObj(tkwin, objPtr));
FreeColorObjProc(objPtr);
}
/*
*---------------------------------------------------------------------------
*
* FreeColorObjProc --
*
* This proc is called to release an object reference to a color.
* Called when the object's internal rep is released or when
* the cached tkColPtr needs to be changed.
*
* Results:
* None.
*
* Side effects:
* The object reference count is decremented. When both it
* and the hash ref count go to zero, the color's resources
* are released.
*
*---------------------------------------------------------------------------
*/
static void
FreeColorObjProc(objPtr)
Tcl_Obj *objPtr; /* The object we are releasing. */
{
TkColor *tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
if (tkColPtr != NULL) {
tkColPtr->objRefCount--;
if ((tkColPtr->objRefCount == 0)
&& (tkColPtr->resourceRefCount == 0)) {
ckfree((char *) tkColPtr);
}
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
}
}
/*
*---------------------------------------------------------------------------
*
* DupColorObjProc --
*
* When a cached color object is duplicated, this is called to
* update the internal reps.
*
* Results:
* None.
*
* Side effects:
* The color's objRefCount is incremented and the internal rep
* of the copy is set to point to it.
*
*---------------------------------------------------------------------------
*/
static void
DupColorObjProc(srcObjPtr, dupObjPtr)
Tcl_Obj *srcObjPtr; /* The object we are copying from. */
Tcl_Obj *dupObjPtr; /* The object we are copying to. */
{
TkColor *tkColPtr = (TkColor *) srcObjPtr->internalRep.twoPtrValue.ptr1;
dupObjPtr->typePtr = srcObjPtr->typePtr;
dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
if (tkColPtr != NULL) {
tkColPtr->objRefCount++;
}
}
/*
*----------------------------------------------------------------------
*
* Tk_GetColorFromObj --
*
* Returns the color referred to by a Tcl object. The color must
* already have been allocated via a call to Tk_AllocColorFromObj
* or Tk_GetColor.
*
* Results:
* Returns the XColor * that matches the tkwin and the string rep
* of objPtr.
*
* Side effects:
* If the object is not already a color, the conversion will free
* any old internal representation.
*
*----------------------------------------------------------------------
*/
XColor *
Tk_GetColorFromObj(tkwin, objPtr)
Tk_Window tkwin; /* The window in which the color will be
* used. */
Tcl_Obj *objPtr; /* String value contains the name of the
* desired color. */
{
TkColor *tkColPtr;
Tcl_HashEntry *hashPtr;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (objPtr->typePtr != &tkColorObjType) {
InitColorObj(objPtr);
}
/*
* First check to see if the internal representation of the object
* is defined and is a color that is valid for the current screen
* and color map. If it is, we are done.
*/
tkColPtr = (TkColor *) objPtr->internalRep.twoPtrValue.ptr1;
if ((tkColPtr != NULL)
&& (tkColPtr->resourceRefCount > 0)
&& (Tk_Screen(tkwin) == tkColPtr->screen)
&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
/*
* The object already points to the right TkColor structure.
* Just return it.
*/
return (XColor *) tkColPtr;
}
/*
* If we reach this point, it means that the TkColor structure
* that we have cached in the internal representation is not valid
* for the current screen and colormap. But there is a list of
* other TkColor structures attached to the TkDisplay. Walk this
* list looking for the right TkColor structure.
*/
hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable,
Tcl_GetString(objPtr));
if (hashPtr == NULL) {
goto error;
}
for (tkColPtr = (TkColor *) Tcl_GetHashValue(hashPtr);
(tkColPtr != NULL); tkColPtr = tkColPtr->nextPtr) {
if ((Tk_Screen(tkwin) == tkColPtr->screen)
&& (Tk_Colormap(tkwin) == tkColPtr->colormap)) {
FreeColorObjProc(objPtr);
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) tkColPtr;
tkColPtr->objRefCount++;
return (XColor *) tkColPtr;
}
}
error:
panic(" Tk_GetColorFromObj called with non-existent color!");
/*
* The following code isn't reached; it's just there to please compilers.
*/
return NULL;
}
/*
*----------------------------------------------------------------------
*
* InitColorObj --
*
* Bookeeping procedure to change an objPtr to a color type.
*
* Results:
* None.
*
* Side effects:
* The old internal rep of the object is freed. The object's
* type is set to color with a NULL TkColor pointer (the pointer
* will be set later by either Tk_AllocColorFromObj or
* Tk_GetColorFromObj).
*
*----------------------------------------------------------------------
*/
static void
InitColorObj(objPtr)
Tcl_Obj *objPtr; /* The object to convert. */
{
Tcl_ObjType *typePtr;
/*
* Free the old internalRep before setting the new one.
*/
Tcl_GetString(objPtr);
typePtr = objPtr->typePtr;
if ((typePtr != NULL) && (typePtr->freeIntRepProc != NULL)) {
(*typePtr->freeIntRepProc)(objPtr);
}
TclObjSetType(objPtr,&tkColorObjType);
objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL;
}
/*
*----------------------------------------------------------------------
*
* ColorInit --
*
* Initialize the structure used for color management.
*
* Results:
* None.
*
* Side effects:
* Read the code.
*
*----------------------------------------------------------------------
*/
static void
ColorInit(dispPtr)
TkDisplay *dispPtr;
{
if (!dispPtr->colorInit) {
dispPtr->colorInit = 1;
Tcl_InitHashTable(&dispPtr->colorNameTable, TCL_STRING_KEYS);
Tcl_InitHashTable(&dispPtr->colorValueTable,
sizeof(ValueKey)/sizeof(int));
}
}
/*
*----------------------------------------------------------------------
*
* TkDebugColor --
*
* This procedure returns debugging information about a color.
*
* Results:
* The return value is a list with one sublist for each TkColor
* corresponding to "name". Each sublist has two elements that
* contain the resourceRefCount and objRefCount fields from the
* TkColor structure.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
Tcl_Obj *
TkDebugColor(tkwin, name)
Tk_Window tkwin; /* The window in which the color will be
* used (not currently used). */
char *name; /* Name of the desired color. */
{
TkColor *tkColPtr;
Tcl_HashEntry *hashPtr;
Tcl_Obj *resultPtr, *objPtr;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
resultPtr = Tcl_NewObj();
hashPtr = Tcl_FindHashEntry(&dispPtr->colorNameTable, name);
if (hashPtr != NULL) {
tkColPtr = (TkColor *) Tcl_GetHashValue(hashPtr);
if (tkColPtr == NULL) {
panic("TkDebugColor found empty hash table entry");
}
for ( ; (tkColPtr != NULL); tkColPtr = tkColPtr->nextPtr) {
objPtr = Tcl_NewObj();
Tcl_ListObjAppendElement(NULL, objPtr,
Tcl_NewIntObj(tkColPtr->resourceRefCount));
Tcl_ListObjAppendElement(NULL, objPtr,
Tcl_NewIntObj(tkColPtr->objRefCount));
Tcl_ListObjAppendElement(NULL, resultPtr, objPtr);
}
}
return resultPtr;
}