425 lines
13 KiB
C
425 lines
13 KiB
C
|
/*
|
|||
|
|
* tkUnixColor.c --
|
|||
|
|
*
|
|||
|
|
* This file contains the platform specific color routines
|
|||
|
|
* needed for X support.
|
|||
|
|
*
|
|||
|
|
* Copyright (c) 1996 by 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: @(#) tkUnixColor.c 1.1 96/10/22 16:52:31
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#include <tkColor.h>
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* If a colormap fills up, attempts to allocate new colors from that
|
|||
|
|
* colormap will fail. When that happens, we'll just choose the
|
|||
|
|
* closest color from those that are available in the colormap.
|
|||
|
|
* One of the following structures will be created for each "stressed"
|
|||
|
|
* colormap to keep track of the colors that are available in the
|
|||
|
|
* colormap (otherwise we would have to re-query from the server on
|
|||
|
|
* each allocation, which would be very slow). These entries are
|
|||
|
|
* flushed after a few seconds, since other clients may release or
|
|||
|
|
* reallocate colors over time.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
struct TkStressedCmap {
|
|||
|
|
Colormap colormap; /* X's token for the colormap. */
|
|||
|
|
int numColors; /* Number of entries currently active
|
|||
|
|
* at *colorPtr. */
|
|||
|
|
XColor *colorPtr; /* Pointer to malloc'ed array of all
|
|||
|
|
* colors that seem to be available in
|
|||
|
|
* the colormap. Some may not actually
|
|||
|
|
* be available, e.g. because they are
|
|||
|
|
* read-write for another client; when
|
|||
|
|
* we find this out, we remove them
|
|||
|
|
* from the array. */
|
|||
|
|
struct TkStressedCmap *nextPtr; /* Next in list of all stressed
|
|||
|
|
* colormaps for the display. */
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Forward declarations for procedures defined in this file:
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void DeleteStressedCmap _ANSI_ARGS_((Display *display,
|
|||
|
|
Colormap colormap));
|
|||
|
|
static void FindClosestColor _ANSI_ARGS_((Tk_Window tkwin,
|
|||
|
|
XColor *desiredColorPtr, XColor *actualColorPtr));
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TkpFreeColor --
|
|||
|
|
*
|
|||
|
|
* Release the specified color back to the system.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Invalidates the colormap cache for the colormap associated with
|
|||
|
|
* the given color.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
TkpFreeColor(tkColPtr)
|
|||
|
|
TkColor *tkColPtr; /* Color to be released. Must have been
|
|||
|
|
* allocated by TkpGetColor or
|
|||
|
|
* TkpGetColorByValue. */
|
|||
|
|
{
|
|||
|
|
Visual *visual;
|
|||
|
|
Screen *screen = tkColPtr->screen;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Careful! Don't free black or white, since this will
|
|||
|
|
* make some servers very unhappy. Also, there is a bug in
|
|||
|
|
* some servers (such Sun's X11/NeWS server) where reference
|
|||
|
|
* counting is performed incorrectly, so that if a color is
|
|||
|
|
* allocated twice in different places and then freed twice,
|
|||
|
|
* the second free generates an error (this bug existed as of
|
|||
|
|
* 10/1/92). To get around this problem, ignore errors that
|
|||
|
|
* occur during the free operation.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
visual = tkColPtr->visual;
|
|||
|
|
if ((visual->class != StaticGray) && (visual->class != StaticColor)
|
|||
|
|
&& (tkColPtr->color.pixel != BlackPixelOfScreen(screen))
|
|||
|
|
&& (tkColPtr->color.pixel != WhitePixelOfScreen(screen))) {
|
|||
|
|
Tk_ErrorHandler handler;
|
|||
|
|
|
|||
|
|
handler = Tk_CreateErrorHandler(DisplayOfScreen(screen),
|
|||
|
|
-1, -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
|
|||
|
|
XFreeColors(DisplayOfScreen(screen), tkColPtr->colormap,
|
|||
|
|
&tkColPtr->color.pixel, 1, 0L);
|
|||
|
|
Tk_DeleteErrorHandler(handler);
|
|||
|
|
}
|
|||
|
|
DeleteStressedCmap(DisplayOfScreen(screen), tkColPtr->colormap);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TkpGetColor --
|
|||
|
|
*
|
|||
|
|
* Allocate a new TkColor for the color with the given name.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Returns a newly allocated TkColor, or NULL on failure.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* May invalidate the colormap cache associated with tkwin upon
|
|||
|
|
* allocating a new colormap entry. Allocates a new TkColor
|
|||
|
|
* structure.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
TkColor *
|
|||
|
|
TkpGetColor(tkwin, name)
|
|||
|
|
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). */
|
|||
|
|
{
|
|||
|
|
Display *display = Tk_Display(tkwin);
|
|||
|
|
Colormap colormap = Tk_Colormap(tkwin);
|
|||
|
|
XColor color;
|
|||
|
|
TkColor *tkColPtr;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Map from the name to a pixel value. Call XAllocNamedColor rather than
|
|||
|
|
* XParseColor for non-# names: this saves a server round-trip for those
|
|||
|
|
* names.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (*name != '#') {
|
|||
|
|
XColor screen;
|
|||
|
|
|
|||
|
|
if (XAllocNamedColor(display, colormap, name, &screen,
|
|||
|
|
&color) != 0) {
|
|||
|
|
DeleteStressedCmap(display, colormap);
|
|||
|
|
} else {
|
|||
|
|
/*
|
|||
|
|
* Couldn't allocate the color. Try translating the name to
|
|||
|
|
* a color value, to see whether the problem is a bad color
|
|||
|
|
* name or a full colormap. If the colormap is full, then
|
|||
|
|
* pick an approximation to the desired color.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (XLookupColor(display, colormap, name, &color,
|
|||
|
|
&screen) == 0) {
|
|||
|
|
return (TkColor *) NULL;
|
|||
|
|
}
|
|||
|
|
FindClosestColor(tkwin, &screen, &color);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if (XParseColor(display, colormap, name, &color) == 0) {
|
|||
|
|
return (TkColor *) NULL;
|
|||
|
|
}
|
|||
|
|
if (XAllocColor(display, colormap, &color) != 0) {
|
|||
|
|
DeleteStressedCmap(display, colormap);
|
|||
|
|
} else {
|
|||
|
|
FindClosestColor(tkwin, &color, &color);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tkColPtr = (TkColor *) ckalloc(sizeof(TkColor));
|
|||
|
|
tkColPtr->color = color;
|
|||
|
|
|
|||
|
|
return tkColPtr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TkpGetColorByValue --
|
|||
|
|
*
|
|||
|
|
* 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 TkColor 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:
|
|||
|
|
* May invalidate the colormap cache for the specified window.
|
|||
|
|
* Allocates a new TkColor structure.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
TkColor *
|
|||
|
|
TkpGetColorByValue(tkwin, colorPtr)
|
|||
|
|
Tk_Window tkwin; /* Window in which color will be used. */
|
|||
|
|
XColor *colorPtr; /* Red, green, and blue fields indicate
|
|||
|
|
* desired color. */
|
|||
|
|
{
|
|||
|
|
Display *display = Tk_Display(tkwin);
|
|||
|
|
Colormap colormap = Tk_Colormap(tkwin);
|
|||
|
|
TkColor *tkColPtr = (TkColor *) ckalloc(sizeof(TkColor));
|
|||
|
|
|
|||
|
|
tkColPtr->color.red = colorPtr->red;
|
|||
|
|
tkColPtr->color.green = colorPtr->green;
|
|||
|
|
tkColPtr->color.blue = colorPtr->blue;
|
|||
|
|
if (XAllocColor(display, colormap, &tkColPtr->color) != 0) {
|
|||
|
|
DeleteStressedCmap(display, colormap);
|
|||
|
|
} else {
|
|||
|
|
FindClosestColor(tkwin, &tkColPtr->color, &tkColPtr->color);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return tkColPtr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* FindClosestColor --
|
|||
|
|
*
|
|||
|
|
* When Tk can't allocate a color because a colormap has filled
|
|||
|
|
* up, this procedure is called to find and allocate the closest
|
|||
|
|
* available color in the colormap.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* There is no return value, but *actualColorPtr is filled in
|
|||
|
|
* with information about the closest available color in tkwin's
|
|||
|
|
* colormap. This color has been allocated via X, so it must
|
|||
|
|
* be released by the caller when the caller is done with it.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* A color is allocated.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
FindClosestColor(tkwin, desiredColorPtr, actualColorPtr)
|
|||
|
|
Tk_Window tkwin; /* Window where color will be used. */
|
|||
|
|
XColor *desiredColorPtr; /* RGB values of color that was
|
|||
|
|
* wanted (but unavailable). */
|
|||
|
|
XColor *actualColorPtr; /* Structure to fill in with RGB and
|
|||
|
|
* pixel for closest available
|
|||
|
|
* color. */
|
|||
|
|
{
|
|||
|
|
TkStressedCmap *stressPtr;
|
|||
|
|
double tmp, distance, closestDistance;
|
|||
|
|
int i, closest, numFound;
|
|||
|
|
XColor *colorPtr;
|
|||
|
|
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
|
|||
|
|
Colormap colormap = Tk_Colormap(tkwin);
|
|||
|
|
XVisualInfo template, *visInfoPtr;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Find the TkStressedCmap structure for this colormap, or create
|
|||
|
|
* a new one if needed.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
for (stressPtr = dispPtr->stressPtr; ; stressPtr = stressPtr->nextPtr) {
|
|||
|
|
if (stressPtr == NULL) {
|
|||
|
|
stressPtr = (TkStressedCmap *) ckalloc(sizeof(TkStressedCmap));
|
|||
|
|
stressPtr->colormap = colormap;
|
|||
|
|
template.visualid = XVisualIDFromVisual(Tk_Visual(tkwin));
|
|||
|
|
visInfoPtr = XGetVisualInfo(Tk_Display(tkwin),
|
|||
|
|
VisualIDMask, &template, &numFound);
|
|||
|
|
if (numFound < 1) {
|
|||
|
|
panic("FindClosestColor couldn't lookup visual");
|
|||
|
|
}
|
|||
|
|
stressPtr->numColors = visInfoPtr->colormap_size;
|
|||
|
|
XFree((char *) visInfoPtr);
|
|||
|
|
stressPtr->colorPtr = (XColor *) ckalloc((unsigned)
|
|||
|
|
(stressPtr->numColors * sizeof(XColor)));
|
|||
|
|
for (i = 0; i < stressPtr->numColors; i++) {
|
|||
|
|
stressPtr->colorPtr[i].pixel = (unsigned long) i;
|
|||
|
|
}
|
|||
|
|
XQueryColors(dispPtr->display, colormap, stressPtr->colorPtr,
|
|||
|
|
stressPtr->numColors);
|
|||
|
|
stressPtr->nextPtr = dispPtr->stressPtr;
|
|||
|
|
dispPtr->stressPtr = stressPtr;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (stressPtr->colormap == colormap) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Find the color that best approximates the desired one, then
|
|||
|
|
* try to allocate that color. If that fails, it must mean that
|
|||
|
|
* the color was read-write (so we can't use it, since it's owner
|
|||
|
|
* might change it) or else it was already freed. Try again,
|
|||
|
|
* over and over again, until something succeeds.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
while (1) {
|
|||
|
|
if (stressPtr->numColors == 0) {
|
|||
|
|
panic("FindClosestColor ran out of colors");
|
|||
|
|
}
|
|||
|
|
closestDistance = 1e30;
|
|||
|
|
closest = 0;
|
|||
|
|
for (colorPtr = stressPtr->colorPtr, i = 0; i < stressPtr->numColors;
|
|||
|
|
colorPtr++, i++) {
|
|||
|
|
/*
|
|||
|
|
* Use Euclidean distance in RGB space, weighted by Y (of YIQ)
|
|||
|
|
* as the objective function; this accounts for differences
|
|||
|
|
* in the color sensitivity of the eye.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
tmp = .30*(((int) desiredColorPtr->red) - (int) colorPtr->red);
|
|||
|
|
distance = tmp*tmp;
|
|||
|
|
tmp = .61*(((int) desiredColorPtr->green) - (int) colorPtr->green);
|
|||
|
|
distance += tmp*tmp;
|
|||
|
|
tmp = .11*(((int) desiredColorPtr->blue) - (int) colorPtr->blue);
|
|||
|
|
distance += tmp*tmp;
|
|||
|
|
if (distance < closestDistance) {
|
|||
|
|
closest = i;
|
|||
|
|
closestDistance = distance;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (XAllocColor(dispPtr->display, colormap,
|
|||
|
|
&stressPtr->colorPtr[closest]) != 0) {
|
|||
|
|
*actualColorPtr = stressPtr->colorPtr[closest];
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Couldn't allocate the color. Remove it from the table and
|
|||
|
|
* go back to look for the next best color.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
stressPtr->colorPtr[closest] =
|
|||
|
|
stressPtr->colorPtr[stressPtr->numColors-1];
|
|||
|
|
stressPtr->numColors -= 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* DeleteStressedCmap --
|
|||
|
|
*
|
|||
|
|
* This procedure releases the information cached for "colormap"
|
|||
|
|
* so that it will be refetched from the X server the next time
|
|||
|
|
* it is needed.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* The TkStressedCmap structure for colormap is deleted; the
|
|||
|
|
* colormap is no longer considered to be "stressed".
|
|||
|
|
*
|
|||
|
|
* Note:
|
|||
|
|
* This procedure is invoked whenever a color in a colormap is
|
|||
|
|
* freed, and whenever a color allocation in a colormap succeeds.
|
|||
|
|
* This guarantees that TkStressedCmap structures are always
|
|||
|
|
* deleted before the corresponding Colormap is freed.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
DeleteStressedCmap(display, colormap)
|
|||
|
|
Display *display; /* Xlib's handle for the display
|
|||
|
|
* containing the colormap. */
|
|||
|
|
Colormap colormap; /* Colormap to flush. */
|
|||
|
|
{
|
|||
|
|
TkStressedCmap *prevPtr, *stressPtr;
|
|||
|
|
TkDisplay *dispPtr = TkGetDisplay(display);
|
|||
|
|
|
|||
|
|
for (prevPtr = NULL, stressPtr = dispPtr->stressPtr; stressPtr != NULL;
|
|||
|
|
prevPtr = stressPtr, stressPtr = stressPtr->nextPtr) {
|
|||
|
|
if (stressPtr->colormap == colormap) {
|
|||
|
|
if (prevPtr == NULL) {
|
|||
|
|
dispPtr->stressPtr = stressPtr->nextPtr;
|
|||
|
|
} else {
|
|||
|
|
prevPtr->nextPtr = stressPtr->nextPtr;
|
|||
|
|
}
|
|||
|
|
ckfree((char *) stressPtr->colorPtr);
|
|||
|
|
ckfree((char *) stressPtr);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TkpCmapStressed --
|
|||
|
|
*
|
|||
|
|
* Check to see whether a given colormap is known to be out
|
|||
|
|
* of entries.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* 1 is returned if "colormap" is stressed (i.e. it has run out
|
|||
|
|
* of entries recently), 0 otherwise.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
int
|
|||
|
|
TkpCmapStressed(tkwin, colormap)
|
|||
|
|
Tk_Window tkwin; /* Window that identifies the display
|
|||
|
|
* containing the colormap. */
|
|||
|
|
Colormap colormap; /* Colormap to check for stress. */
|
|||
|
|
{
|
|||
|
|
TkStressedCmap *stressPtr;
|
|||
|
|
|
|||
|
|
for (stressPtr = ((TkWindow *) tkwin)->dispPtr->stressPtr;
|
|||
|
|
stressPtr != NULL; stressPtr = stressPtr->nextPtr) {
|
|||
|
|
if (stressPtr->colormap == colormap) {
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return 0;
|
|||
|
|
}
|