CrCmap.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xmu/StdCmap.h>

Include dependency graph for CrCmap.c:

Go to the source code of this file.

Defines
#define	lowbit(x)   ((x) & (~(x) + 1))
#define	TRUEMATCH(mult, max, mask)
#define	calc(max, mult)
Functions
static int	ROmap (Display *, Colormap, unsigned long[], int, int)
static Status	ROorRWcell (Display *, Colormap, unsigned long[], int, XColor *, unsigned long)
static Status	RWcell (Display *, Colormap, XColor *, XColor *, unsigned long *)
static int	compare (_Xconst void *, _Xconst void *)
static Status	contiguous (unsigned long[], int, int, unsigned long, int *, int *)
static void	free_cells (Display *, Colormap, unsigned long[], int, int)
static Status	readonly_map (Display *, XVisualInfo *, XStandardColormap *)
static Status	readwrite_map (Display *, XVisualInfo *, XStandardColormap *)
Status	XmuCreateColormap (Display *dpy, XStandardColormap *colormap)

---

Define Documentation

#define calc	(	max,
		mult		)

Value:

(((n / colormap->mult) % \
                         (colormap->max + 1)) * 65535) / colormap->max

Referenced by readwrite_map().

#define lowbit

(

x

)

((x) & (~(x) + 1))

Definition at line 72 of file CrCmap.c.

#define TRUEMATCH	(	mult,
		max,
		mask		)

Value:

(colormap->max * colormap->mult <= vinfo->mask && \
     lowbit(vinfo->mask) == colormap->mult)

Definition at line 73 of file CrCmap.c.

---

Function Documentation

static int compare	(	_Xconst void *	,
		_Xconst void *
	)			[static]

Definition at line 497 of file CrCmap.c.

{
  return ((int)(*(long *)e1 - *(long *)e2));
}

static Status contiguous	(	unsigned	long[],
		int	,
		int	,
		unsigned	long,
		int *	,
		int *
	)			[static]

Definition at line 376 of file CrCmap.c.

References count, and i.

Referenced by readwrite_map().

{
    register int i = 1;         /* walking index into the pixel array */
    register int count = 1;     /* length of sequence discovered so far */

    *first = 0;
    if (npixels == ncolors) {
        *rem = 0;
        return 1;
    }
    *rem = npixels - 1;
    while (count < ncolors && ncolors - count <= *rem)
    {
        if (pixels[i-1] + delta == pixels[i])
            count++;
        else {
            count = 1;
            *first = i;
        }
        i++;
        (*rem)--;
    }
    if (count != ncolors)
        return 0;
    return 1;
}

Here is the caller graph for this function:

static void free_cells	(	Display *	,
		Colormap	,
		unsigned	long[],
		int	,
		int
	)			[static]

Definition at line 451 of file CrCmap.c.

References free().

Referenced by ROorRWcell().

