StdCmap.h File Reference

#include <X11/Xfuncproto.h>

Include dependency graph for StdCmap.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
_XFUNCPROTOBEGIN Status	XmuAllStandardColormaps (Display *dpy)
Status	XmuCreateColormap (Display *dpy, XStandardColormap *colormap)
void	XmuDeleteStandardColormap (Display *dpy, int screen, Atom property)
Status	XmuGetColormapAllocation (XVisualInfo *vinfo, Atom property, unsigned long *red_max_return, unsigned long *green_max_return, unsigned long *blue_max_return)
Status	XmuLookupStandardColormap (Display *dpy, int screen, VisualID visualid, unsigned int depth, Atom property, Bool replace, Bool retain)
XStandardColormap *	XmuStandardColormap (Display *dpy, int screen, VisualID visualid, unsigned int depth, Atom property, Colormap cmap, unsigned long red_max, unsigned long green_max, unsigned long blue_max)
Status	XmuVisualStandardColormaps (Display *dpy, int screen, VisualID visualid, unsigned int depth, Bool replace, Bool retain)
Bool	XmuDistinguishableColors (XColor *colors, int count)
Bool	XmuDistinguishablePixels (Display *dpy, Colormap cmap, unsigned long *pixels, int count)

---

Function Documentation

_XFUNCPROTOBEGIN Status XmuAllStandardColormaps

(

Display *

dpy

)

Definition at line 92 of file AllCmap.c.

References getDeepestVisual(), NULL, and XmuVisualStandardColormaps().

{
    int         nvisuals, scr;
    Status      status;
    long        vinfo_mask;
    XVisualInfo template, *vinfo, *v1, *v2;

    status = 0;
    /* for each screen, determine all visuals of this server */
    for (scr=0; scr < ScreenCount(dpy); scr++)
    {
        template.screen = scr;
        vinfo_mask = VisualScreenMask;
        vinfo = XGetVisualInfo(dpy, vinfo_mask, &template, &nvisuals);
        if (vinfo == NULL) /* unexpected: a screen with no visuals */
            continue;

        v1 = getDeepestVisual(DirectColor, vinfo, nvisuals);
        v2 = getDeepestVisual(PseudoColor, vinfo, nvisuals);

        if (v2 &&
            (!v1 || (v2->colormap_size >=
                     ((v1->red_mask | v1->green_mask | v1->blue_mask) + 1))))
            status = XmuVisualStandardColormaps(dpy, scr, v2->visualid,
                                                (unsigned) v2->depth, 1, 1);
        else if (v1)
            status = XmuVisualStandardColormaps(dpy, scr, v1->visualid,
                                                (unsigned) v1->depth, 1, 1);

        else {
            if (((v1 = getDeepestVisual(TrueColor, vinfo, nvisuals)) != NULL)
                || ((v1 = getDeepestVisual(StaticColor, vinfo, nvisuals)) !=
                NULL))
                status = XmuVisualStandardColormaps(dpy, scr, v1->visualid,
                                                   (unsigned) v1->depth, 1, 1);
            if (status && 
               (((v1 = getDeepestVisual(GrayScale, vinfo, nvisuals)) != NULL)
                || ((v1 = getDeepestVisual(StaticGray, vinfo, nvisuals)) != 
                    NULL)))
                status = XmuVisualStandardColormaps(dpy, scr, v1->visualid,
                                                   (unsigned) v1->depth, 1, 1);
        }
        XFree ((char *) vinfo);
        if (!status) break;
    }
    return status;
}

Here is the call 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:

void XmuDeleteStandardColormap	(	Display *	dpy,
		int	screen,
		Atom	property
	)

Definition at line 45 of file DelCmap.c.

References count, and s.

Referenced by lookup(), and XmuVisualStandardColormaps().

{
    XStandardColormap   *stdcmaps, *s;
    int                 count = 0;

    if (XGetRGBColormaps(dpy, RootWindow(dpy, screen), &stdcmaps, &count,
                         property))
    {
        for (s=stdcmaps; count > 0; count--, s++) {
            if ((s->killid == ReleaseByFreeingColormap) &&
                (s->colormap != None) &&
                (s->colormap != DefaultColormap(dpy, screen)))
                XFreeColormap(dpy, s->colormap);
            else if (s->killid != None)
                XKillClient(dpy, s->killid);
        }
        XDeleteProperty(dpy, RootWindow(dpy, screen), property);
        XFree((char *) stdcmaps);
        XSync(dpy, False);
    }
}

