WINGs/wcolor.c

   1
   2 #include "WINGsP.h"
   3
   4 #include <wraster.h>
   5
   6 #define LIGHT_STIPPLE_WIDTH 4
   7 #define LIGHT_STIPPLE_HEIGHT 4
   8 static unsigned char LIGHT_STIPPLE_BITS[] = {
   9    0x05, 0x0a, 0x05, 0x0a};
  10
  11 #define DARK_STIPPLE_WIDTH 4
  12 #define DARK_STIPPLE_HEIGHT 4
  13 static unsigned char DARK_STIPPLE_BITS[] = {
  14    0x0a, 0x04, 0x0a, 0x01};
  15
  16
  17 static WMColor *createRGBColor(WMScreen *scr, unsigned short red,
  18                                unsigned short green, unsigned short blue);
  19
  20 /*
  21  * TODO: make the color creation code return the same WMColor for the
  22  * same colors.
  23  * make findCloseColor() find the closest color in the RContext pallette
  24  * or in the other colors allocated by WINGs.
  25  */
  26
  27 static WMColor*
  28 findCloseColor(WMScreen *scr, unsigned short red, unsigned short green,
  29                unsigned short blue)
  30 {
  31     WMColor *color;
  32     XColor xcolor;
  33     RColor rcolor;
  34     XGCValues gcv;
  35
  36     rcolor.red = red>>8;
  37     rcolor.green = green>>8;
  38     rcolor.blue = blue>>8;
  39
  40     if (!RGetClosestXColor(scr->rcontext, &rcolor, &xcolor))
  41         return NULL;
  42
  43     if (!XAllocColor(scr->display, scr->colormap, &xcolor))
  44         return NULL;
  45
  46     color = wmalloc(sizeof(WMColor));
  47
  48     color->screen = scr;
  49     color->refCount = 1;
  50     color->color = xcolor;
  51     color->flags.exact = 1;
  52
  53     gcv.foreground = color->color.pixel;
  54     gcv.graphics_exposures = False;
  55     color->gc = XCreateGC(scr->display, scr->rcontext->drawable,
  56                           GCForeground|GCGraphicsExposures, &gcv);
  57
  58     return color;
  59 }
  60
  61
  62
  63 static WMColor*
  64 createRGBColor(WMScreen *scr, unsigned short red, unsigned short green,
  65                unsigned short blue)
  66 {
  67     WMColor *color;
  68     XGCValues gcv;
  69     XColor xcolor;
  70
  71     xcolor.red = red;
  72     xcolor.green = green;
  73     xcolor.blue = blue;
  74     xcolor.flags = DoRed|DoGreen|DoBlue;
  75     if (!XAllocColor(scr->display, scr->colormap, &xcolor))
  76         return NULL;
  77
  78     color = wmalloc(sizeof(WMColor));
  79
  80     color->screen = scr;
  81     color->refCount = 1;
  82     color->color = xcolor;
  83     color->flags.exact = 1;
  84
  85     gcv.foreground = color->color.pixel;
  86     gcv.graphics_exposures = False;
  87     color->gc = XCreateGC(scr->display, scr->rcontext->drawable,
  88                           GCForeground|GCGraphicsExposures, &gcv);
  89
  90     return color;
  91 }
  92
  93
  94
  95 WMColor*
  96 WMCreateRGBColor(WMScreen *scr, unsigned short red, unsigned short green,
  97                  unsigned short blue, Bool exact)
  98 {
  99     WMColor *color = NULL;
 100
 101     if (!exact || !(color=createRGBColor(scr, red, green, blue))) {
 102         color = findCloseColor(scr, red, green, blue);
 103     }
 104     if (!color)
 105         color = WMBlackColor(scr);
 106
 107     return color;
 108 }
 109
 110
 111 WMColor*
 112 WMCreateNamedColor(WMScreen *scr, char *name, Bool exact)
 113 {
 114     WMColor *color;
 115     XColor xcolor;
 116
 117     if (!XParseColor(scr->display, scr->colormap, name, &xcolor))
 118         return NULL;
 119
 120
 121     if (!exact || !(color=createRGBColor(scr, xcolor.red, xcolor.green,
 122                                          xcolor.blue))) {
 123         color = findCloseColor(scr, xcolor.red, xcolor.green, xcolor.blue);
 124     }
 125     return color;
 126 }
 127
 128
 129
 130 WMColor*
 131 WMRetainColor(WMColor *color)
 132 {
 133     assert(color!=NULL);
 134
 135     color->refCount++;
 136
 137     return color;
 138 }
 139
 140
 141 void
 142 WMReleaseColor(WMColor *color)
 143 {
 144     color->refCount--;
 145
 146     if (color->refCount < 1) {
 147         XFreeColors(color->screen->display, color->screen->colormap,
 148                     &(color->color.pixel), 1, 0);
 149         XFreeGC(color->screen->display, color->gc);
 150         free(color);
 151     }
 152 }
 153
 154
 155 void
 156 WMPaintColorSwatch(WMColor *color, Drawable d, int x, int y,
 157                     unsigned int width, unsigned int height)
 158 {
 159     XFillRectangle(color->screen->display, d, color->gc, x, y, width, height);
 160 }
 161
 162
 163 WMPixel
 164 WMColorPixel(WMColor *color)
 165 {
 166     return color->color.pixel;
 167 }
 168
 169
 170 GC
 171 WMColorGC(WMColor *color)
 172 {
 173     return color->gc;
 174 }
 175
 176
 177 void
 178 WMSetColorInGC(WMColor *color, GC gc)
 179 {
 180     XSetForeground(color->screen->display, gc, color->color.pixel);
 181 }
 182
 183
 184
 185 /* "system" colors */
 186 WMColor*
 187 WMWhiteColor(WMScreen *scr)
 188 {
 189     if (!scr->white) {
 190         scr->white = WMCreateRGBColor(scr, 0xffff, 0xffff, 0xffff, True);
 191         if (!scr->white->flags.exact)
 192             wwarning("could not allocate %s color", "white");
 193     }
 194     return WMRetainColor(scr->white);
 195 }
 196
 197
 198
 199 WMColor*
 200 WMBlackColor(WMScreen *scr)
 201 {
 202     if (!scr->black) {
 203         scr->black = WMCreateRGBColor(scr, 0, 0, 0, True);
 204         if (!scr->black->flags.exact)
 205             wwarning("could not allocate %s color", "black");
 206     }
 207     return WMRetainColor(scr->black);
 208 }
 209
 210
 211
 212 WMColor*
 213 WMGrayColor(WMScreen *scr)
 214 {
 215     if (!scr->gray) {
 216         WMColor *color;
 217
 218         if (scr->depth == 1) {
 219             Pixmap stipple;
 220             WMColor *white = WMWhiteColor(scr);
 221             WMColor *black = WMBlackColor(scr);
 222             XGCValues gcv;
 223
 224             stipple = XCreateBitmapFromData(scr->display, W_DRAWABLE(scr),
 225                                         LIGHT_STIPPLE_BITS, LIGHT_STIPPLE_WIDTH,
 226                                         LIGHT_STIPPLE_HEIGHT);
 227
 228             color = createRGBColor(scr, 0xffff, 0xffff, 0xffff);
 229             XFreeGC(scr->display, color->gc);
 230
 231             gcv.foreground = white->color.pixel;
 232             gcv.background = black->color.pixel;
 233             gcv.fill_style = FillStippled;
 234             gcv.stipple = stipple;
 235             color->gc = XCreateGC(scr->display, W_DRAWABLE(scr), GCForeground
 236                                   |GCBackground|GCStipple|GCFillStyle
 237                                   |GCGraphicsExposures, &gcv);
 238
 239             XFreePixmap(scr->display, stipple);
 240             WMReleaseColor(white);
 241             WMReleaseColor(black);
 242         } else {
 243             color = WMCreateRGBColor(scr, 0xaeba, 0xaaaa, 0xaeba, True);
 244             if (!color->flags.exact)
 245                 wwarning("could not allocate %s color", "gray");
 246         }
 247         scr->gray = color;
 248     }
 249     return WMRetainColor(scr->gray);
 250 }
 251
 252
 253
 254 WMColor*
 255 WMDarkGrayColor(WMScreen *scr)
 256 {
 257     if (!scr->darkGray) {
 258         WMColor *color;
 259
 260         if (scr->depth == 1) {
 261             Pixmap stipple;
 262             WMColor *white = WMWhiteColor(scr);
 263             WMColor *black = WMBlackColor(scr);
 264             XGCValues gcv;
 265
 266             stipple = XCreateBitmapFromData(scr->display, W_DRAWABLE(scr),
 267                                           DARK_STIPPLE_BITS, DARK_STIPPLE_WIDTH,
 268                                           DARK_STIPPLE_HEIGHT);
 269
 270             color = createRGBColor(scr, 0, 0, 0);
 271             XFreeGC(scr->display, color->gc);
 272
 273             gcv.foreground = white->color.pixel;
 274             gcv.background = black->color.pixel;
 275             gcv.fill_style = FillStippled;
 276             gcv.stipple = stipple;
 277             color->gc = XCreateGC(scr->display, W_DRAWABLE(scr), GCForeground
 278                                   |GCBackground|GCStipple|GCFillStyle
 279                                   |GCGraphicsExposures, &gcv);
 280
 281             XFreePixmap(scr->display, stipple);
 282             WMReleaseColor(white);
 283             WMReleaseColor(black);
 284         } else {
 285             color = WMCreateRGBColor(scr, 0x5144, 0x5555, 0x5144, True);
 286             if (!color->flags.exact)
 287                 wwarning("could not allocate %s color", "dark gray");
 288         }
 289         scr->darkGray = color;
 290     }
 291     return WMRetainColor(scr->darkGray);
 292 }
 293
 294
 295 unsigned short
 296 WMRedComponentOfColor(WMColor *color)
 297 {
 298     return color->color.red;
 299 }
 300
 301
 302 unsigned short
 303 WMGreenComponentOfColor(WMColor *color)
 304 {
 305     return color->color.green;
 306 }
 307
 308
 309 unsigned short
 310 WMBlueComponentOfColor(WMColor *color)
 311 {
 312     return color->color.blue;
 313 }
 314
 315
 316 char*
 317 WMGetColorRGBDescription(WMColor *color)
 318 {
 319     char *str = wmalloc(32);
 320
 321     sprintf(str, "rgb:%4x/%4x/%4x", color->color.red, color->color.green,
 322             color->color.blue);
 323
 324     return str;
 325 }