{
    /* One of the npixels allocated has already been freed.
     * p is the index of the freed pixel.
     * First free the pixels preceeding p, and there are p of them;
     * then free the pixels following p, there are npixels - p - 1 of them.
     */
    XFreeColors(dpy, cmap, pixels, p, (unsigned long) 0);
    XFreeColors(dpy, cmap, &(pixels[p+1]), npixels - p - 1, (unsigned long) 0);
    free((char *) pixels);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Status readonly_map	(	Display *	,
		XVisualInfo *	,
		XStandardColormap *
	)			[static]

Definition at line 505 of file CrCmap.c.

References i, and long.

{
    int                 i, last_pixel;
    XColor              color;

    last_pixel = (colormap->red_max + 1) * (colormap->green_max + 1) * 
        (colormap->blue_max + 1) + colormap->base_pixel - 1;

    for(i=colormap->base_pixel; i <= last_pixel; i++) {

        color.pixel = (unsigned long) i;
        color.red = (unsigned short)
            (((i/colormap->red_mult) * 65535) / colormap->red_max);

        if (vinfo->class == StaticColor) {
            color.green = (unsigned short)
                ((((i/colormap->green_mult) % (colormap->green_max + 1)) *
                  65535) / colormap->green_max);
            color.blue = (unsigned short)
                (((i%colormap->green_mult) * 65535) / colormap->blue_max);
        }
        else    /* vinfo->class == GrayScale, old style allocation XXX */
            color.green = color.blue = color.red;

        XAllocColor(dpy, colormap->colormap, &color);
        if (color.pixel != (unsigned long) i)
            return 0;
    }
    return 1;
}

static Status readwrite_map	(	Display *	,
		XVisualInfo *	,
		XStandardColormap *
	)			[static]

Definition at line 170 of file CrCmap.c.

References calc, calloc(), compare(), contiguous(), free(), i, lowbit, n, NULL, ROmap(), and ROorRWcell().

{
    register unsigned long i, n;        /* index counters */
    unsigned long       ncolors;        /* number of colors to be defined */
    int                 npixels;        /* number of pixels allocated R/W */
    int                 first_index;    /* first index of pixels to use */
    int                 remainder;      /* first index of remainder */
    XColor              color;          /* the definition of a color */
    unsigned long       *pixels;        /* array of colormap pixels */
    unsigned long       delta;

    
    /* Determine ncolors, the number of colors to be defined.
     * Insure that 1 < ncolors <= the colormap size.
     */
    if (vinfo->class == DirectColor) {
        ncolors = colormap->red_max;
        if (colormap->green_max > ncolors)
            ncolors = colormap->green_max;
        if (colormap->blue_max > ncolors)
            ncolors = colormap->blue_max;
        ncolors++;
        delta = lowbit(vinfo->red_mask) +
                lowbit(vinfo->green_mask) +
                lowbit(vinfo->blue_mask);
    } else {
        ncolors = colormap->red_max * colormap->red_mult +
                  colormap->green_max * colormap->green_mult +
                  colormap->blue_max * colormap->blue_mult + 1;
        delta = 1;
    }
    if (ncolors <= 1 || (int) ncolors > vinfo->colormap_size)   return 0;

    /* Allocate Read/Write as much of the colormap as we can possibly get.
     * Then insure that the pixels we were allocated are given in 
     * monotonically increasing order, using a quicksort.  Next, insure
     * that our allocation includes a subset of contiguous pixels at least
     * as long as the number of colors to be defined.  Now we know that 
     * these conditions are met:
     *  1) There are no free cells in the colormap.
     *  2) We have a contiguous sequence of pixels, monotonically 
     *     increasing, of length >= the number of colors requested.
     *
     * One cell at a time, we will free, compute the next color value, 
     * then allocate read only.  This takes a long time.
     * This is done to insure that cells are allocated read only in the
     * contiguous order which we prefer.  If the server has a choice of
     * cells to grant to an allocation request, the server may give us any
     * cell, so that is why we do these slow gymnastics.
     */

    if ((pixels = (unsigned long *) calloc((unsigned) vinfo->colormap_size,
                                      sizeof(unsigned long))) == NULL)
        return 0;

    if ((npixels = ROmap(dpy, colormap->colormap, pixels,
                           vinfo->colormap_size, ncolors)) == 0) {
        free((char *) pixels);
        return 0;
    }

    qsort((char *) pixels, npixels, sizeof(unsigned long), compare);

    if (!contiguous(pixels, npixels, ncolors, delta, &first_index, &remainder))
    {
        /* can't find enough contiguous cells, give up */
        XFreeColors(dpy, colormap->colormap, pixels, npixels,
                    (unsigned long) 0);
        free((char *) pixels);
        return 0;
    }
    colormap->base_pixel = pixels[first_index];

    /* construct a gray map */
    if (colormap->red_mult == 1 && colormap->green_mult == 1 &&
        colormap->blue_mult == 1)
        for (n=colormap->base_pixel, i=0; i < ncolors; i++, n += delta)
        {
            color.pixel = n;
            color.blue = color.green = color.red =
                (unsigned short) ((i * 65535) / (colormap->red_max +
                                                 colormap->green_max +
                                                 colormap->blue_max));

            if (! ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
                             first_index + i))
                return 0;
        }

    /* construct a red ramp map */
    else if (colormap->green_max == 0 && colormap->blue_max == 0)
        for (n=colormap->base_pixel, i=0; i < ncolors; i++, n += delta)
        {
            color.pixel = n;
            color.red = (unsigned short) ((i * 65535) / colormap->red_max);
            color.green = color.blue = 0;

            if (! ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
                             first_index + i))
                return 0;
        }

    /* construct a green ramp map */
    else if (colormap->red_max == 0 && colormap->blue_max == 0)
        for (n=colormap->base_pixel, i=0; i < ncolors; i++, n += delta)
        {
            color.pixel = n;
            color.green = (unsigned short) ((i * 65535) / colormap->green_max);
            color.red = color.blue = 0;

            if (! ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
                             first_index + i))
                return 0;
        }

    /* construct a blue ramp map */
    else if (colormap->red_max == 0 && colormap->green_max == 0)
        for (n=colormap->base_pixel, i=0; i < ncolors; i++, n += delta)
        {
            color.pixel = n;
            color.blue = (unsigned short) ((i * 65535) / colormap->blue_max);
            color.red = color.green = 0;

            if (! ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
                             first_index + i))
                return 0;
        }

    /* construct a standard red green blue cube map */
    else
    {
#define calc(max,mult) (((n / colormap->mult) % \
                         (colormap->max + 1)) * 65535) / colormap->max

        for (n=0, i=0; i < ncolors; i++, n += delta)
        {
            color.pixel = n + colormap->base_pixel;
            color.red = calc(red_max, red_mult);
            color.green = calc(green_max, green_mult);
            color.blue = calc(blue_max, blue_mult);
            if (! ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
                             first_index + i))
                return 0;
        }