Here is the caller graph for this function:

Bool XmuDistinguishableColors	(	XColor *	colors,
		int	count
	)

Definition at line 47 of file Distinct.c.

References i, j, and MIN_DISTINGUISH.

Referenced by XmuDistinguishablePixels().

{
    double          deltaRed, deltaGreen, deltaBlue;
    double          dist;
    int             i, j;

    for (i = 0; i < count - 1; i++)
        for (j = i + 1; j < count; j++)
        {
            deltaRed = (double)colors[i].red - (double)colors[j].red;
            deltaGreen = (double)colors[i].green - (double)colors[j].green;
            deltaBlue = (double)colors[i].blue - (double)colors[j].blue;
            dist = deltaRed * deltaRed +
                   deltaGreen * deltaGreen +
                   deltaBlue * deltaBlue;
            if (dist <= MIN_DISTINGUISH * MIN_DISTINGUISH)
                return False;
        }
    return True;
}

Here is the caller graph for this function:

Bool XmuDistinguishablePixels	(	Display *	dpy,
		Colormap	cmap,
		unsigned long *	pixels,
		int	count
	)

Definition at line 69 of file Distinct.c.

References free(), i, j, malloc(), and XmuDistinguishableColors().

{
    XColor  *defs;
    int     i, j;
    Bool    ret;

    for (i = 0; i < count - 1; i++)
        for (j = i + 1; j < count; j++)
            if (pixels[i] == pixels[j])
                return False;
    defs = (XColor *) malloc (count * sizeof (XColor));
    if (!defs)
        return False;
    for (i = 0; i < count; i++)
        defs[i].pixel = pixels[i];
    XQueryColors (dpy, cmap, defs, count);
    ret = XmuDistinguishableColors (defs, count);
    free ((char *) defs);
    return ret;
}

Here is the call graph for this function:

Status XmuGetColormapAllocation	(	XVisualInfo *	vinfo,
		Atom	property,
		unsigned long *	red_max_return,
		unsigned long *	green_max_return,
		unsigned long *	blue_max_return
	)

Definition at line 68 of file CmapAlloc.c.

References best_allocation(), default_allocation(), and gray_allocation().

Referenced by XmuLookupStandardColormap().

