WINGs/wcolor.c

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