#undef calc
    }
    /* We have a read-only map defined.  Now free unused cells,
     * first those occuring before the contiguous sequence begins,
     * then any following the contiguous sequence.
     */

    if (first_index)
        XFreeColors(dpy, colormap->colormap, pixels, first_index, 
                    (unsigned long) 0);
    if (remainder)
        XFreeColors(dpy, colormap->colormap,
                    &(pixels[first_index + ncolors]), remainder,
                    (unsigned long) 0);

    free((char *) pixels);
    return 1;
}

Here is the call graph for this function:

static int ROmap	(	Display *	,
		Colormap	,
		unsigned	long[],
		int	,
		int
	)			[static]

Definition at line 336 of file CrCmap.c.

References NULL, and p.

Referenced by readwrite_map().

{
    register int        p;

    /* first try to allocate the entire colormap */
    if (XAllocColorCells(dpy, cmap, 1, (unsigned long *) NULL, 
                         (unsigned) 0, pixels, (unsigned) m))
        return m;

    /* Allocate all available cells in the colormap, using a binary
     * algorithm to discover how many cells we can allocate in the colormap.
     */
    m--;
    while (n <= m) {
        p = n + ((m - n + 1) / 2);
        if (XAllocColorCells(dpy, cmap, 1, (unsigned long *) NULL,
                             (unsigned) 0, pixels, (unsigned) p)) {
            if (p == m)
                return p;
            else {
                XFreeColors(dpy, cmap, pixels, p, (unsigned long) 0);
                n = p;
            }
        }
        else
            m = p - 1;
    }
    return 0;
}

Here is the caller graph for this function:

static Status ROorRWcell	(	Display *	,
		Colormap	,
		unsigned	long[],
		int	,
		XColor *	,
		unsigned	long
	)			[static]

Definition at line 414 of file CrCmap.c.

References free_cells(), and RWcell().

Referenced by readwrite_map().