{
    Status      status = 1;

    if (vinfo->colormap_size <= 2)
        return 0;

    switch (property)
    {
      case XA_RGB_DEFAULT_MAP:
        status = default_allocation(vinfo, red_max, green_max, blue_max);
        break;
      case XA_RGB_BEST_MAP:
        best_allocation(vinfo, red_max, green_max, blue_max);
        break;
      case XA_RGB_GRAY_MAP:
        gray_allocation(vinfo->colormap_size, red_max, green_max, blue_max);
        break;
      case XA_RGB_RED_MAP:
        *red_max = vinfo->colormap_size - 1;
        *green_max = *blue_max = 0;
        break;
      case XA_RGB_GREEN_MAP:
        *green_max = vinfo->colormap_size - 1;
        *red_max = *blue_max = 0;
        break;
      case XA_RGB_BLUE_MAP:
        *blue_max = vinfo->colormap_size - 1;
        *red_max = *green_max = 0;
        break;
      default:
        status = 0;
    }
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status XmuLookupStandardColormap	(	Display *	dpy,
		int	screen,
		VisualID	visualid,
		unsigned int	depth,
		Atom	property,
		Bool	replace,
		Bool	retain
	)

Definition at line 72 of file LookupCmap.c.

References count, lookup(), NULL, XmuGetColormapAllocation(), and XmuStandardColormap().

Referenced by XmuVisualStandardColormaps().

{
    Display             *odpy;          /* original display connection */
    XStandardColormap   *colormap;      
    XVisualInfo         vinfo_template, *vinfo; /* visual */
    long                vinfo_mask;
    unsigned long       r_max, g_max, b_max;    /* allocation */
    int                 count;  
    Colormap            cmap;                   /* colormap ID */
    Status              status = 0;


    /* Match the requested visual */

    vinfo_template.visualid = visualid; 
    vinfo_template.screen = screen;
    vinfo_template.depth = depth;
    vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
    if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &count)) ==
        NULL)
        return 0;

    /* Monochrome visuals have no standard maps */

    if (vinfo->colormap_size <= 2) {
        XFree((char *) vinfo);
        return 0;       
    }

    /* If the requested property already exists on this screen, and, 
     * if the replace flag has not been set to true, return success.
     * lookup() will remove a pre-existing map if replace is true.
     */

    if (lookup(dpy, screen, visualid, property, (XStandardColormap *) NULL,
               replace) && !replace) {
        XFree((char *) vinfo);
        return 1;
    }

    /* Determine the best allocation for this property under the requested
     * visualid and depth, and determine whether or not to use the default
     * colormap of the screen.
     */

    if (!XmuGetColormapAllocation(vinfo, property, &r_max, &g_max, &b_max)) {
        XFree((char *) vinfo);
        return 0;
    }

    cmap = (property == XA_RGB_DEFAULT_MAP &&
            visualid == XVisualIDFromVisual(DefaultVisual(dpy, screen)))
        ? DefaultColormap(dpy, screen) : None;

    /* If retaining resources, open a new connection to the same server */

    if (retain) {
        odpy = dpy;
        if ((dpy = XOpenDisplay(XDisplayString(odpy))) == NULL) {
            XFree((char *) vinfo);
            return 0;
        }
    }

    /* Create the standard colormap */

    colormap = XmuStandardColormap(dpy, screen, visualid, depth, property,
                                   cmap, r_max, g_max, b_max);

    /* Set the standard colormap property */

    if (colormap) {
        XGrabServer(dpy);

        if (lookup(dpy, screen, visualid, property, colormap, replace) &&
            !replace) {
            /* Someone has defined the property since we last looked.
             * Since we will not replace it, release our own resources.
             * If this is the default map, our allocations will be freed 
             * when this connection closes.
             */
            if (colormap->killid == ReleaseByFreeingColormap)
                XFreeColormap(dpy, colormap->colormap);
        }
        else if (retain) {
                XSetCloseDownMode(dpy, RetainPermanent);
        }
        XUngrabServer(dpy);
        XFree((char *) colormap);
        status = 1;
    }

    if (retain)
        XCloseDisplay(dpy);
    XFree((char *) vinfo);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XStandardColormap* XmuStandardColormap	(	Display *	dpy,
		int	screen,
		VisualID	visualid,
		unsigned int	depth,
		Atom	property,
		Colormap	cmap,
		unsigned long	red_max,
		unsigned long	green_max,
		unsigned long	blue_max
	)

Definition at line 65 of file StdCmap.c.

References lowbit, n, NULL, valid_args(), and XmuCreateColormap().

Referenced by XmuLookupStandardColormap().

