wrlib/StdCmap.c

   1 /* $XConsortium: StdCmap.c,v 1.14 94/04/17 20:16:14 rws Exp $ */
   2
   3 /*
   4
   5 Copyright (c) 1989  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28 */
  29
  30 /*
  31  * Author:  Donna Converse, MIT X Consortium
  32  */
  33
  34 #include <stdio.h>
  35 #include <X11/Xlib.h>
  36 #include <X11/Xatom.h>
  37 #include <X11/Xutil.h>
  38 #include "StdCmap.h"
  39
  40 #define lowbit(x) ((x) & (~(x) + 1))
  41
  42 static Status valid_args();             /* argument restrictions */
  43
  44 /*
  45  * To create any one standard colormap, use XmuStandardColormap().
  46  *
  47  * Create a standard colormap for the given screen, visualid, and visual
  48  * depth, with the given red, green, and blue maximum values, with the
  49  * given standard property name.  Return a pointer to an XStandardColormap
  50  * structure which describes the newly created colormap, upon success.
  51  * Upon failure, return NULL.
  52  *
  53  * XmuStandardColormap() calls XmuCreateColormap() to create the map.
  54  *
  55  * Resources created by this function are not made permanent; that is the
  56  * caller's responsibility.
  57  */
  58
  59 XStandardColormap *XmuStandardColormap(dpy, screen, visualid, depth, property,
  60                                        cmap, red_max, green_max, blue_max)
  61     Display             *dpy;           /* specifies X server connection */
  62     int                 screen;         /* specifies display screen */
  63     VisualID            visualid;       /* identifies the visual type */
  64     unsigned int        depth;          /* identifies the visual type */
  65     Atom                property;       /* a standard colormap property */
  66     Colormap            cmap;           /* specifies colormap ID or None */
  67     unsigned long       red_max, green_max, blue_max;   /* allocations */
  68 {
  69     XStandardColormap   *stdcmap;
  70     Status              status;
  71     XVisualInfo         vinfo_template, *vinfo;
  72     long                vinfo_mask;
  73     int                 n;
  74
  75     /* Match the required visual information to an actual visual */
  76     vinfo_template.visualid = visualid;
  77     vinfo_template.screen = screen;
  78     vinfo_template.depth = depth;
  79     vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
  80     if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
  81         return 0;
  82
  83     /* Check the validity of the combination of visual characteristics,
  84      * allocation, and colormap property.  Create an XStandardColormap
  85      * structure.
  86      */
  87
  88     if (! valid_args(vinfo, red_max, green_max, blue_max, property)
  89         || ((stdcmap = XAllocStandardColormap()) == NULL)) {
  90         XFree((char *) vinfo);
  91         return 0;
  92     }
  93
  94     /* Fill in the XStandardColormap structure */
  95
  96     if (cmap == DefaultColormap(dpy, screen)) {
  97         /* Allocating out of the default map, cannot use XFreeColormap() */
  98         Window win = XCreateWindow(dpy, RootWindow(dpy, screen), 1, 1, 1, 1,
  99                                    0, 0, InputOnly, vinfo->visual,
 100                                    (unsigned long) 0,
 101                                    (XSetWindowAttributes *)NULL);
 102         stdcmap->killid  = (XID) XCreatePixmap(dpy, win, 1, 1, depth);
 103         XDestroyWindow(dpy, win);
 104         stdcmap->colormap = cmap;
 105     } else {
 106         stdcmap->killid = ReleaseByFreeingColormap;
 107         stdcmap->colormap = XCreateColormap(dpy, RootWindow(dpy, screen),
 108                                             vinfo->visual, AllocNone);
 109     }
 110     stdcmap->red_max = red_max;
 111     stdcmap->green_max = green_max;
 112     stdcmap->blue_max = blue_max;
 113     if (property == XA_RGB_GRAY_MAP)
 114         stdcmap->red_mult = stdcmap->green_mult = stdcmap->blue_mult = 1;
 115     else if (vinfo->class == TrueColor || vinfo->class == DirectColor) {
 116         stdcmap->red_mult = lowbit(vinfo->red_mask);
 117         stdcmap->green_mult = lowbit(vinfo->green_mask);
 118         stdcmap->blue_mult = lowbit(vinfo->blue_mask);
 119     } else {
 120         stdcmap->red_mult = (red_max > 0)
 121             ? (green_max + 1) * (blue_max + 1) : 0;
 122         stdcmap->green_mult = (green_max > 0) ? blue_max + 1 : 0;
 123         stdcmap->blue_mult = (blue_max > 0) ? 1 : 0;
 124     }
 125     stdcmap->base_pixel = 0;                    /* base pixel may change */
 126     stdcmap->visualid = vinfo->visualid;
 127
 128     /* Make the colormap */
 129
 130     status = XmuCreateColormap(dpy, stdcmap);
 131
 132     /* Clean up */
 133
 134     XFree((char *) vinfo);
 135     if (!status) {
 136
 137         /* Free the colormap or the pixmap, if we created one */
 138         if (stdcmap->killid == ReleaseByFreeingColormap)
 139             XFreeColormap(dpy, stdcmap->colormap);
 140         else if (stdcmap->killid != None)
 141             XFreePixmap(dpy, stdcmap->killid);
 142
 143         XFree((char *) stdcmap);
 144         return (XStandardColormap *) NULL;
 145     }
 146     return stdcmap;
 147 }
 148
 149 /****************************************************************************/
 150 static Status valid_args(vinfo, red_max, green_max, blue_max, property)
 151     XVisualInfo         *vinfo;         /* specifies visual */
 152     unsigned long       red_max, green_max, blue_max;   /* specifies alloc */
 153     Atom                property;       /* specifies property name */
 154 {
 155     unsigned long       ncolors;        /* number of colors requested */
 156
 157     /* Determine that the number of colors requested is <= map size */
 158
 159     if ((vinfo->class == DirectColor) || (vinfo->class == TrueColor)) {
 160         unsigned long mask;
 161
 162         mask = vinfo->red_mask;
 163         while (!(mask & 1))
 164             mask >>= 1;
 165         if (red_max > mask)
 166             return 0;
 167         mask = vinfo->green_mask;
 168         while (!(mask & 1))
 169             mask >>= 1;
 170         if (green_max > mask)
 171             return 0;
 172         mask = vinfo->blue_mask;
 173         while (!(mask & 1))
 174             mask >>= 1;
 175         if (blue_max > mask)
 176             return 0;
 177     } else if (property == XA_RGB_GRAY_MAP) {
 178         ncolors = red_max + green_max + blue_max + 1;
 179         if (ncolors > vinfo->colormap_size)
 180             return 0;
 181     } else {
 182         ncolors = (red_max + 1) * (green_max + 1) * (blue_max + 1);
 183         if (ncolors > vinfo->colormap_size)
 184             return 0;
 185     }
 186
 187     /* Determine that the allocation and visual make sense for the property */
 188
 189     switch (property)
 190     {
 191       case XA_RGB_DEFAULT_MAP:
 192         if (red_max == 0 || green_max == 0 || blue_max == 0)
 193             return 0;
 194         break;
 195       case XA_RGB_RED_MAP:
 196         if (red_max == 0)
 197             return 0;
 198         break;
 199       case XA_RGB_GREEN_MAP:
 200         if (green_max == 0)
 201             return 0;
 202         break;
 203       case XA_RGB_BLUE_MAP:
 204         if (blue_max == 0)
 205             return 0;
 206         break;
 207       case XA_RGB_BEST_MAP:
 208         if (red_max == 0 || green_max == 0 || blue_max == 0)
 209             return 0;
 210         break;
 211       case XA_RGB_GRAY_MAP:
 212         if (red_max == 0 || blue_max == 0 || green_max == 0)
 213             return 0;
 214         break;
 215       default:
 216         return 0;
 217     }
 218     return 1;
 219 }