Initial revision

FossilOrigin-Name: 2bf55ca9aa942b581137b9f474da5ad9c1480de4

1 files changed, 397 insertions, 0 deletions

diff --git a/generic/tkColor.c b/generic/tkColor.c
new file mode 100644
index 0000000..781971c
--- /dev/null
+++ b/generic/tkColor.c
@@ -0,0 +1,397 @@
+/* 
+ * 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-1995 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) tkColor.c 1.44 96/11/04 13:55:25
+ */
+
+#include <tkColor.h>
+
+/*
+ * A two-level data structure is used to manage the color database.
+ * The top level consists of one entry for each color name that is
+ * currently active, and the bottom level contains one entry for each
+ * pixel value that is still in use.  The distinction between
+ * levels is necessary because the same pixel may have several
+ * different names.  There are two hash tables, one used to index into
+ * each of the data structures.  The name hash table is used when
+ * allocating colors, and the pixel hash table is used when freeing
+ * colors.
+ */
+
+
+/*
+ * Hash table for name -> TkColor mapping, and key structure used to
+ * index into that table:
+ */
+
+static Tcl_HashTable nameTable;
+typedef struct {
+    Tk_Uid name;		/* Name of desired color. */
+    Colormap colormap;		/* Colormap from which color will be
+				 * allocated. */
+    Display *display;		/* Display for colormap. */
+} NameKey;
+
+/*
+ * Hash table for value -> TkColor mapping, and key structure used to
+ * index into that table:
+ */
+
+static Tcl_HashTable valueTable;
+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;
+
+static int initialized = 0;	/* 0 means static structures haven't been
+				 * initialized yet. */
+
+/*
+ * Forward declarations for procedures defined in this file:
+ */
+
+static void		ColorInit _ANSI_ARGS_((void));
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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 interp->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 allocated (in form
+				 * suitable for passing to XParseColor). */
+{
+    NameKey nameKey;
+    Tcl_HashEntry *nameHashPtr;
+    int new;
+    TkColor *tkColPtr;
+    Display *display = Tk_Display(tkwin);
+
+    if (!initialized) {
+	ColorInit();
+    }
+
+    /*
+     * First, check to see if there's already a mapping for this color
+     * name.
+     */
+
+    nameKey.name = name;
+    nameKey.colormap = Tk_Colormap(tkwin);
+    nameKey.display = display;
+    nameHashPtr = Tcl_CreateHashEntry(&nameTable, (char *) &nameKey, &new);
+    if (!new) {
+	tkColPtr = (TkColor *) Tcl_GetHashValue(nameHashPtr);
+	tkColPtr->refCount++;
+	return &tkColPtr->color;
+    }
+
+    /*
+     * 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);
+	    }
+	}
+	Tcl_DeleteHashEntry(nameHashPtr);
+	return (XColor *) NULL;
+    }
+
+    /*
+     * Now create a new TkColor structure and add it to nameTable.
+     */
+
+    tkColPtr->magic = COLOR_MAGIC;
+    tkColPtr->gc = None;
+    tkColPtr->screen = Tk_Screen(tkwin);
+    tkColPtr->colormap = nameKey.colormap;
+    tkColPtr->visual  = Tk_Visual(tkwin);
+    tkColPtr->refCount = 1;
+    tkColPtr->tablePtr = &nameTable;
+    tkColPtr->hashPtr = nameHashPtr;
+    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);
+
+    if (!initialized) {
+	ColorInit();
+    }
+
+    /*
+     * 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(&valueTable, (char *) &valueKey, &new);
+    if (!new) {
+	tkColPtr = (TkColor *) Tcl_GetHashValue(valueHashPtr);
+	tkColPtr->refCount++;
+	return &tkColPtr->color;
+    }
+
+    /*
+     * The name isn't currently known.  Find a pixel value for this
+     * color and add a new structure to valueTable.
+     */
+
+    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->refCount = 1;
+    tkColPtr->tablePtr = &valueTable;
+    tkColPtr->hashPtr = valueHashPtr;
+    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.
+ *
+ *--------------------------------------------------------------
+ */
+
+char *
+Tk_NameOfColor(colorPtr)
+    XColor *colorPtr;		/* Color whose name is desired. */
+{
+    register TkColor *tkColPtr = (TkColor *) colorPtr;
+    static char string[20];
+
+    if ((tkColPtr->magic == COLOR_MAGIC)
+	    && (tkColPtr->tablePtr == &nameTable)) {
+	return ((NameKey *) tkColPtr->hashPtr->key.words)->name;
+    }
+    sprintf(string, "#%04x%04x%04x", colorPtr->red, colorPtr->green,
+	    colorPtr->blue);
+    return string;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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 or
+				 * Tk_GetColorByName. */
+    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. */
+{
+    register TkColor *tkColPtr = (TkColor *) colorPtr;
+    Screen *screen = tkColPtr->screen;
+
+    /*
+     * 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->refCount--;
+    if (tkColPtr->refCount == 0) {
+	if (tkColPtr->gc != None) {
+	    XFreeGC(DisplayOfScreen(screen), tkColPtr->gc);
+	    tkColPtr->gc = None;
+	}
+	TkpFreeColor(tkColPtr);
+	Tcl_DeleteHashEntry(tkColPtr->hashPtr);
+	tkColPtr->magic = 0;
+	ckfree((char *) tkColPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ColorInit --
+ *
+ *	Initialize the structure used for color management.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Read the code.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ColorInit()
+{
+    initialized = 1;
+    Tcl_InitHashTable(&nameTable, sizeof(NameKey)/sizeof(int));
+    Tcl_InitHashTable(&valueTable, sizeof(ValueKey)/sizeof(int));
+}