Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 1602 insertions, 0 deletions

diff --git a/nx-X11/lib/dps/dpsXcmu.c b/nx-X11/lib/dps/dpsXcmu.c
new file mode 100644
index 000000000..502649d51
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXcmu.c
@@ -0,0 +1,1602 @@
+/*
+ * dpsXcmu.c -- Simple color management/allocation utility
+ *
+ * (c) Copyright 1988-1994 Adobe Systems Incorporated.
+ * All rights reserved.
+ * 
+ * Permission to use, copy, modify, distribute, and sublicense this software
+ * and its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notices appear in all copies and that
+ * both those copyright notices and this permission notice appear in
+ * supporting documentation and that the name of Adobe Systems Incorporated
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  No trademark license
+ * to use the Adobe trademarks is hereby granted.  If the Adobe trademark
+ * "Display PostScript"(tm) is used to describe this software, its
+ * functionality or for any other purpose, such use shall be limited to a
+ * statement that this software works in conjunction with the Display
+ * PostScript system.  Proper trademark attribution to reflect Adobe's
+ * ownership of the trademark shall be given whenever any such reference to
+ * the Display PostScript system is made.
+ * 
+ * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
+ * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
+ * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON- INFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL ADOBE BE LIABLE
+ * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  ADOBE WILL NOT
+ * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
+ * 
+ * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
+ * Incorporated which may be registered in certain jurisdictions
+ * 
+ * Portions Copyright 1989 by the Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided 
+ * that the above copyright notice appear in all copies and that both that 
+ * copyright notice and this permission notice appear in supporting 
+ * documentation, and that the name of M.I.T. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific, 
+ * written prior permission. M.I.T. makes no representations about the 
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Adobe Systems Incorporated and Donna Converse, MIT X Consortium
+ */
+/* $XFree86: xc/lib/dps/dpsXcmu.c,v 1.4 2000/09/26 15:56:59 tsi Exp $ */
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/Xresource.h>
+#include <X11/Xos.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <pwd.h>
+
+#include "dpsassert.h"
+#include "cslibint.h"
+
+/* Defines for standard colormap routines */
+
+#define PrivSort qsort
+#include <stddef.h>
+
+static char redsName[] = "reds";
+static char greensName[] = "greens";
+static char bluesName[] = "blues";
+static char graysName[] = "grays";
+
+/* Database containing DPS default color cube values */
+
+typedef struct _dpyRec {
+    Display *dpy;
+    XrmDatabase db;
+    Atom XA_GRAY_DEFAULT_MAP;
+    struct _dpyRec *next;
+} DpyRec;
+
+static DpyRec *dpyRec = NULL;
+static DpyRec *curDpyRec;
+static DpyRec *FindDpyRec(Display *);
+
+typedef struct {
+    unsigned long *pixels;
+    int npixels;
+} PixelRec;
+
+static Bool AllocateColor(Display *, Colormap, XColor *);
+static Bool AllocateColormap(Display *, XStandardColormap *, XVisualInfo *, int *, PixelRec *, int *, int *, unsigned long);
+static Bool CheckCube(XColor *, XColor *, XStandardColormap *);
+static Bool CubicCube(XStandardColormap *);
+static Bool GetColorCubeFromProperty(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap **, int *);
+static Bool GetGrayRampFromProperty(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap **, int *);
+Status XDPSCreateStandardColormaps(Display *, Drawable, Visual *, int, int, int, int, XStandardColormap *, XStandardColormap *, Bool);
+static Status contiguous(unsigned long *, int, int *, unsigned long, int *, int *);
+static XVisualInfo *PickCorrectVisual(Display *, XVisualInfo *, int, Colormap);
+static int FindRampSize(XColor *, XColor *);
+static long NumColors(char *, char *, char *);
+static void AllocateColorCube(Display *, XVisualInfo *, XStandardColormap *, PixelRec *);
+static void AllocateGrayRamp(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *, PixelRec *);
+static void ColorValuesFromMask(unsigned long, unsigned long *, unsigned long *);
+static void CreateDefaultsDb(Display *);
+static void DefineProperty(Display *, XStandardColormap *, XVisualInfo *, XStandardColormap *, int, Atom);
+static void FindStaticColorCube(Display *, XVisualInfo *, XStandardColormap *);
+static void FindStaticGrayRamp(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *);
+static void GetDatabaseValues(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *);
+static void GetHomeDir(char *);
+static void SetRamp(XColor *, XColor *, int, int *, unsigned long *);
+static void ShrinkMapToFit(XStandardColormap *, int *, XVisualInfo *);
+static void UseGrayCorners(XStandardColormap *, XStandardColormap *);
+static void UseGrayDiagonal(XStandardColormap *, XStandardColormap *);
+
+#define SCALE 65535
+#undef ABS
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+
+void XDPSGetDefaultColorMaps(
+    Display *dpy,
+    Screen *screen,
+    Drawable drawable,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp)
+{
+    Window root;
+    Visual *visual;
+    XStandardColormap g;
+
+    /* If there is a screen specified, use it; otherwise use the drawable */
+
+    if (screen == NULL) {
+        if (drawable == None || ScreenCount(dpy) == 1) {
+            root = DefaultRootWindow(dpy);
+            screen = DefaultScreenOfDisplay(dpy);
+        } else {
+            /* Have to get the root for this drawable */
+            int x, y;
+            int i;
+            unsigned int width, height, bwidth, depth;
+            if (!XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height,
+                              &bwidth, &depth)) root = DefaultRootWindow(dpy);
+            for (i = 0;
+                 i < ScreenCount(dpy) && root != RootWindow(dpy, i);
+                 i++) {}
+            screen = ScreenOfDisplay(dpy, i);
+        }
+    } else root = RootWindowOfScreen(screen);
+
+    if (grayRamp == NULL) grayRamp = &g;
+
+    visual = DefaultVisualOfScreen(screen);
+    grayRamp->colormap = DefaultColormapOfScreen(screen);
+    if (colorCube != NULL) colorCube->colormap = grayRamp->colormap;
+
+    (void) XDPSCreateStandardColormaps(dpy, root, visual,
+				       0, 0, 0, 0, colorCube, grayRamp, True);
+}
+
+Status XDPSCreateStandardColormaps(
+    Display *dpy,
+    Drawable drawable,
+    Visual *visual,
+    int reds, int greens, int blues, int grays,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp,
+    Bool retain)
+{
+    XVisualInfo vtemp, *vinfo;
+    int nvis;
+    XStandardColormap *propCube = NULL, *propRamp = NULL;
+    int nPropCube = 0, nPropRamp = 0;
+    Bool gotCube = False, gotRamp;
+    PixelRec pixels;
+
+    if (grayRamp == NULL) return 0;
+    if (colorCube != NULL &&
+	colorCube->colormap != grayRamp->colormap) return 0;
+
+    if (dpy == NULL || (drawable == None && visual == NULL)) return 0;
+
+    if (visual == NULL) {
+	XWindowAttributes attr;
+	if (XGetWindowAttributes(dpy, drawable, &attr) == 0) return 0;
+	visual = attr.visual;
+    }
+
+    if (grayRamp->colormap == None && drawable == None) return 0;
+
+    curDpyRec = FindDpyRec(dpy);
+    if (curDpyRec == NULL) return 0;
+
+    vtemp.visualid = XVisualIDFromVisual(visual);
+    vinfo = XGetVisualInfo(dpy, VisualIDMask, &vtemp, &nvis);
+    if (nvis == 0) return 0;
+
+    if (nvis > 1) {
+	vinfo = PickCorrectVisual(dpy, vinfo, nvis, grayRamp->colormap);
+    }
+    if (vinfo == NULL) return 0;
+
+    if (grays <= 1) grayRamp->red_max = 0;
+    else grayRamp->red_max = grays - 1;
+
+    if (colorCube != NULL) {
+	if (reds <= 1) colorCube->red_max = 0;
+	else colorCube->red_max = reds - 1;
+	if (greens <= 1) colorCube->green_max = 0;
+	else colorCube->green_max = greens - 1;
+	if (blues <= 1) colorCube->blue_max = 0;
+	else colorCube->blue_max = blues - 1;
+    }
+
+    if ((vinfo->class == StaticGray || vinfo->class == GrayScale) &&
+	colorCube != NULL) {
+	/* Can't do a color cube in a gray visual! */
+	colorCube->red_max = colorCube->green_max = colorCube->blue_max =
+	colorCube->red_mult = colorCube->green_mult = colorCube->blue_mult =
+	colorCube->base_pixel = 0;
+	colorCube = NULL;
+    }
+
+    if (retain) {
+	Display *newDpy = XOpenDisplay(XDisplayString(dpy));
+	if (newDpy == NULL) retain = False;
+	else dpy = newDpy;
+	XGrabServer(dpy);
+    }
+
+    if (grayRamp->colormap == None) {
+	grayRamp->colormap = XCreateColormap(dpy, drawable, vinfo->visual,
+					     AllocNone);
+	if (colorCube != NULL) colorCube->colormap = grayRamp->colormap;
+    }
+
+    if (colorCube != NULL) {
+	gotCube = GetColorCubeFromProperty(dpy, vinfo, colorCube,
+					   &propCube, &nPropCube);
+    }
+    gotRamp = GetGrayRampFromProperty(dpy, vinfo, grayRamp,
+				      &propRamp, &nPropRamp);
+
+    if (!gotRamp || (colorCube != NULL && !gotCube)) {
+	/* Couldn't find at least one thing we wanted, so let's look in the
+	   database */
+
+	GetDatabaseValues(dpy, vinfo, colorCube, grayRamp);
+
+	pixels.pixels = NULL;
+	pixels.npixels = 0;
+
+	if (colorCube != NULL) {
+	    if (colorCube->red_max != 0) {
+		AllocateColorCube(dpy, vinfo, colorCube, &pixels);
+	    }
+	    if (colorCube->red_max == 0) {
+		colorCube->green_max = colorCube->blue_max = 
+		colorCube->red_mult = colorCube->green_mult =
+		colorCube->blue_mult = 0;
+	    }
+	}
+
+	if (grayRamp->red_max != 0) {
+	    AllocateGrayRamp(dpy, vinfo, grayRamp, colorCube, &pixels);
+	}
+
+	if (pixels.pixels != NULL) {
+	    if (pixels.npixels != 0) {
+		XFreeColors(dpy, grayRamp->colormap,
+			    pixels.pixels, pixels.npixels, 0);
+	    }
+	    free((char *) pixels.pixels);
+	}
+
+	if (retain) {
+	    Pixmap p;
+
+	    /* Create something to put in killid field so the entries can
+	       be deleted sometime */
+	    p = XCreatePixmap(dpy, RootWindow(dpy, vinfo->screen), 1, 1, 1);
+	    if (colorCube != NULL && !gotCube && colorCube->red_max != 0) {
+		colorCube->visualid = vinfo->visualid;
+		colorCube->killid = p;
+		DefineProperty(dpy, colorCube, vinfo, propCube, nPropCube,
+			       XA_RGB_DEFAULT_MAP);
+	    }
+	    if (!gotRamp && grayRamp->red_max != 0) {
+		grayRamp->visualid = vinfo->visualid;
+		grayRamp->killid = p;
+		DefineProperty(dpy, grayRamp, vinfo, propRamp, nPropRamp,
+			       (vinfo->class == GrayScale ? XA_RGB_GRAY_MAP :
+				curDpyRec->XA_GRAY_DEFAULT_MAP));
+	    }
+	    XSetCloseDownMode(dpy, RetainTemporary);
+	}
+    }
+
+    if (grayRamp->red_max == 0) {
+	/* Use special magic values.  If this is a default colormap,
+	   the server recognizes a gray ramp with red_max=1, red_mult=1,
+	   base_pixel=0 to mean a 2 gray ramp with BlackPixel being 
+	   the lowest intensity gray and WhitePixel being the highest
+           intensity gray.  If it's not a default colormap, then the
+	   server will either generate a BadValue error, or just happily
+	   use pixel values 0 and 1; either is better than the alternative,
+	   silently converting into a null device. */
+	grayRamp->red_max = 1;
+	grayRamp->red_mult = 1;
+	grayRamp->base_pixel = 0;
+    }
+
+    if (retain) {
+	XUngrabServer(dpy);
+	XCloseDisplay(dpy);
+    }
+    if (propCube != NULL) XFree((void *) propCube);
+    if (propRamp != NULL) XFree((void *) propRamp);
+    XFree((void *) vinfo);
+    return 1;
+}
+
+static DpyRec *FindDpyRec(Display *dpy)
+{
+    DpyRec *d;
+
+    for (d = dpyRec; d != NULL; d = d->next) {
+	if (d->dpy == dpy) return d;
+    }
+  
+    d = (DpyRec *) malloc(sizeof(DpyRec));
+    if (d == NULL) return NULL;
+    d->XA_GRAY_DEFAULT_MAP = XInternAtom(dpy, "DEFAULT_GRAY", False);
+    d->db = NULL;
+    d->next = dpyRec;
+    dpyRec = d;
+    return d;
+}
+
+static XVisualInfo *PickCorrectVisual(
+    Display *dpy,
+    XVisualInfo *vlist,
+    int n,
+    Colormap cmap)
+{
+    register int i;
+    register int screen_number;
+    Bool def_cmap = False;
+
+    /* A visual id may be valid on multiple screens.  Also, there may 
+     * be multiple visuals with identical visual ids at different depths.  
+     * If the colormap is the Default Colormap, use the Default Visual.
+     * Otherwise, arbitrarily, use the deepest visual.
+     */
+
+    for (screen_number = ScreenCount(dpy); --screen_number >= 0; /**/) {
+	if (cmap == DefaultColormap(dpy, screen_number)) {
+	    def_cmap = True;
+	    break;
+	}
+    }
+
+    if (def_cmap) {
+	for (i = 0; i < n; i++, vlist++) {
+	    if (vlist->visual == DefaultVisual(dpy, screen_number)) {
+		return vlist;
+	    }
+	}
+	return NULL;	/* Visual does not match colormap */
+    } else {
+	int maxdepth = 0;
+	XVisualInfo *v = 0;
+
+	for (i = 0; i < n; i++, vlist++) {
+	    if (vlist->depth > maxdepth) {
+		maxdepth = vlist->depth;
+		v = vlist;
+	    }
+	}
+	return v;
+    }
+}
+
+/* Do some rudimentary checking of the properties to avoid obviously bad ones.
+   How did they get there, anyway? */
+
+static Bool ValidCube(
+    XStandardColormap *c,
+    XVisualInfo *vinfo)
+{
+    unsigned long max = 1 << vinfo->depth;
+    unsigned long pixel;
+
+    if (c->red_max < 1 || c->green_max < 1 || c->blue_max < 1) return False;
+    if (c->base_pixel > max) return False;
+    pixel = (c->red_max * c->red_mult + c->green_max * c->green_mult +
+	     c->blue_max * c->blue_mult + c->base_pixel) & 0xFFFFFFFF;
+    if (pixel > max) return False;
+
+    return True;
+}
+
+static Bool ValidRamp(
+    XStandardColormap *c,
+    XVisualInfo *vinfo)
+{
+    unsigned long max = 1 << vinfo->depth;
+    unsigned long pixel;
+
+    if (c->red_max < 1) return False;
+    if (c->base_pixel > max) return False;
+    pixel = (c->red_max * c->red_mult + c->base_pixel) & 0xFFFFFFFF;
+    if (pixel > max) return False;
+
+    return True;
+}
+
+static Bool GetColorCubeFromProperty(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    XStandardColormap **cube,
+    int *ncube)
+{
+    int gotCube;
+    int i;
+    register XStandardColormap *c;
+
+    gotCube = XGetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), cube,
+			       ncube, XA_RGB_DEFAULT_MAP);
+    
+    if (gotCube) {
+	/* Try to find a match with the visual */
+	c = *cube;
+	for (i = 0; i < *ncube; i++) {
+	    if (c->colormap == colorCube->colormap &&
+		c->visualid == vinfo->visualid &&
+		ValidCube(c, vinfo)) {
+		colorCube->red_max = c->red_max;
+		colorCube->red_mult = c->red_mult;
+		colorCube->green_max = c->green_max;
+		colorCube->green_mult = c->green_mult;
+		colorCube->blue_max = c->blue_max;
+		colorCube->blue_mult = c->blue_mult;
+		colorCube->base_pixel = c->base_pixel;
+		colorCube->visualid = c->visualid;
+		colorCube->killid = c->killid;
+		break;
+	    }
+	    c++;
+	}
+	if (i == *ncube) gotCube = False;
+    }
+    return gotCube;
+}
+
+static Bool GetGrayRampFromProperty(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap **ramp,
+    int *nramp)
+{
+    int gotRamp;
+    int i;
+    Atom grayAtom;
+    register XStandardColormap *c;
+
+    if (vinfo->class == GrayScale) grayAtom = XA_RGB_GRAY_MAP;
+    else grayAtom = curDpyRec->XA_GRAY_DEFAULT_MAP;
+
+    gotRamp = XGetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), ramp,
+			       nramp, grayAtom);
+    
+    if (gotRamp) {
+	/* Try to find a match with the visual */
+	c = *ramp;
+	for (i = 0; i < *nramp; i++) {
+	    if (c->colormap == grayRamp->colormap &&
+		c->visualid == vinfo->visualid &&
+		ValidRamp(c, vinfo)) {
+		grayRamp->red_max = c->red_max;
+		grayRamp->red_mult = c->red_mult;
+		grayRamp->base_pixel = c->base_pixel;
+		grayRamp->visualid = c->visualid;
+		grayRamp->killid = c->killid;
+		break;
+	    }
+	    c++;
+	}
+	if (i == *nramp) gotRamp = False;
+    }
+    return gotRamp;
+}
+
+static void GetDatabaseValues(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp)
+{
+    char *class, *depth;
+    char namePrefix[40], classPrefix[40];
+    unsigned long max;
+    XStandardColormap fakeCube;
+
+    switch (vinfo->class) {
+	default:
+        case StaticGray:  class = "StaticGray."; break;
+        case GrayScale:   class = "GrayScale."; break;
+        case StaticColor: class = "StaticColor."; break;
+        case PseudoColor: class = "PseudoColor."; break;
+        case TrueColor:   class = "TrueColor."; break;
+        case DirectColor: class = "DirectColor."; break;
+    }
+
+    if      (vinfo->depth >= 24) depth = "24.";
+    else if (vinfo->depth >= 12) depth = "12.";
+    else if (vinfo->depth >= 8) depth = "8.";
+    else if (vinfo->depth >= 4) depth = "4.";
+    else if (vinfo->depth >= 2) depth = "2.";
+    else depth = "1.";
+
+    (void) strcpy(namePrefix, "dpsColorCube.");
+    (void) strcat(strcat(namePrefix, class), depth);
+    (void) strcpy(classPrefix, "DPSColorCube.");
+    (void) strcat(strcat(classPrefix, class), depth);
+
+    CreateDefaultsDb(dpy);
+
+    if (colorCube == NULL && vinfo->class == TrueColor) {
+	/* We'll need the color cube information to compute the gray ramp,
+	   even if it wasn't asked for, so make colorCube point to a
+	   temporary structure */
+	colorCube = &fakeCube;
+    }
+
+    if (colorCube != NULL) {
+	switch (vinfo->class) {
+	    case StaticGray:
+	    case GrayScale:
+	        /* We can't do a color cube for these visuals */
+		break;
+
+	    case TrueColor:
+		/* Rewrite whatever was there before with real values */
+		ColorValuesFromMask(vinfo->red_mask, &colorCube->red_max,
+				    &colorCube->red_mult);
+		ColorValuesFromMask(vinfo->green_mask, &colorCube->green_max,
+				    &colorCube->green_mult);
+		ColorValuesFromMask(vinfo->blue_mask, &colorCube->blue_max,
+				    &colorCube->blue_mult);
+		colorCube->base_pixel = 0;
+		break;
+
+	    case DirectColor:
+		/* Get the mults from the masks; ignore maxes */
+		ColorValuesFromMask(vinfo->red_mask, &max,
+				    &colorCube->red_mult);
+		ColorValuesFromMask(vinfo->green_mask, &max,
+				    &colorCube->green_mult);
+		ColorValuesFromMask(vinfo->blue_mask, &max,
+				    &colorCube->blue_mult);
+		/* Get the maxes from the database */
+		if (colorCube->red_max == 0) {
+		    colorCube->red_max =
+			    NumColors(namePrefix, classPrefix, redsName) - 1;
+		}
+		if (colorCube->green_max == 0) {
+		    colorCube->green_max =
+			    NumColors(namePrefix, classPrefix, greensName) - 1;
+		}
+		if (colorCube->blue_max == 0) {
+		    colorCube->blue_max =
+			    NumColors(namePrefix, classPrefix, bluesName) - 1;
+		}
+		colorCube->base_pixel = 0;
+		break;
+
+	    case PseudoColor:
+		if (colorCube->red_max == 0) {
+		    colorCube->red_max =
+			    NumColors(namePrefix, classPrefix, redsName) - 1;
+		}
+		if (colorCube->green_max == 0) {
+		    colorCube->green_max =
+			    NumColors(namePrefix, classPrefix, greensName) - 1;
+		}
+		if (colorCube->blue_max == 0) {
+		    colorCube->blue_max =
+			    NumColors(namePrefix, classPrefix, bluesName) - 1;
+		}
+		colorCube->red_mult = (colorCube->green_max + 1) *
+			(colorCube->blue_max + 1);
+		colorCube->green_mult = colorCube->blue_max + 1;
+		colorCube->blue_mult = 1;
+		break;
+
+	    case StaticColor:
+		FindStaticColorCube(dpy, vinfo, colorCube);
+		break;
+	}
+    }
+
+    switch (vinfo->class) {
+	case GrayScale:
+	case PseudoColor:
+	case DirectColor:
+	    if (grayRamp->red_max == 0) {
+		grayRamp->red_max =
+			NumColors(namePrefix, classPrefix, graysName) - 1;
+	    }
+	    grayRamp->red_mult = 1;
+	    break;
+
+	case TrueColor:
+	    /* If the color cube is truly a cube, use its diagonal.  Otherwise
+	       were SOL and have to use a two-element ramp. */
+	    if (CubicCube(colorCube)) UseGrayDiagonal(colorCube, grayRamp);
+	    else UseGrayCorners(colorCube, grayRamp);
+	    break;
+
+	case StaticColor:
+	case StaticGray:
+	    FindStaticGrayRamp(dpy, vinfo, grayRamp, colorCube);
+	    break;
+    }
+}
+
+static Bool CubicCube(XStandardColormap *cube)
+{
+    return cube->red_max == cube->green_max && cube->red_max ==
+	    cube->blue_max;
+}
+
+static void UseGrayDiagonal(XStandardColormap *cube, XStandardColormap *ramp)
+{
+    ramp->red_max = cube->red_max;
+    ramp->red_mult = cube->red_mult + cube->green_mult + cube->blue_mult;
+    ramp->base_pixel = cube->base_pixel;
+}
+
+static void UseGrayCorners(XStandardColormap *cube, XStandardColormap *ramp)
+{
+    ramp->red_max = 1;
+    ramp->red_mult = (cube->red_max + 1) * (cube->green_max + 1) *
+	    (cube->blue_max + 1) - 1;
+    if (* (int *) &(cube->red_mult) < 0) ramp->red_mult *= -1;
+    ramp->base_pixel = cube->base_pixel;
+}
+
+static void ColorValuesFromMask(
+    unsigned long	mask,
+    unsigned long	*maxColor,
+    unsigned long	*mult)
+{
+    *mult = 1;
+    while ((mask & 1) == 0) {
+	*mult <<= 1;
+	mask >>= 1;
+    }
+    *maxColor = mask;
+}
+
+/* 
+Resource definitions for default color cube / gray ramp sizes
+are based on visual class and depth. Working from least choices
+to most, here's motivation for the defaults:
+
+If unspecified, default is 0 values for red, green, and blue,
+and 2 (black and white) for grays. This covers StaticGray, StaticColor,
+and depths less than 4 of the other visual classes.
+
+If we have a choice, we try to allocate a gray ramp with an odd number
+of colors; this is so 50% gray can be rendered without dithering.
+In general we don't want to allocate a large cube (even when many
+colormap entries are available) because allocation of each entry
+requires a round-trip to the server (entries allocated read-only
+via XAllocColor).
+
+For GrayScale, any depth less than 4 is treated as monochrome.
+
+PseudoColor depth 4 we try for a 2x2x2 cube with the gray ramp on
+the diagonal. Depth 8 uses a 4x4x4 cube with a separate 9 entry
+gray ramp. Depth 12 uses a 6x6x5 "cube" with a separate 17 entry gray
+ramp. The cube is non-symmetrical; we don't want to use the diagonal
+for a gray ramp and we can get by with fewer blues than reds or greens.
+
+For DirectColor, allocating a gray ramp separate from the color cube
+is wasteful of map entries, so we specify a symmetrical cube and
+share the diagonal entries for the gray ramp. 
+
+For TrueColor, # color shades is set equal to the # shades / primary;
+we don't actually allocate map entries, but it's handy to be able to
+do the resource lookup blindly and get the right value.
+*/
+
+static char dpsDefaults[] = "\
+*reds: 0\n\
+*greens: 0\n\
+*blues: 0\n\
+*grays: 2\n\
+\
+*GrayScale.4.grays: 9\n\
+*GrayScale.8.grays: 17\n\
+\
+*PseudoColor.4.reds: 2\n\
+*PseudoColor.4.greens: 2\n\
+*PseudoColor.4.blues: 2\n\
+*PseudoColor.4.grays: 2\n\
+*PseudoColor.8.reds: 4\n\
+*PseudoColor.8.greens: 4\n\
+*PseudoColor.8.blues: 4\n\
+*PseudoColor.8.grays: 9\n\
+*PseudoColor.12.reds: 6\n\
+*PseudoColor.12.greens: 6\n\
+*PseudoColor.12.blues: 5\n\
+*PseudoColor.12.grays: 17\n\
+\
+*DirectColor.8.reds: 4\n\
+*DirectColor.8.greens: 4\n\
+*DirectColor.8.blues: 4\n\
+*DirectColor.8.grays: 4\n\
+*DirectColor.12.reds: 6\n\
+*DirectColor.12.greens: 6\n\
+*DirectColor.12.blues: 6\n\
+*DirectColor.12.grays: 6\n\
+*DirectColor.24.reds: 7\n\
+*DirectColor.24.greens: 7\n\
+*DirectColor.24.blues: 7\n\
+*DirectColor.24.grays: 7\n\
+\
+*TrueColor.12.reds: 16\n\
+*TrueColor.12.greens: 16\n\
+*TrueColor.12.blues: 16\n\
+*TrueColor.12.grays: 16\n\
+*TrueColor.24.reds: 256\n\
+*TrueColor.24.greens: 256\n\
+*TrueColor.24.blues: 256\n\
+*TrueColor.24.grays: 256\n\
+";
+
+static XrmDatabase defaultDB = NULL;
+
+static void CreateDefaultsDb(Display *dpy)
+{
+    char home[256], *dpyDefaults;
+
+    if (defaultDB == NULL) defaultDB = XrmGetStringDatabase(dpsDefaults);
+
+    if (curDpyRec->db != NULL) return;
+
+    dpyDefaults = XResourceManagerString(dpy);
+    if (dpyDefaults != NULL) {
+	curDpyRec->db = XrmGetStringDatabase(dpyDefaults);
+    } 
+
+    if (curDpyRec->db == NULL) {
+	GetHomeDir(home);
+	strcpy(home, "/.Xdefaults");
+	curDpyRec->db = XrmGetFileDatabase(home);
+    }
+}
+
+static void GetHomeDir(char *buf)
+{
+#ifndef X_NOT_POSIX
+     uid_t uid;
+#else
+     int uid;
+     extern int getuid();
+#ifndef SYSV386
+     extern struct passwd *getpwuid(), *getpwnam();
+#endif
+#endif
+     struct passwd *pw;
+     static char *ptr = NULL;
+
+     if (ptr == NULL) {
+        if (!(ptr = getenv("HOME"))) {
+            if ((ptr = getenv("USER")) != 0) pw = getpwnam(ptr);
+            else {
+                uid = getuid();
+                pw = getpwuid(uid);
+            }
+            if (pw) ptr = pw->pw_dir;
+            else {
+                ptr = NULL;
+                *buf = '\0';
+            }
+        }
+     }
+
+     if (ptr)
+        (void) strcpy(buf, ptr);
+
+     buf += strlen(buf);
+     *buf = '/';
+     buf++;
+     *buf = '\0';
+     return;
+}
+
+static long NumColors(char *namePrefix, char *classPrefix, char *color)
+{
+    char name[40], class[40];
+    XrmValue rtnValue;
+    char *rtnType;
+    long value;
+
+    (void) strcpy(name, namePrefix);
+    (void) strcpy(class, classPrefix);
+    if (! XrmGetResource(curDpyRec->db, strcat(name, color), 
+			 strcat(class, color), &rtnType, &rtnValue)) {
+	if (! XrmGetResource(defaultDB, name, class, &rtnType, &rtnValue)) {
+	    /* This should never happen, as our defaults cover all cases */
+	    return 0;
+	}
+    }
+
+    /* Resource value is number of shades of specified color.  If value
+       is not an integer, atoi returns 0, so we return 0. If value
+       is less than 2, it is invalid (need at least 2 shades of a color).
+       Explicitly setting 0 is ok for colors (means to not use a color
+       cube) but merits a warning for gray. */
+
+    if (strcmp(rtnValue.addr, "0") == 0 && strcmp(color, "grays") != 0) {
+	return 0;
+    }
+
+    value = atol(rtnValue.addr);
+    if (value < 2) {
+	char mbuf[512];
+	sprintf(mbuf, "%% Value '%s' is invalid for %s resource\n",
+		rtnValue.addr, name);
+	DPSWarnProc(NULL, mbuf);
+    }
+    return value;
+}
+
+/* Query the entire colormap in the static color case, then try to find
+   a color cube.  Check pairs of black and white cells trying to find
+   a cube between them and take the first one you find. */
+
+static void FindStaticColorCube(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube)
+{
+    XColor *ramp, *black, *white, *altBlack, *altWhite;
+    int i, entries;
+
+    entries = 1 << vinfo->depth;
+    ramp = (XColor *) calloc(entries, sizeof(XColor));
+
+    if (ramp == NULL) {
+	colorCube->red_max = 0;
+	return;
+    }
+
+    /* Query the colormap */
+    for (i = 0; i < entries; i++) ramp[i].pixel = i;
+    XQueryColors(dpy, colorCube->colormap, ramp, entries);
+
+    /* Find the white and black entries */
+
+    black = white = altBlack = altWhite = NULL;
+    for (i = 0; i < entries; i++) {
+	if (ramp[i].flags != (DoRed | DoBlue | DoGreen)) continue;
+	if (ramp[i].red == 0 && ramp[i].blue == 0 &&
+	    ramp[i].green == 0) {
+	    if (black == NULL) black = ramp+i;
+	    else if (altBlack == NULL) altBlack = ramp+i;
+	} else if (ramp[i].red == SCALE && ramp[i].blue == SCALE &&
+		   ramp[i].green == SCALE) {
+	    if (white == NULL) white = ramp+i;
+	    else if (altWhite == NULL) altWhite = ramp+i;
+	}
+    }
+
+    if (black == NULL || white == NULL) {
+	colorCube->red_max = 0;
+	free(ramp);
+	return;
+    }
+
+    /* Look for cubes between pairs of black & white */
+    if (!CheckCube(black, white, colorCube) &&
+	!CheckCube(altBlack, white, colorCube) &&
+	!CheckCube(black, altWhite, colorCube) &&
+	!CheckCube(altBlack, altWhite, colorCube)) {
+	colorCube->red_max = 0;
+    }
+
+    free(ramp);
+}
+
+#define R 1
+#define G 2
+#define B 4
+#define C 8
+#define M 16
+#define Y 32
+
+#define SMALLSCALE 255
+#define CheckColor(color,r,g,b) ((((color)->red >> 8) == (r) * SMALLSCALE) && \
+	(((color)->green >> 8) == (g) * SMALLSCALE) && \
+	(((color)->blue >> 8) == (b) * SMALLSCALE))
+
+static Bool CheckCube(
+    XColor *black,
+    XColor *white,
+    XStandardColormap *cube)
+{
+    int r = 0, g = 0, b = 0, c = 0, m = 0, y = 0, k, w;
+    XColor *color;
+    unsigned int found = 0;
+    int small, middle, large;
+    int smallMult, smallMax, middleMult, middleMax, largeMult, largeMax;
+    Bool backwards = False;
+    int mult = 1;
+    XStandardColormap test;	/* Test cube */
+    int i;
+    int size;
+
+    if (black == NULL || white == NULL) return False;
+
+    k = black->pixel;
+    w = white->pixel - k;
+
+    size = ABS(w);
+    if (w < 0) {
+	backwards = True;
+	mult = -1;
+    }
+
+    for (i = 1; i < size; i++) {
+	color = black + i*mult;
+	if (color->flags != (DoRed | DoBlue | DoGreen)) return False;
+
+	/* If black or white is in the middle of the cube, can't work */
+	if (CheckColor(color, 0, 0, 0)) return False;
+	if (CheckColor(color, 1, 1, 1)) return False;
+
+	/* Check for red, green, blue, cyan, magenta, and yellow */
+	if (CheckColor(color, 1, 0, 0)) {r = color->pixel-k; found |= R;}
+	else if (CheckColor(color, 0, 1, 0)) {g = color->pixel-k; found |= G;}
+	else if (CheckColor(color, 0, 0, 1)) {b = color->pixel-k; found |= B;}
+	else if (CheckColor(color, 0, 1, 1)) {c = color->pixel-k; found |= C;}
+	else if (CheckColor(color, 1, 0, 1)) {m = color->pixel-k; found |= M;}
+	else if (CheckColor(color, 1, 1, 0)) {y = color->pixel-k; found |= Y;}
+    }
+
+    /* If any color is missing no cube is possible */
+    if (found != (R | G | B | C | M | Y)) return False;
+
+    /* Next test.  Make sure B + G = C, R + B = M, R + G = Y,
+       and R + G + B = W */
+    if (b + g != c) return False;
+    if (r + b != m) return False;
+    if (r + g != y) return False;
+    if (r + g + b != w) return False;
+
+    /* Looking good!  Compensate for backwards cubes */
+    if (backwards) {
+	w = ABS(w);
+	r = ABS(r);
+	g = ABS(g);
+	b = ABS(b);
+    }
+
+    /* Find the smallest, middle, and largest difference */
+    if (r < b && b < g) {
+	small = r; middle = b; large = g;
+    } else if (r < g && g < b) {
+	small = r; middle = g; large = b;
+    } else if (b < r && r < g) {
+	small = b; middle = r; large = g;
+    } else if (b < g && g < r) {
+	small = b; middle = g; large = r;
+    } else if (g < r && r < b) {
+	small = g; middle = r; large = b;
+    } else {
+	small = g; middle = b; large = r;
+    }
+
+    /* The smallest must divide the middle, and the middle the large */
+    if ((middle % (small + 1)) != 0) return False;
+    if ((large % (small + middle + 1)) != 0) return False;
+
+    /* OK, we believe we have a cube.  Compute the description */
+    smallMult = 1;
+    smallMax = small;
+    middleMult = small + 1;
+    middleMax = middle / middleMult;
+    largeMult = small + middle + 1;
+    largeMax = large / largeMult;
+	
+    if (small == r) {
+	test.red_max = smallMax; test.red_mult = smallMult;
+	if (middle == b) {
+	    test.blue_max = middleMax; test.blue_mult = middleMult;
+	    test.green_max = largeMax; test.green_mult = largeMult;
+	} else {
+	    test.green_max = middleMax; test.green_mult = middleMult;
+	    test.blue_max = largeMax; test.blue_mult = largeMult;
+	}
+    } else if (small == g) {
+	test.green_max = smallMax; test.green_mult = smallMult;
+	if (middle == b) {
+	    test.blue_max = middleMax; test.blue_mult = middleMult;
+	    test.red_max = largeMax; test.red_mult = largeMult;
+	} else {
+	    test.red_max = middleMax; test.red_mult = middleMult;
+	    test.blue_max = largeMax; test.blue_mult = largeMult;
+	}
+    } else {	/* small == b */
+	test.blue_max = smallMax; test.blue_mult = smallMult;
+	if (middle == r) {
+	    test.red_max = middleMax; test.red_mult = middleMult;
+	    test.green_max = largeMax; test.green_mult = largeMult;
+	} else {
+	    test.green_max = middleMax; test.green_mult = middleMult;
+	    test.red_max = largeMax; test.red_mult = largeMult;
+	}
+    }
+    
+    /* Re-compensate for backwards cube */
+    if (backwards) {
+	test.red_mult *= -1;
+	test.green_mult *= -1;
+	test.blue_mult *= -1;
+    }
+
+    /* Finally, test the hypothesis!  The answer must be correct within 1
+       bit.  Only look at the top 8 bits; the others are too noisy */
+
+    for (i = 1; i < size; i++) {
+#define calc(i, max, mult) ((((i / test.mult) % \
+			      (test.max + 1)) * SCALE) / test.max)
+	r = ((unsigned short) calc(i, red_max, red_mult) >> 8) -
+		(black[i*mult].red >> 8);
+	g = ((unsigned short) calc(i, green_max, green_mult) >> 8) -
+		(black[i*mult].green >> 8);
+	b = ((unsigned short) calc(i, blue_max, blue_mult) >> 8) -
+		(black[i*mult].blue >> 8);
+#undef calc
+	if (ABS(r) > 2 || ABS(g) > 2 || ABS(b) > 2) return False;
+    }
+    cube->red_max = test.red_max;
+    cube->red_mult = test.red_mult;
+    cube->green_max = test.green_max;
+    cube->green_mult = test.green_mult;
+    cube->blue_max = test.blue_max;
+    cube->blue_mult = test.blue_mult;
+    cube->base_pixel = k;
+    return True;
+}
+
+#undef R
+#undef G
+#undef B
+#undef C
+#undef M
+#undef Y
+
+/* Query the entire colormap in the static gray case, then try to find
+   a gray ramp.  This handles there being 2 white or black entries
+   in the colormap and finds the longest linear ramp between pairs of
+   white and black.  If there is a color cube, also check its diagonal and
+   use its corners if we need to */
+
+static void FindStaticGrayRamp(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube)
+{
+    XColor *ramp, *black, *white, *altBlack, *altWhite;
+    int i, r0, r1, r2, r3, size, entries, redMult;
+    unsigned long base;
+
+    entries = 1 << vinfo->depth;
+    ramp = (XColor *) calloc(entries, sizeof(XColor));
+
+    if (ramp == NULL) {
+	grayRamp->red_max = 0;
+	return;
+    }
+
+    /* Query the colormap */
+    for (i = 0; i < entries; i++) ramp[i].pixel = i;
+    XQueryColors(dpy, grayRamp->colormap, ramp, entries);
+
+    /* Find the white and black entries */
+
+    black = white = altBlack = altWhite = NULL;
+    for (i = 0; i < entries; i++) {
+	if (ramp[i].flags != (DoRed | DoBlue | DoGreen)) continue;
+	if (CheckColor(ramp+i, 0, 0, 0)) {
+	    if (black == NULL) black = ramp+i;
+	    else if (altBlack == NULL) altBlack = ramp+i;
+	} else if (CheckColor(ramp+i, 1, 1, 1)) {
+	    if (white == NULL) white = ramp+i;
+	    else if (altWhite == NULL) altWhite = ramp+i;
+	}
+    }
+
+    if (black == NULL || white == NULL) {
+	grayRamp->red_max = 0;
+	free(ramp);
+	return;
+    }
+
+    /* Find out how large a ramp exists between pairs of black & white */
+    r0 = FindRampSize(black, white);
+    r1 = FindRampSize(altBlack, white);
+    r2 = FindRampSize(black, altWhite);
+    r3 = FindRampSize(altBlack, altWhite);
+
+    size = r0;
+    if (r1 > size) size = r1;
+    if (r2 > size) size = r2;
+    if (r3 > size) size = r3;
+    if (size == r0) SetRamp(black, white, size, &redMult, &base);
+    else if (size == r1) SetRamp(altBlack, white, size, &redMult, &base);
+    else if (size == r2) SetRamp(black, altWhite, size, &redMult, &base);
+    else if (size == r3) SetRamp(altBlack, altWhite, size, &redMult, &base);
+
+    if (colorCube != NULL && CubicCube(colorCube) &&
+	colorCube->red_max > size) {
+	UseGrayDiagonal(colorCube, grayRamp);
+    } else {
+	grayRamp->red_max = size;
+	grayRamp->red_mult = redMult;
+	grayRamp->base_pixel = base;
+    }
+
+    free(ramp);
+}
+
+static int FindRampSize(XColor *black, XColor *white)
+{
+    XColor *c;
+    int r;
+    int mult = 1;
+    int i, size;
+
+    if (black == NULL || white == NULL) return 0;
+    size = ABS(white - black);
+
+    /* See if we have a backwards ramp */
+    if (black > white) mult = -1;
+
+    /* See if all cells between black and white are linear, to within 1 bit.
+       Only look at the high order 8 bits */
+
+    for (i = 1; i < size; i++) {
+	c = &black[i*mult];
+	if (c->red != c->blue || c->red != c->green) return 1;
+	r = ((unsigned short) ((i * SCALE) / size) >> 8) - (c->red >> 8);
+	if (ABS(r) > 2) return 1;
+    }
+    return size;
+}
+
+static void SetRamp(
+    XColor *black,
+    XColor *white,
+    int size,
+    int *mult,
+    unsigned long *base)
+{
+    *base = black->pixel;
+    *mult = (white - black) / size;
+}
+
+#define lowbit(x) ((x) & (~(x) + 1))
+
+static unsigned long shiftdown(unsigned long x)
+{
+    while ((x & 1) == 00) {
+	x = x >> 1;
+    }
+    return x;
+}
+
+static void AllocateColorCube(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    PixelRec *pixels)
+{
+    int count, first, remain, n, j;
+    unsigned long i;
+    Colormap cmap = colorCube->colormap;
+    unsigned long delta;
+    XColor color;
+
+    /* We do no allocation for TrueColor or StaticColor */
+    if (vinfo->class == TrueColor || vinfo->class == StaticColor) return;
+
+    if (vinfo->class == DirectColor) {
+	if ((i = shiftdown(vinfo->red_mask)) > colorCube->red_max)
+		colorCube->red_max = i;
+	if ((i = shiftdown(vinfo->green_mask)) > colorCube->green_max)
+		colorCube->green_max = i;
+	if ((i = shiftdown(vinfo->blue_mask)) > colorCube->blue_max)
+		colorCube->blue_max = i;
+
+	/* We only handle symmetric DirectColor */
+	count = colorCube->red_max + 1;
+	if (colorCube->blue_max + 1 < count) count = colorCube->blue_max + 1;
+	if (colorCube->green_max + 1 < count) count = colorCube->green_max + 1;
+	colorCube->red_max = colorCube->blue_max = colorCube->green_max =
+		count - 1;
+
+	delta = lowbit(vinfo->red_mask) + lowbit(vinfo->green_mask) +
+		lowbit(vinfo->blue_mask);
+    } else {
+	count = (colorCube->red_max + 1) * (colorCube->blue_max + 1) *
+		(colorCube->green_max + 1);
+	delta = 1;
+    }
+
+    colorCube->base_pixel = 0; /* temporary, may change */
+
+    pixels->pixels = (unsigned long *) calloc(vinfo->colormap_size,
+					      sizeof(unsigned long));
+    if (pixels->pixels == NULL) {
+	colorCube->red_max = 0;
+	return;
+    }
+
+    if (!AllocateColormap(dpy, colorCube, vinfo, &count, pixels,
+			  &first, &remain, delta)) {
+	free((char *) pixels->pixels);
+	pixels->pixels = NULL;
+	colorCube->red_max = 0;
+	return;
+    }
+
+    colorCube->base_pixel = pixels->pixels[first];
+    color.flags = DoRed | DoGreen | DoBlue;
+
+    /* Define colors */
+    for (n = 0, j = 0; j < count; ++j, n += delta) {
+	color.pixel = n + pixels->pixels[first];
+	if (vinfo->class == PseudoColor) {
+#define calc(i, max, mult) ((((i / colorCube->mult) % \
+			      (colorCube->max + 1)) * SCALE) / colorCube->max)
+	    color.red = (unsigned short) calc(n, red_max, red_mult);
+	    color.green = (unsigned short) calc(n, green_max, green_mult);
+	    color.blue = (unsigned short) calc(n, blue_max, blue_mult);
+#undef calc
+	} else {
+	    color.red = color.green = color.blue =
+		    (j * SCALE) / colorCube->red_max;
+	}
+	if (!AllocateColor(dpy, cmap, &color)) {
+	    XFreeColors(dpy, cmap, pixels->pixels, count+first+remain, 0);
+	    free((char *) pixels->pixels);
+	    pixels->pixels = NULL;
+	    colorCube->red_max = 0;
+	    return;
+	}
+    }
+
+    /* Smush down unused pixels, if any */
+
+    for (j = 0; j < remain; j++) {
+	pixels->pixels[first+j] = pixels->pixels[first+count+j];
+    }
+    pixels->npixels -= count;
+}
+
+static void AllocateGrayRamp(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube,
+    PixelRec *pixels)
+{
+    int count, first, remain, n, i;
+    Colormap cmap = grayRamp->colormap;
+    XColor color;
+    unsigned long delta;
+
+    /* Allocate cells in read/write visuals only */
+    if (vinfo->class != PseudoColor && vinfo->class != GrayScale &&
+	vinfo->class != DirectColor) return;
+
+    if (vinfo->class == DirectColor) {
+	delta = lowbit(vinfo->red_mask) + lowbit(vinfo->green_mask) +
+		lowbit(vinfo->blue_mask);
+    } else delta = 1;
+
+    /* First of all see if there's a usable gray ramp in the color cube */
+
+    if (colorCube != NULL) {
+	if (CubicCube(colorCube)) {
+	    if (colorCube->red_max >= grayRamp->red_max) {
+		/* diagonal is long enough!  use it */
+		UseGrayDiagonal(colorCube, grayRamp);
+		return;
+	    }
+	}
+    }
+
+    grayRamp->base_pixel = 0; /* temporary, may change */
+
+    count = grayRamp->red_max + 1;
+
+    if (pixels->pixels == NULL) {
+	pixels->pixels = (unsigned long *) calloc(vinfo->colormap_size,
+						  sizeof(unsigned long));
+	if (pixels->pixels == NULL) {
+	    grayRamp->red_max = 0;
+	    return;
+	}
+    }
+
+    if (!AllocateColormap(dpy, grayRamp, vinfo, &count, pixels,
+			  &first, &remain, delta)) {
+	/* Last gasp:  try any diagonal or the corners of the color cube */
+	if (colorCube != NULL) {
+	    if (CubicCube(colorCube)) UseGrayDiagonal(colorCube, grayRamp);
+	    else UseGrayCorners(colorCube, grayRamp);
+	} else {
+	    grayRamp->red_max = 0;
+	}
+	return;
+    }
+
+    grayRamp->base_pixel = pixels->pixels[first];
+    color.flags = DoRed | DoGreen | DoBlue;
+
+    /* Define colors */
+    for (n = 0, i = 0; i < count; ++i, n += delta) {
+	color.pixel = n + pixels->pixels[first];
+	color.red = (unsigned short)((n * SCALE) / (grayRamp->red_max));
+	color.green = color.red;
+	color.blue = color.red;
+
+	if (!AllocateColor(dpy, cmap, &color)) {
+	    /* Don't need to free pixels here; we'll do it on return */
+	    grayRamp->red_max = 0;
+	    return;
+	}
+    }
+
+    /* Smush down unused pixels, if any */
+
+    for (i = 0; i < remain; i++) {
+	pixels->pixels[first+i] = pixels->pixels[first+count+i];
+    }
+    pixels->npixels -= count;
+}
+
+static int compare(const void *a1, const void *a2)
+{
+    register unsigned long *e1 = (unsigned long *) a1,
+			   *e2 = (unsigned long *) a2;
+
+    if (*e1 < *e2)	return -1;
+    if (*e1 > *e2)	return 1;
+    return 0;
+}
+
+static Bool AllocateColormap(
+    Display *dpy,
+    XStandardColormap *map,
+    XVisualInfo *vinfo,
+    int *count,
+    PixelRec *pixels,
+    int *first, int *remain,
+    unsigned long delta)
+{
+    Colormap cmap = map->colormap;
+    int npixels, ok, i;
+    Bool success = False;
+
+    if (pixels->npixels == 0) {
+	/* First try to allocate the entire colormap */
+	npixels = vinfo->colormap_size;
+	ok = XAllocColorCells(dpy, cmap, 1, NULL, 0, pixels->pixels, npixels);
+	if (ok) success = True;
+	else {
+	    int total;
+	    int top, mid = 0;
+
+	    /* If it's a gray ramp or direct color we need at least 2;
+	       others 8 */
+	    if (map->blue_max == 0 || vinfo->class == DirectColor) total = 2;
+	    else total = 8;
+
+	    /* Allocate all available cells, using binary backoff */
+	    top = vinfo->colormap_size - 1;
+	    while (total <= top) {
+		mid = total + ((top - total + 1) / 2);
+		ok = XAllocColorCells(dpy, cmap, 1, NULL, 0,
+				      pixels->pixels, mid);
+		if (ok) {
+		    if (mid == top) {
+			success = True;
+			break;
+		    } else {
+			XFreeColors(dpy, cmap, pixels->pixels, mid, 0);
+			total = mid;
+		    }
+		} else top = mid - 1;
+	    }
+	    if (success) npixels = mid;
+	    else npixels = 0;
+	}
+    } else {
+	/* We must be in the gray ramp case, so we need at least 2 entries */
+	npixels = pixels->npixels;
+	if (map->blue_max != 0 || npixels >= 2) success = True;
+    }
+
+    if (success) {
+	/* Avoid pessimal case by testing to see if already sorted */
+	for (i = 0; i < npixels-1; ++i) {
+	    if (pixels->pixels[i] != pixels->pixels[i+1]-1) break;
+	}
+
+	if (i < npixels-1) {
+	    PrivSort((char *)pixels->pixels, npixels,
+		     sizeof(unsigned long), compare);
+	}
+    
+	if (!contiguous(pixels->pixels, npixels, count, delta,
+			first, remain)) {
+	    /* If there are enough free cells, shrink the map to fit.
+	       Otherwise fail; we'll free the pixels later */
+	    if (((map->blue_max == 0 || vinfo->class == DirectColor) &&
+		 *count >= 2) || *count >=8) {
+		ShrinkMapToFit(map, count, vinfo);
+		*remain = npixels - *first - *count;
+	    } else success = False;
+	}
+    }
+
+    pixels->npixels = npixels;
+    return success;
+}
+
+static Bool contiguous(
+    unsigned long	pixels[],	/* specifies allocated pixels */
+    int			npixels,	/* specifies count of alloc'd pixels */
+    int			*ncolors,	/* specifies needed sequence length
+					   If not available, returns max 
+					   available contiguous sequence */
+    unsigned long	delta,
+    int			*first,		/* returns first index of sequence */
+    int			*rem)		/* returns first index after sequence,
+					 * or 0, if none follow */
+{
+    register int i = 1;		/* walking index into the pixel array */
+    register int count = 1;	/* length of sequence discovered so far */
+    int max = 1;		/* longest sequence we found */
+    int maxstart = 0;
+
+    *first = 0;
+    while (count < *ncolors && i < npixels) {
+	if (pixels[i-1] + delta == pixels[i]) count++;
+	else {
+	    if (count > max) {
+		max = count;
+		maxstart = *first;
+	    }
+	    count = 1;
+	    *first = i;
+	}
+	i++;
+    }
+    if (i == npixels && count > max) {
+	max = count;
+	maxstart = *first;
+    }
+    *rem = npixels - i;
+    if (count != *ncolors) {
+	*ncolors = max;
+	*first = maxstart;
+	return False;
+    } return True;
+}
+
+static Bool AllocateColor(
+    Display *dpy,
+    Colormap cmap,
+    XColor *color)
+{
+    unsigned long pix = color->pixel;
+    XColor request;
+    int ok;
+
+    request = *color;
+
+    /* Free RW, Alloc RO, if fails, try RW */
+    XFreeColors(dpy, cmap, &pix, 1, 0);
+    ok = XAllocColor(dpy, cmap, &request);
+
+    /* If the pixel we get back isn't the request one, probably RO
+       White or Black, so shove it in RW so our cube is correct.
+       If alloc fails, try RW. */
+
+    if (!ok || request.pixel != color->pixel) {
+	ok = XAllocColorCells(dpy, cmap, 0, NULL, 0, &pix, 1);
+
+	if (pix != color->pixel) XFreeColors(dpy, cmap, &pix, 1, 0);
+	if (!ok || pix != color->pixel) {
+	    return False;
+	}
+	request = *color;
+	XStoreColor(dpy, cmap, &request);
+    }
+    return True;
+}
+
+static void ShrinkMapToFit(
+    XStandardColormap *map,
+    int *space,
+    XVisualInfo *vinfo)
+{
+    if (map->blue_max == 0) map->red_max = *space - 1;
+    else if (vinfo->class == DirectColor) {
+	if (map->red_max > *space - 1) map->red_max = *space - 1;
+	if (map->green_max > *space - 1) map->green_max = *space - 1;
+	if (map->blue_max > *space - 1) map->blue_max = *space - 1;
+    } else {
+	int which = 2;
+	while ((map->red_max + 1) * (map->green_max + 1) *
+	       (map->blue_max + 1) > *space) {
+	    if (which == 0) {
+		if (map->red_max > 1) map->red_max--;
+		which = 1;
+	    } else if (which == 1) {
+		if (map->green_max > 1) map->green_max--;
+		which = 2;
+	    } else {
+		if (map->blue_max > 1) map->blue_max--;
+		which = 0;
+	    }
+	}
+	*space = (map->red_max + 1) * (map->green_max + 1) *
+		(map->blue_max + 1);
+
+	map->red_mult = (map->green_max + 1) * (map->blue_max + 1);
+	map->green_mult = map->blue_max + 1;
+	map->blue_mult = 1;
+    }
+}
+
+static void DefineProperty(
+    Display *dpy,
+    XStandardColormap *map,
+    XVisualInfo *vinfo,
+    XStandardColormap *prop,
+    int nProp,
+    Atom atom)
+{
+    XStandardColormap *copy;
+    int i;
+
+    if (nProp == 0) {
+	XSetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), map, 1, atom);
+	return;
+    }
+
+    copy = (XStandardColormap *) calloc(nProp+1, sizeof(XStandardColormap));
+
+    /* Hm.  If I can't allocate the list, is it better to just put our
+       property on, or to leave the ones there?  I'll guess the latter... */
+    if (copy == NULL) return;
+
+    if (vinfo->visual == DefaultVisual(dpy, vinfo->screen) &&
+	map->colormap == DefaultColormap(dpy, vinfo->screen)) {
+	/* Put new entry first; it's more likely to be useful */
+	for (i = 0; i < nProp; i++) copy[i+1] = prop[i];
+	i = 0;
+    } else {
+	/* Put it at the end */
+	for (i = 0; i < nProp; i++) copy[i] = prop[i];
+	/* i = nProp; (it does already) */
+    }
+
+    copy[i] = *map;
+    XSetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), copy, nProp+1, atom);
+    
+    free((void *) copy);
+}