Dogcows Code - chaz/openbox/blob - render/gradient.c

   1 #include "render.h"
   2 #include "gradient.h"
   3 #include "color.h"
   4 #include <glib.h>
   5
   6 static void highlight(RrPixel32 *x, RrPixel32 *y, gboolean raised);
   7 static void gradient_solid(RrAppearance *l, int w, int h);
   8 static void gradient_vertical(RrSurface *sf, int w, int h);
   9 static void gradient_horizontal(RrSurface *sf, int w, int h);
  10 static void gradient_diagonal(RrSurface *sf, int w, int h);
  11 static void gradient_crossdiagonal(RrSurface *sf, int w, int h);
  12 static void gradient_pyramid(RrSurface *sf, int inw, int inh);
  13
  14 void RrRender(RrAppearance *a, int w, int h)
  15 {
  16     RrPixel32 *data = a->surface.pixel_data;
  17     RrPixel32 current;
  18     unsigned int r,g,b;
  19     int off, x;
  20
  21     switch (a->surface.grad) {
  22     case RR_SURFACE_SOLID:
  23         gradient_solid(a, w, h);
  24         break;
  25     case RR_SURFACE_VERTICAL:
  26         gradient_vertical(&a->surface, w, h);
  27         break;
  28     case RR_SURFACE_HORIZONTAL:
  29         gradient_horizontal(&a->surface, w, h);
  30         break;
  31     case RR_SURFACE_DIAGONAL:
  32         gradient_diagonal(&a->surface, w, h);
  33         break;
  34     case RR_SURFACE_CROSS_DIAGONAL:
  35         gradient_crossdiagonal(&a->surface, w, h);
  36         break;
  37     case RR_SURFACE_PYRAMID:
  38         gradient_pyramid(&a->surface, w, h);
  39         break;
  40     default:
  41         g_assert_not_reached(); /* unhandled gradient */
  42         return;
  43     }
  44
  45     if (a->surface.relief == RR_RELIEF_FLAT && a->surface.border) {
  46         r = a->surface.border_color->r;
  47         g = a->surface.border_color->g;
  48         b = a->surface.border_color->b;
  49         current = (r << RrDefaultRedOffset)
  50             + (g << RrDefaultGreenOffset)
  51             + (b << RrDefaultBlueOffset);
  52         for (off = 0, x = 0; x < w; ++x, off++) {
  53             *(data + off) = current;
  54             *(data + off + ((h-1) * w)) = current;
  55         }
  56         for (off = 0, x = 0; x < h; ++x, off++) {
  57             *(data + (off * w)) = current;
  58             *(data + (off * w) + w - 1) = current;
  59         }
  60     }
  61
  62     if (a->surface.relief != RR_RELIEF_FLAT) {
  63         if (a->surface.bevel == RR_BEVEL_1) {
  64             for (off = 1, x = 1; x < w - 1; ++x, off++)
  65                 highlight(data + off,
  66                           data + off + (h-1) * w,
  67                           a->surface.relief==RR_RELIEF_RAISED);
  68             for (off = 0, x = 0; x < h; ++x, off++)
  69                 highlight(data + off * w,
  70                           data + off * w + w - 1,
  71                           a->surface.relief==RR_RELIEF_RAISED);
  72         }
  73
  74         if (a->surface.bevel == RR_BEVEL_2) {
  75             for (off = 2, x = 2; x < w - 2; ++x, off++)
  76                 highlight(data + off + w,
  77                           data + off + (h-2) * w,
  78                           a->surface.relief==RR_RELIEF_RAISED);
  79             for (off = 1, x = 1; x < h-1; ++x, off++)
  80                 highlight(data + off * w + 1,
  81                           data + off * w + w - 2,
  82                           a->surface.relief==RR_RELIEF_RAISED);
  83         }
  84     }
  85 }
  86
  87 static void highlight(RrPixel32 *x, RrPixel32 *y, gboolean raised)
  88 {
  89     int r, g, b;
  90
  91     RrPixel32 *up, *down;
  92     if (raised) {
  93         up = x;
  94         down = y;
  95     } else {
  96         up = y;
  97         down = x;
  98     }
  99     r = (*up >> RrDefaultRedOffset) & 0xFF;
 100     r += r >> 1;
 101     g = (*up >> RrDefaultGreenOffset) & 0xFF;
 102     g += g >> 1;
 103     b = (*up >> RrDefaultBlueOffset) & 0xFF;
 104     b += b >> 1;
 105     if (r > 0xFF) r = 0xFF;
 106     if (g > 0xFF) g = 0xFF;
 107     if (b > 0xFF) b = 0xFF;
 108     *up = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset)
 109         + (b << RrDefaultBlueOffset);
 110
 111     r = (*down >> RrDefaultRedOffset) & 0xFF;
 112     r = (r >> 1) + (r >> 2);
 113     g = (*down >> RrDefaultGreenOffset) & 0xFF;
 114     g = (g >> 1) + (g >> 2);
 115     b = (*down >> RrDefaultBlueOffset) & 0xFF;
 116     b = (b >> 1) + (b >> 2);
 117     *down = (r << RrDefaultRedOffset) + (g << RrDefaultGreenOffset)
 118         + (b << RrDefaultBlueOffset);
 119 }
 120
 121 static void create_bevel_colors(RrAppearance *l)
 122 {
 123     int r, g, b;
 124
 125     /* light color */
 126     r = l->surface.primary->r;
 127     r += r >> 1;
 128     g = l->surface.primary->g;
 129     g += g >> 1;
 130     b = l->surface.primary->b;
 131     b += b >> 1;
 132     if (r > 0xFF) r = 0xFF;
 133     if (g > 0xFF) g = 0xFF;
 134     if (b > 0xFF) b = 0xFF;
 135     g_assert(!l->surface.bevel_light);
 136     l->surface.bevel_light = RrColorNew(l->inst, r, g, b);
 137     RrColorAllocateGC(l->surface.bevel_light);
 138
 139     /* dark color */
 140     r = l->surface.primary->r;
 141     r = (r >> 1) + (r >> 2);
 142     g = l->surface.primary->g;
 143     g = (g >> 1) + (g >> 2);
 144     b = l->surface.primary->b;
 145     b = (b >> 1) + (b >> 2);
 146     g_assert(!l->surface.bevel_dark);
 147     l->surface.bevel_dark = RrColorNew(l->inst, r, g, b);
 148     RrColorAllocateGC(l->surface.bevel_dark);
 149 }
 150
 151 static void gradient_solid(RrAppearance *l, int w, int h)
 152 {
 153     RrPixel32 pix;
 154     int i, a, b;
 155     RrSurface *sp = &l->surface;
 156     int left = 0, top = 0, right = w - 1, bottom = h - 1;
 157
 158     if (sp->primary->gc == None)
 159         RrColorAllocateGC(sp->primary);
 160     pix = (sp->primary->r << RrDefaultRedOffset)
 161         + (sp->primary->g << RrDefaultGreenOffset)
 162         + (sp->primary->b << RrDefaultBlueOffset);
 163
 164     for (a = 0; a < w; a++)
 165         for (b = 0; b < h; b++)
 166             sp->pixel_data[a + b * w] = pix;
 167
 168     XFillRectangle(RrDisplay(l->inst), l->pixmap, sp->primary->gc,
 169                    0, 0, w, h);
 170
 171     if (sp->interlaced) {
 172         if (sp->secondary->gc == None)
 173             RrColorAllocateGC(sp->secondary);
 174         for (i = 0; i < h; i += 2)
 175             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->secondary->gc,
 176                       0, i, w, i);
 177     }
 178
 179     switch (sp->relief) {
 180     case RR_RELIEF_RAISED:
 181         if (!sp->bevel_dark)
 182             create_bevel_colors(l);
 183
 184         switch (sp->bevel) {
 185         case RR_BEVEL_1:
 186             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 187                       left, bottom, right, bottom);
 188             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 189                       right, bottom, right, top);
 190
 191             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 192                       left, top, right, top);
 193             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 194                       left, bottom, left, top);
 195             break;
 196         case RR_BEVEL_2:
 197             XDrawLine(RrDisplay(l->inst), l->pixmap,
 198                       sp->bevel_dark->gc,
 199                       left + 1, bottom - 2, right - 2, bottom - 2);
 200             XDrawLine(RrDisplay(l->inst), l->pixmap,
 201                       sp->bevel_dark->gc,
 202                       right - 2, bottom - 2, right - 2, top + 1);
 203
 204             XDrawLine(RrDisplay(l->inst), l->pixmap,
 205                       sp->bevel_light->gc,
 206                       left + 1, top + 1, right - 2, top + 1);
 207             XDrawLine(RrDisplay(l->inst), l->pixmap,
 208                       sp->bevel_light->gc,
 209                       left + 1, bottom - 2, left + 1, top + 1);
 210             break;
 211         default:
 212             g_assert_not_reached(); /* unhandled BevelType */
 213         }
 214         break;
 215     case RR_RELIEF_SUNKEN:
 216         if (!sp->bevel_dark)
 217             create_bevel_colors(l);
 218
 219         switch (sp->bevel) {
 220         case RR_BEVEL_1:
 221             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 222                       left, bottom, right, bottom);
 223             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 224                       right, bottom, right, top);
 225
 226             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 227                       left, top, right, top);
 228             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 229                       left, bottom, left, top);
 230             break;
 231         case RR_BEVEL_2:
 232             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 233                       left + 1, bottom - 2, right - 2, bottom - 2);
 234             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_light->gc,
 235                       right - 2, bottom - 2, right - 2, top + 1);
 236
 237             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 238                       left + 1, top + 1, right - 2, top + 1);
 239             XDrawLine(RrDisplay(l->inst), l->pixmap, sp->bevel_dark->gc,
 240                       left + 1, bottom - 2, left + 1, top + 1);
 241
 242             break;
 243         default:
 244             g_assert_not_reached(); /* unhandled BevelType */
 245         }
 246         break;
 247     case RR_RELIEF_FLAT:
 248         if (sp->border) {
 249             if (sp->border_color->gc == None)
 250                 RrColorAllocateGC(sp->border_color);
 251             XDrawRectangle(RrDisplay(l->inst), l->pixmap, sp->border_color->gc,
 252                            left, top, right, bottom);
 253         }
 254         break;
 255     default:
 256         g_assert_not_reached(); /* unhandled ReliefType */
 257     }
 258 }
 259
 260 /* * * * * * * * * * * * * * GRADIENT MAGIC WOOT * * * * * * * * * * * * * * */
 261
 262 #define VARS(x)                                                     \
 263     unsigned int color##x[3];                                       \
 264     int len##x, cdelta##x[3], error##x[3] = { 0, 0, 0 }, inc##x[3]; \
 265     gboolean bigslope##x[3] /* color slope > 1 */
 266
 267 #define SETUP(x, from, to, w)         \
 268     len##x = w;                       \
 269                                       \
 270     color##x[0] = from->r;            \
 271     color##x[1] = from->g;            \
 272     color##x[2] = from->b;            \
 273                                       \
 274     cdelta##x[0] = to->r - from->r;   \
 275     cdelta##x[1] = to->g - from->g;   \
 276     cdelta##x[2] = to->b - from->b;   \
 277                                       \
 278     if (cdelta##x[0] < 0) {           \
 279         cdelta##x[0] = -cdelta##x[0]; \
 280         inc##x[0] = -1;               \
 281     } else                            \
 282         inc##x[0] = 1;                \
 283     if (cdelta##x[1] < 0) {           \
 284         cdelta##x[1] = -cdelta##x[1]; \
 285         inc##x[1] = -1;               \
 286     } else                            \
 287         inc##x[1] = 1;                \
 288     if (cdelta##x[2] < 0) {           \
 289         cdelta##x[2] = -cdelta##x[2]; \
 290         inc##x[2] = -1;               \
 291     } else                            \
 292         inc##x[2] = 1;                \
 293     bigslope##x[0] = cdelta##x[0] > w;\
 294     bigslope##x[1] = cdelta##x[1] > w;\
 295     bigslope##x[2] = cdelta##x[2] > w
 296
 297 #define COLOR_RR(x, c)                       \
 298     c->r = color##x[0];                      \
 299     c->g = color##x[1];                      \
 300     c->b = color##x[2]
 301
 302 #define COLOR(x)                             \
 303     ((color##x[0] << RrDefaultRedOffset) +   \
 304      (color##x[1] << RrDefaultGreenOffset) + \
 305      (color##x[2] << RrDefaultBlueOffset))
 306
 307 #define INCREMENT(x, i) \
 308     (inc##x[i])
 309
 310 #define NEXT(x)                                           \
 311 {                                                         \
 312     int i;                                                \
 313     for (i = 2; i >= 0; --i) {                            \
 314         if (!cdelta##x[i]) continue;                      \
 315                                                           \
 316         if (!bigslope##x[i]) {                            \
 317             /* Y (color) is dependant on X */             \
 318             error##x[i] += cdelta##x[i];                  \
 319             if ((error##x[i] << 1) >= len##x) {           \
 320                 color##x[i] += INCREMENT(x, i);           \
 321                 error##x[i] -= len##x;                    \
 322             }                                             \
 323         } else {                                          \
 324             /* X is dependant on Y (color) */             \
 325             while (1) {                                   \
 326                 color##x[i] += INCREMENT(x, i);           \
 327                 error##x[i] += len##x;                    \
 328                 if ((error##x[i] << 1) >= cdelta##x[i]) { \
 329                     error##x[i] -= cdelta##x[i];          \
 330                     break;                                \
 331                 }                                         \
 332             }                                             \
 333         }                                                 \
 334     }                                                     \
 335 }
 336
 337 static void gradient_horizontal(RrSurface *sf, int w, int h)
 338 {
 339     int x, y;
 340     RrPixel32 *data = sf->pixel_data, *datav;
 341     RrPixel32 current;
 342
 343     VARS(x);
 344     SETUP(x, sf->primary, sf->secondary, w);
 345
 346     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 347         current = COLOR(x);
 348         datav = data;
 349         for (y = h - 1; y >= 0; --y) {  /* 0 -> h */
 350             *datav = current;
 351             datav += w;
 352         }
 353         ++data;
 354
 355         NEXT(x);
 356     }
 357     current = COLOR(x);
 358     for (y = h - 1; y >= 0; --y)  /* 0 -> h */
 359         *(data + y * w) = current;
 360 }
 361
 362 static void gradient_vertical(RrSurface *sf, int w, int h)
 363 {
 364     int x, y;
 365     RrPixel32 *data = sf->pixel_data;
 366     RrPixel32 current;
 367
 368     VARS(y);
 369     SETUP(y, sf->primary, sf->secondary, h);
 370
 371     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 372         current = COLOR(y);
 373         for (x = w - 1; x >= 0; --x)  /* 0 -> w */
 374             *(data++) = current;
 375
 376         NEXT(y);
 377     }
 378     current = COLOR(y);
 379     for (x = w - 1; x >= 0; --x)  /* 0 -> w */
 380         *(data++) = current;
 381 }
 382
 383
 384 static void gradient_diagonal(RrSurface *sf, int w, int h)
 385 {
 386     int x, y;
 387     RrPixel32 *data = sf->pixel_data;
 388     RrColor left, right;
 389     RrColor extracorner;
 390
 391     VARS(lefty);
 392     VARS(righty);
 393     VARS(x);
 394
 395     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 396     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 397     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 398
 399     SETUP(lefty, sf->primary, (&extracorner), h);
 400     SETUP(righty, (&extracorner), sf->secondary, h);
 401
 402     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 403         COLOR_RR(lefty, (&left));
 404         COLOR_RR(righty, (&right));
 405
 406         SETUP(x, (&left), (&right), w);
 407
 408         for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 409             *(data++) = COLOR(x);
 410
 411             NEXT(x);
 412         }
 413         *(data++) = COLOR(x);
 414
 415         NEXT(lefty);
 416         NEXT(righty);
 417     }
 418     COLOR_RR(lefty, (&left));
 419     COLOR_RR(righty, (&right));
 420
 421     SETUP(x, (&left), (&right), w);
 422
 423     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 424         *(data++) = COLOR(x);
 425
 426         NEXT(x);
 427     }
 428     *data = COLOR(x);
 429 }
 430
 431 static void gradient_crossdiagonal(RrSurface *sf, int w, int h)
 432 {
 433     int x, y;
 434     RrPixel32 *data = sf->pixel_data;
 435     RrColor left, right;
 436     RrColor extracorner;
 437
 438     VARS(lefty);
 439     VARS(righty);
 440     VARS(x);
 441
 442     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 443     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 444     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 445
 446     SETUP(lefty, (&extracorner), sf->secondary, h);
 447     SETUP(righty, sf->primary, (&extracorner), h);
 448
 449     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 450         COLOR_RR(lefty, (&left));
 451         COLOR_RR(righty, (&right));
 452
 453         SETUP(x, (&left), (&right), w);
 454
 455         for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 456             *(data++) = COLOR(x);
 457
 458             NEXT(x);
 459         }
 460         *(data++) = COLOR(x);
 461
 462         NEXT(lefty);
 463         NEXT(righty);
 464     }
 465     COLOR_RR(lefty, (&left));
 466     COLOR_RR(righty, (&right));
 467
 468     SETUP(x, (&left), (&right), w);
 469
 470     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 471         *(data++) = COLOR(x);
 472
 473         NEXT(x);
 474     }
 475     *data = COLOR(x);
 476 }
 477
 478 static void gradient_pyramid(RrSurface *sf, int inw, int inh)
 479 {
 480     int x, y, w = (inw >> 1) + 1, h = (inh >> 1) + 1;
 481     RrPixel32 *data = sf->pixel_data;
 482     RrPixel32 *end = data + inw*inh - 1;
 483     RrPixel32 current;
 484     RrColor left, right;
 485     RrColor extracorner;
 486
 487     VARS(lefty);
 488     VARS(righty);
 489     VARS(x);
 490
 491     extracorner.r = (sf->primary->r + sf->secondary->r) / 2;
 492     extracorner.g = (sf->primary->g + sf->secondary->g) / 2;
 493     extracorner.b = (sf->primary->b + sf->secondary->b) / 2;
 494
 495     SETUP(lefty, (&extracorner), sf->secondary, h);
 496     SETUP(righty, sf->primary, (&extracorner), h);
 497
 498     for (y = h - 1; y > 0; --y) {  /* 0 -> h-1 */
 499         COLOR_RR(lefty, (&left));
 500         COLOR_RR(righty, (&right));
 501
 502         SETUP(x, (&left), (&right), w);
 503
 504         for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 505             current = COLOR(x);
 506             *(data+x) = current;
 507             *(data+inw-x) = current;
 508             *(end-x) = current;
 509             *(end-(inw-x)) = current;
 510
 511             NEXT(x);
 512         }
 513         current = COLOR(x);
 514         *(data+x) = current;
 515         *(data+inw-x) = current;
 516         *(end-x) = current;
 517         *(end-(inw-x)) = current;
 518
 519         data+=inw;
 520         end-=inw;
 521
 522         NEXT(lefty);
 523         NEXT(righty);
 524     }
 525     COLOR_RR(lefty, (&left));
 526     COLOR_RR(righty, (&right));
 527
 528     SETUP(x, (&left), (&right), w);
 529
 530     for (x = w - 1; x > 0; --x) {  /* 0 -> w-1 */
 531         current = COLOR(x);
 532         *(data+x) = current;
 533         *(data+inw-x) = current;
 534         *(end-x) = current;
 535         *(end-(inw-x)) = current;
 536
 537         NEXT(x);
 538     }
 539     current = COLOR(x);
 540     *(data+x) = current;
 541     *(data+inw-x) = current;
 542     *(end-x) = current;
 543     *(end-(inw-x)) = current;
 544 }
 545