{
    XStandardColormap   *stdcmap;
    Status              status;
    XVisualInfo         vinfo_template, *vinfo;
    long                vinfo_mask;
    int                 n;

    /* Match the required visual information to an actual visual */
    vinfo_template.visualid = visualid; 
    vinfo_template.screen = screen;
    vinfo_template.depth = depth;
    vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
    if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
        return 0;

    /* Check the validity of the combination of visual characteristics,
     * allocation, and colormap property.  Create an XStandardColormap
     * structure.
     */

    if (! valid_args(vinfo, red_max, green_max, blue_max, property)
        || ((stdcmap = XAllocStandardColormap()) == NULL)) {
        XFree((char *) vinfo);
        return 0;
    }

    /* Fill in the XStandardColormap structure */

    if (cmap == DefaultColormap(dpy, screen)) {
        /* Allocating out of the default map, cannot use XFreeColormap() */
        Window win = XCreateWindow(dpy, RootWindow(dpy, screen), 1, 1, 1, 1,
                                   0, 0, InputOnly, vinfo->visual,
                                   (unsigned long) 0,
                                   (XSetWindowAttributes *)NULL);
        stdcmap->killid  = (XID) XCreatePixmap(dpy, win, 1, 1, depth);
        XDestroyWindow(dpy, win);
        stdcmap->colormap = cmap;
    } else {
        stdcmap->killid = ReleaseByFreeingColormap;
        stdcmap->colormap = XCreateColormap(dpy, RootWindow(dpy, screen),
                                            vinfo->visual, AllocNone);
    }
    stdcmap->red_max = red_max;
    stdcmap->green_max = green_max;
    stdcmap->blue_max = blue_max;
    if (property == XA_RGB_GRAY_MAP) 
        stdcmap->red_mult = stdcmap->green_mult = stdcmap->blue_mult = 1;
    else if (vinfo->class == TrueColor || vinfo->class == DirectColor) {
        stdcmap->red_mult = lowbit(vinfo->red_mask);
        stdcmap->green_mult = lowbit(vinfo->green_mask);
        stdcmap->blue_mult = lowbit(vinfo->blue_mask);
    } else {
        stdcmap->red_mult = (red_max > 0)
            ? (green_max + 1) * (blue_max + 1) : 0;
        stdcmap->green_mult = (green_max > 0) ? blue_max + 1 : 0;
        stdcmap->blue_mult = (blue_max > 0) ? 1 : 0;
    }
    stdcmap->base_pixel = 0;                    /* base pixel may change */
    stdcmap->visualid = vinfo->visualid;

    /* Make the colormap */

    status = XmuCreateColormap(dpy, stdcmap);

    /* Clean up */

    XFree((char *) vinfo);
    if (!status) {

        /* Free the colormap or the pixmap, if we created one */
        if (stdcmap->killid == ReleaseByFreeingColormap)
            XFreeColormap(dpy, stdcmap->colormap);
        else if (stdcmap->killid != None)
            XFreePixmap(dpy, stdcmap->killid);
        
        XFree((char *) stdcmap);
        return (XStandardColormap *) NULL;
    }
    return stdcmap;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Status XmuVisualStandardColormaps	(	Display *	dpy,
		int	screen,
		VisualID	visualid,
		unsigned int	depth,
		Bool	replace,
		Bool	retain
	)

Definition at line 72 of file VisCmap.c.

References n, NULL, XmuDeleteStandardColormap(), and XmuLookupStandardColormap().

Referenced by XmuAllStandardColormaps().

{
    Status              status;
    int                 n;
    long                vinfo_mask;
    XVisualInfo         vinfo_template, *vinfo;

    status = 0;
    vinfo_template.screen = screen;
    vinfo_template.visualid = visualid;
    vinfo_template.depth = depth;
    vinfo_mask = VisualScreenMask | VisualIDMask | VisualDepthMask;
    if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
        return 0;

    if (vinfo->colormap_size <= 2) {
        /* Monochrome visuals have no standard maps; considered successful */
        XFree((char *) vinfo);
        return 1;
    }

    switch (vinfo->class)
    {
      case PseudoColor:
      case DirectColor:
        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_DEFAULT_MAP, replace,retain);
        if (!status) break;

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_GRAY_MAP, replace, retain);
        if (!status) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            break;
        }

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_RED_MAP, replace, retain);
        if (!status) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
            break;
        }

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_GREEN_MAP, replace, retain);
        if (!status) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
            break;
        }

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_BLUE_MAP, replace, retain);
        if (!status) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GREEN_MAP);
            break;
        }
        /* fall through */

      case StaticColor:
      case TrueColor:

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_BEST_MAP, replace, retain);
        if (!status && (vinfo->class == PseudoColor || 
                        vinfo->class == DirectColor)) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GREEN_MAP);
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_BLUE_MAP);
        }
        break;
        /* the end for PseudoColor, DirectColor, StaticColor, and TrueColor */

      case GrayScale:
        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_DEFAULT_MAP, replace,
                                           retain);
        if (! status) break;
        /*FALLTHROUGH*/

      case StaticGray:

        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
                                           XA_RGB_GRAY_MAP, replace, retain);
        if (! status && vinfo->class == GrayScale) {
            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
            break;
        }
    }

    XFree((char *) vinfo);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---