WINGs/wcolor.c

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