{
    unsigned long       pixel;
    XColor              request;

    /* Free the read/write allocation of one cell in the colormap.
     * Request a read only allocation of one cell in the colormap.
     * If the read only allocation cannot be granted, give up, because
     * there must be no free cells in the colormap.
     * If the read only allocation is granted, but gives us a cell which
     * is not the one that we just freed, it is probably the case that
     * we are trying allocate White or Black or some other color which
     * already has a read-only allocation in the map.  So we try to 
     * allocate the previously freed cell with a read/write allocation,
     * because we want contiguous cells for image processing algorithms.
     */
     
    pixel = color->pixel;
    request.red = color->red;
    request.green = color->green;
    request.blue = color->blue;

    XFreeColors(dpy, cmap, &pixel, 1, (unsigned long) 0);
    if (! XAllocColor(dpy, cmap, color) 
        || (color->pixel != pixel &&
            (!RWcell(dpy, cmap, color, &request, &pixel)))) 
    {
        free_cells(dpy, cmap, pixels, npixels, (int)p);
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Status RWcell	(	Display *	,
		Colormap	,
		XColor *	,
		XColor *	,
		unsigned long *
	)			[static]

Definition at line 471 of file CrCmap.c.

References n, and NULL.

Referenced by ROorRWcell().

{
    unsigned long       n = *pixel;

    XFreeColors(dpy, cmap, &(color->pixel), 1, (unsigned long)0);
    if (! XAllocColorCells(dpy, cmap, (Bool) 0, (unsigned long *) NULL,
                           (unsigned) 0, pixel, (unsigned) 1))
        return 0;
    if (*pixel != n)
    {
        XFreeColors(dpy, cmap, pixel, 1, (unsigned long) 0);
        return 0;
    }
    color->pixel = *pixel;
    color->flags = DoRed | DoGreen | DoBlue;
    color->red = request->red;
    color->green = request->green;
    color->blue = request->blue;
    XStoreColors(dpy, cmap, color, 1);
    return 1;
}

Here is the caller graph for this function:

Status XmuCreateColormap	(	Display *	dpy,
		XStandardColormap *	colormap
	)

Definition at line 98 of file CrCmap.c.

References i, n, NULL, and v.

Referenced by XmuStandardColormap().

{
    XVisualInfo         vinfo_template; /* template visual information */
    XVisualInfo         *vinfo;         /* matching visual information */
    XVisualInfo         *vpointer;      /* for freeing the entire list */
    long                vinfo_mask;     /* specifies the visual mask value */
    int                 n;              /* number of matching visuals */
    int                 status;         

    vinfo_template.visualid = colormap->visualid;
    vinfo_mask = VisualIDMask;
    if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
        return 0;

    /* 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.
     */
    vpointer = vinfo;
    if (n > 1)
    {
        register int    i;
        register int    screen_number;
        Bool            def_cmap;

        def_cmap = False;
        for (screen_number = ScreenCount(dpy); --screen_number >= 0; )
            if (colormap->colormap == DefaultColormap(dpy, screen_number)) {
                def_cmap = True;
                break;
            }

        if (def_cmap) {
            for (i=0; i < n; i++, vinfo++) {
                if (vinfo->visual == DefaultVisual(dpy, screen_number))
                        break;
            }
        } else {
            int                 maxdepth = 0;
            XVisualInfo         *v = NULL;

            for (i=0; i < n; i++, vinfo++)
                if (vinfo->depth > maxdepth) {
                    maxdepth = vinfo->depth;
                    v = vinfo;
                }
            vinfo = v;
        }
    }

    if (vinfo->class == PseudoColor || vinfo->class == DirectColor ||
        vinfo->class == GrayScale)
        status = readwrite_map(dpy, vinfo, colormap);
    else if (vinfo->class == TrueColor)
        status = TRUEMATCH(red_mult, red_max, red_mask) &&
                 TRUEMATCH(green_mult, green_max, green_mask) &&
                 TRUEMATCH(blue_mult, blue_max, blue_mask);
    else 
        status = readonly_map(dpy, vinfo, colormap);
    
    XFree((char *) vpointer);
    return status;
}

Here is the caller graph for this function:

---