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

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