Dogcows Code - chaz/openbox/blob - src/image.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; -*-
   2
   3 #ifdef    HAVE_CONFIG_H
   4 #  include "../config.h"
   5 #endif // HAVE_CONFIG_H
   6
   7 #ifdef    HAVE_STDIO_H
   8 #  include <stdio.h>
   9 #endif // HAVE_STDIO_H
  10
  11 #include <algorithm>
  12 using std::max;
  13 using std::min;
  14
  15 #include "blackbox.hh"
  16 #include "basedisplay.hh"
  17 #include "gccache.hh"
  18 #include "image.hh"
  19 #include "texture.hh"
  20
  21
  22 BImage::BImage(BImageControl *c, int w, int h) {
  23   control = c;
  24
  25   width = (w > 0) ? w : 1;
  26   height = (h > 0) ? h : 1;
  27
  28   red = new unsigned char[width * height];
  29   green = new unsigned char[width * height];
  30   blue = new unsigned char[width * height];
  31
  32   xtable = ytable = (unsigned int *) 0;
  33
  34   cpc = control->getColorsPerChannel();
  35   cpccpc = cpc * cpc;
  36
  37   control->getColorTables(&red_table, &green_table, &blue_table,
  38                           &red_offset, &green_offset, &blue_offset,
  39                           &red_bits, &green_bits, &blue_bits);
  40
  41   if (control->getVisual()->c_class != TrueColor)
  42     control->getXColorTable(&colors, &ncolors);
  43 }
  44
  45
  46 BImage::~BImage(void) {
  47   delete [] red;
  48   delete [] green;
  49   delete [] blue;
  50 }
  51
  52
  53 Pixmap BImage::render(const BTexture &texture) {
  54   if (texture.texture() & BTexture::Parent_Relative)
  55     return ParentRelative;
  56   else if (texture.texture() & BTexture::Solid)
  57     return render_solid(texture);
  58   else if (texture.texture() & BTexture::Gradient)
  59     return render_gradient(texture);
  60   return None;
  61 }
  62
  63
  64 Pixmap BImage::render_solid(const BTexture &texture) {
  65   Pixmap pixmap = XCreatePixmap(control->getBaseDisplay()->getXDisplay(),
  66                                 control->getDrawable(), width,
  67                                 height, control->getDepth());
  68   if (pixmap == None) {
  69     fprintf(stderr, "BImage::render_solid: error creating pixmap\n");
  70     return None;
  71   }
  72
  73   Display *display = control->getBaseDisplay()->getXDisplay();
  74
  75   BPen pen(texture.color());
  76   BPen penlight(texture.lightColor());
  77   BPen penshadow(texture.shadowColor());
  78
  79   XFillRectangle(display, pixmap, pen.gc(), 0, 0, width, height);
  80
  81   if (texture.texture() & BTexture::Interlaced) {
  82     BPen peninterlace(texture.colorTo());
  83     for (unsigned int i = 0; i < height; i += 2)
  84       XDrawLine(display, pixmap, peninterlace.gc(), 0, i, width, i);
  85   }
  86
  87   int left = 0, top = 0, right = width - 1, bottom = height - 1;
  88
  89   if (texture.texture() & BTexture::Border) {
  90     BPen penborder(texture.borderColor());
  91     XDrawRectangle(display, pixmap, penborder.gc(),
  92                    left, top, right, bottom);
  93   }
  94
  95   if (texture.texture() & BTexture::Bevel1) {
  96     if (texture.texture() & BTexture::Raised) {
  97       XDrawLine(display, pixmap, penshadow.gc(),
  98                 left, bottom, right, bottom);
  99       XDrawLine(display, pixmap, penshadow.gc(),
 100                 right, bottom, right, top);
 101
 102       XDrawLine(display, pixmap, penlight.gc(),
 103                 left, top, right, top);
 104       XDrawLine(display, pixmap, penlight.gc(),
 105                 left, bottom, left, top);
 106     } else if (texture.texture() & BTexture::Sunken) {
 107       XDrawLine(display, pixmap, penlight.gc(),
 108                 left, bottom, right, bottom);
 109       XDrawLine(display, pixmap, penlight.gc(),
 110                 right, bottom, right, top);
 111
 112       XDrawLine(display, pixmap, penshadow.gc(),
 113                 left, top, right, top);
 114       XDrawLine(display, pixmap, penshadow.gc(),
 115                 left, bottom, left, top);
 116     }
 117   } else if (texture.texture() & BTexture::Bevel2) {
 118     if (texture.texture() & BTexture::Raised) {
 119       XDrawLine(display, pixmap, penshadow.gc(),
 120                 left + 1, bottom - 2, right - 2, bottom - 2);
 121       XDrawLine(display, pixmap, penshadow.gc(),
 122                 right - 2, bottom - 2, right - 2, top + 1);
 123
 124       XDrawLine(display, pixmap, penlight.gc(),
 125                 left + 1, top + 1, right - 2, top + 1);
 126       XDrawLine(display, pixmap, penlight.gc(),
 127                 left + 1, bottom - 2, left + 1, top + 1);
 128     } else if (texture.texture() & BTexture::Sunken) {
 129       XDrawLine(display, pixmap, penlight.gc(),
 130                 left + 1, bottom - 2, right - 2, bottom - 2);
 131       XDrawLine(display, pixmap, penlight.gc(),
 132                 right - 2, bottom - 2, right - 2, top + 1);
 133
 134       XDrawLine(display, pixmap, penshadow.gc(),
 135                 left + 1, top + 1, right - 2, top + 1);
 136       XDrawLine(display, pixmap, penshadow.gc(),
 137                 left + 1, bottom - 2, left + 1, top + 1);
 138     }
 139   }
 140
 141   return pixmap;
 142 }
 143
 144
 145 Pixmap BImage::render_gradient(const BTexture &texture) {
 146   bool inverted = False;
 147
 148   interlaced = texture.texture() & BTexture::Interlaced;
 149
 150   if (texture.texture() & BTexture::Sunken) {
 151     from = texture.colorTo();
 152     to = texture.color();
 153
 154     if (! (texture.texture() & BTexture::Invert)) inverted = True;
 155   } else {
 156     from = texture.color();
 157     to = texture.colorTo();
 158
 159     if (texture.texture() & BTexture::Invert) inverted = True;
 160   }
 161
 162   control->getGradientBuffers(width, height, &xtable, &ytable);
 163
 164   if (texture.texture() & BTexture::Diagonal) dgradient();
 165   else if (texture.texture() & BTexture::Elliptic) egradient();
 166   else if (texture.texture() & BTexture::Horizontal) hgradient();
 167   else if (texture.texture() & BTexture::Pyramid) pgradient();
 168   else if (texture.texture() & BTexture::Rectangle) rgradient();
 169   else if (texture.texture() & BTexture::Vertical) vgradient();
 170   else if (texture.texture() & BTexture::CrossDiagonal) cdgradient();
 171   else if (texture.texture() & BTexture::PipeCross) pcgradient();
 172
 173   if (texture.texture() & BTexture::Bevel1) bevel1();
 174   else if (texture.texture() & BTexture::Bevel2) bevel2();
 175
 176   if (texture.texture() & BTexture::Border) border(texture);
 177
 178   if (inverted) invert();
 179
 180   return renderPixmap();
 181
 182 }
 183
 184
 185 static const unsigned char dither4[4][4] = {
 186   {0, 4, 1, 5},
 187   {6, 2, 7, 3},
 188   {1, 5, 0, 4},
 189   {7, 3, 6, 2}
 190 };
 191
 192
 193 /*
 194  * Helper function for TrueColorDither and renderXImage
 195  *
 196  * This handles the proper setting of the image data based on the image depth
 197  * and the machine's byte ordering
 198  */
 199 static inline
 200 void assignPixelData(unsigned int bit_depth, unsigned char **data,
 201                      unsigned long pixel) {
 202   unsigned char *pixel_data = *data;
 203   switch (bit_depth) {
 204   case  8: //  8bpp
 205     *pixel_data++ = pixel;
 206     break;
 207
 208   case 16: // 16bpp LSB
 209     *pixel_data++ = pixel;
 210     *pixel_data++ = pixel >> 8;
 211     break;
 212
 213   case 17: // 16bpp MSB
 214     *pixel_data++ = pixel >> 8;
 215     *pixel_data++ = pixel;
 216     break;
 217
 218   case 24: // 24bpp LSB
 219     *pixel_data++ = pixel;
 220     *pixel_data++ = pixel >> 8;
 221     *pixel_data++ = pixel >> 16;
 222     break;
 223
 224   case 25: // 24bpp MSB
 225     *pixel_data++ = pixel >> 16;
 226     *pixel_data++ = pixel >> 8;
 227     *pixel_data++ = pixel;
 228     break;
 229
 230   case 32: // 32bpp LSB
 231     *pixel_data++ = pixel;
 232     *pixel_data++ = pixel >> 8;
 233     *pixel_data++ = pixel >> 16;
 234     *pixel_data++ = pixel >> 24;
 235     break;
 236
 237   case 33: // 32bpp MSB
 238     *pixel_data++ = pixel >> 24;
 239     *pixel_data++ = pixel >> 16;
 240     *pixel_data++ = pixel >> 8;
 241     *pixel_data++ = pixel;
 242     break;
 243   }
 244   *data = pixel_data; // assign back so we don't lose our place
 245 }
 246
 247
 248 // algorithm: ordered dithering... many many thanks to rasterman
 249 // (raster@rasterman.com) for telling me about this... portions of this
 250 // code is based off of his code in Imlib
 251 void BImage::TrueColorDither(unsigned int bit_depth, int bytes_per_line,
 252                              unsigned char *pixel_data) {
 253   unsigned int x, y, dithx, dithy, r, g, b, er, eg, eb, offset;
 254   unsigned char *ppixel_data = pixel_data;
 255   unsigned long pixel;
 256
 257   for (y = 0, offset = 0; y < height; y++) {
 258     dithy = y & 0x3;
 259
 260     for (x = 0; x < width; x++, offset++) {
 261       dithx = x & 0x3;
 262       r = red[offset];
 263       g = green[offset];
 264       b = blue[offset];
 265
 266       er = r & (red_bits - 1);
 267       eg = g & (green_bits - 1);
 268       eb = b & (blue_bits - 1);
 269
 270       r = red_table[r];
 271       g = green_table[g];
 272       b = blue_table[b];
 273
 274       if ((dither4[dithy][dithx] < er) && (r < red_table[255])) r++;
 275       if ((dither4[dithy][dithx] < eg) && (g < green_table[255])) g++;
 276       if ((dither4[dithy][dithx] < eb) && (b < blue_table[255])) b++;
 277
 278       pixel = (r << red_offset) | (g << green_offset) | (b << blue_offset);
 279       assignPixelData(bit_depth, &pixel_data, pixel);
 280     }
 281
 282     pixel_data = (ppixel_data += bytes_per_line);
 283   }
 284 }
 285
 286 #ifdef ORDEREDPSEUDO
 287 const static unsigned char dither8[8][8] = {
 288   { 0,  32, 8,  40, 2,  34, 10, 42},
 289   { 48, 16, 56, 24, 50, 18, 58, 26},
 290   { 12, 44, 4,  36, 14, 46, 6,  38},
 291   { 60, 28, 52, 20, 62, 30, 54, 22},
 292   { 3,  35, 11, 43, 1,  33, 9,  41},
 293   { 51, 19, 59, 27, 49, 17, 57, 25},
 294   { 15, 47, 7,  39, 13, 45, 5,  37},
 295   { 63, 31, 55, 23, 61, 29, 53, 21}
 296 };
 297
 298 void BImage::OrderedPseudoColorDither(int bytes_per_line,
 299                                       unsigned char *pixel_data) {
 300   unsigned int x, y, dithx, dithy, r, g, b, er, eg, eb, offset;
 301   unsigned long pixel;
 302   unsigned char *ppixel_data = pixel_data;
 303
 304   for (y = 0, offset = 0; y < height; y++) {
 305     dithy = y & 7;
 306
 307     for (x = 0; x < width; x++, offset++) {
 308       dithx = x & 7;
 309
 310       r = red[offset];
 311       g = green[offset];
 312       b = blue[offset];
 313
 314       er = r & (red_bits - 1);
 315       eg = g & (green_bits - 1);
 316       eb = b & (blue_bits - 1);
 317
 318       r = red_table[r];
 319       g = green_table[g];
 320       b = blue_table[b];
 321
 322       if ((dither8[dithy][dithx] < er) && (r < red_table[255])) r++;
 323       if ((dither8[dithy][dithx] < eg) && (g < green_table[255])) g++;
 324       if ((dither8[dithy][dithx] < eb) && (b < blue_table[255])) b++;
 325
 326       pixel = (r * cpccpc) + (g * cpc) + b;
 327       *(pixel_data++) = colors[pixel].pixel;
 328     }
 329
 330     pixel_data = (ppixel_data += bytes_per_line);
 331   }
 332 }
 333 #endif
 334
 335 void BImage::PseudoColorDither(int bytes_per_line, unsigned char *pixel_data) {
 336   short *terr,
 337     *rerr = new short[width + 2],
 338     *gerr = new short[width + 2],
 339     *berr = new short[width + 2],
 340     *nrerr = new short[width + 2],
 341     *ngerr = new short[width + 2],
 342     *nberr = new short[width + 2];
 343
 344   int rr, gg, bb, rer, ger, ber;
 345   int dd = 255 / control->getColorsPerChannel();
 346   unsigned int x, y, r, g, b, offset;
 347   unsigned long pixel;
 348   unsigned char *ppixel_data = pixel_data;
 349
 350   for (x = 0; x < width; x++) {
 351     *(rerr + x) = *(red + x);
 352     *(gerr + x) = *(green + x);
 353     *(berr + x) = *(blue + x);
 354   }
 355
 356   *(rerr + x) = *(gerr + x) = *(berr + x) = 0;
 357
 358   for (y = 0, offset = 0; y < height; y++) {
 359     if (y < (height - 1)) {
 360       int i = offset + width;
 361       for (x = 0; x < width; x++, i++) {
 362         *(nrerr + x) = *(red + i);
 363         *(ngerr + x) = *(green + i);
 364         *(nberr + x) = *(blue + i);
 365       }
 366
 367       *(nrerr + x) = *(red + (--i));
 368       *(ngerr + x) = *(green + i);
 369       *(nberr + x) = *(blue + i);
 370     }
 371
 372     for (x = 0; x < width; x++) {
 373       rr = rerr[x];
 374       gg = gerr[x];
 375       bb = berr[x];
 376
 377       if (rr > 255) rr = 255; else if (rr < 0) rr = 0;
 378       if (gg > 255) gg = 255; else if (gg < 0) gg = 0;
 379       if (bb > 255) bb = 255; else if (bb < 0) bb = 0;
 380
 381       r = red_table[rr];
 382       g = green_table[gg];
 383       b = blue_table[bb];
 384
 385       rer = rerr[x] - r*dd;
 386       ger = gerr[x] - g*dd;
 387       ber = berr[x] - b*dd;
 388
 389       pixel = (r * cpccpc) + (g * cpc) + b;
 390       *pixel_data++ = colors[pixel].pixel;
 391
 392       r = rer >> 1;
 393       g = ger >> 1;
 394       b = ber >> 1;
 395       rerr[x+1] += r;
 396       gerr[x+1] += g;
 397       berr[x+1] += b;
 398       nrerr[x] += r;
 399       ngerr[x] += g;
 400       nberr[x] += b;
 401     }
 402
 403     offset += width;
 404
 405     pixel_data = (ppixel_data += bytes_per_line);
 406
 407     terr = rerr;
 408     rerr = nrerr;
 409     nrerr = terr;
 410
 411     terr = gerr;
 412     gerr = ngerr;
 413     ngerr = terr;
 414
 415     terr = berr;
 416     berr = nberr;
 417     nberr = terr;
 418   }
 419
 420   delete [] rerr;
 421   delete [] gerr;
 422   delete [] berr;
 423   delete [] nrerr;
 424   delete [] ngerr;
 425   delete [] nberr;
 426 }
 427
 428 XImage *BImage::renderXImage(void) {
 429   XImage *image =
 430     XCreateImage(control->getBaseDisplay()->getXDisplay(),
 431                  control->getVisual(), control->getDepth(), ZPixmap, 0, 0,
 432                  width, height, 32, 0);
 433
 434   if (! image) {
 435     fprintf(stderr, "BImage::renderXImage: error creating XImage\n");
 436     return (XImage *) 0;
 437   }
 438
 439   // insurance policy
 440   image->data = (char *) 0;
 441
 442   unsigned char *d = new unsigned char[image->bytes_per_line * (height + 1)];
 443
 444   unsigned int o = image->bits_per_pixel +
 445     ((image->byte_order == MSBFirst) ? 1 : 0);
 446
 447   bool unsupported = False;
 448
 449   if (control->doDither() && width > 1 && height > 1) {
 450     switch (control->getVisual()->c_class) {
 451     case TrueColor:
 452       TrueColorDither(o, image->bytes_per_line, d);
 453       break;
 454
 455     case StaticColor:
 456     case PseudoColor: {
 457 #ifdef ORDEREDPSEUDO
 458       OrderedPseudoColorDither(image->bytes_per_line, d);
 459 #else
 460       PseudoColorDither(image->bytes_per_line, d);
 461 #endif
 462       break;
 463     }
 464
 465     default:
 466       unsupported = True;
 467     }
 468   } else {
 469     unsigned int x, y, r, g, b, offset;
 470     unsigned char *pixel_data = d, *ppixel_data = d;
 471     unsigned long pixel;
 472
 473     switch (control->getVisual()->c_class) {
 474     case StaticColor:
 475     case PseudoColor:
 476       for (y = 0, offset = 0; y < height; ++y) {
 477         for (x = 0; x < width; ++x, ++offset) {
 478           r = red_table[red[offset]];
 479           g = green_table[green[offset]];
 480           b = blue_table[blue[offset]];
 481
 482           pixel = (r * cpccpc) + (g * cpc) + b;
 483           *pixel_data++ = colors[pixel].pixel;
 484         }
 485
 486         pixel_data = (ppixel_data += image->bytes_per_line);
 487       }
 488
 489       break;
 490
 491     case TrueColor:
 492       for (y = 0, offset = 0; y < height; y++) {
 493         for (x = 0; x < width; x++, offset++) {
 494           r = red_table[red[offset]];
 495           g = green_table[green[offset]];
 496           b = blue_table[blue[offset]];
 497
 498           pixel = (r << red_offset) | (g << green_offset) | (b << blue_offset);
 499           assignPixelData(o, &pixel_data, pixel);
 500         }
 501
 502         pixel_data = (ppixel_data += image->bytes_per_line);
 503       }
 504
 505       break;
 506
 507     case StaticGray:
 508     case GrayScale:
 509       for (y = 0, offset = 0; y < height; y++) {
 510         for (x = 0; x < width; x++, offset++) {
 511           r = *(red_table + *(red + offset));
 512           g = *(green_table + *(green + offset));
 513           b = *(blue_table + *(blue + offset));
 514
 515           g = ((r * 30) + (g * 59) + (b * 11)) / 100;
 516           *pixel_data++ = colors[g].pixel;
 517         }
 518
 519         pixel_data = (ppixel_data += image->bytes_per_line);
 520       }
 521
 522       break;
 523
 524     default:
 525       unsupported = True;
 526     }
 527   }
 528
 529   if (unsupported) {
 530     fprintf(stderr, "BImage::renderXImage: unsupported visual\n");
 531     delete [] d;
 532     XDestroyImage(image);
 533     return (XImage *) 0;
 534   }
 535
 536   image->data = (char *) d;
 537
 538   return image;
 539 }
 540
 541
 542 Pixmap BImage::renderPixmap(void) {
 543   Pixmap pixmap =
 544     XCreatePixmap(control->getBaseDisplay()->getXDisplay(),
 545                   control->getDrawable(), width, height, control->getDepth());
 546
 547   if (pixmap == None) {
 548     fprintf(stderr, "BImage::renderPixmap: error creating pixmap\n");
 549     return None;
 550   }
 551
 552   XImage *image = renderXImage();
 553
 554   if (! image) {
 555     XFreePixmap(control->getBaseDisplay()->getXDisplay(), pixmap);
 556     return None;
 557   }
 558
 559   if (! image->data) {
 560     XDestroyImage(image);
 561     XFreePixmap(control->getBaseDisplay()->getXDisplay(), pixmap);
 562     return None;
 563   }
 564
 565   XPutImage(control->getBaseDisplay()->getXDisplay(), pixmap,
 566             DefaultGC(control->getBaseDisplay()->getXDisplay(),
 567                       control->getScreenInfo()->getScreenNumber()),
 568             image, 0, 0, 0, 0, width, height);
 569
 570   if (image->data) {
 571     delete [] image->data;
 572     image->data = NULL;
 573   }
 574
 575   XDestroyImage(image);
 576
 577   return pixmap;
 578 }
 579
 580
 581 void BImage::bevel1(void) {
 582   if (width > 2 && height > 2) {
 583     unsigned char *pr = red, *pg = green, *pb = blue;
 584
 585     register unsigned char r, g, b, rr ,gg ,bb;
 586     register unsigned int w = width, h = height - 1, wh = w * h;
 587
 588     while (--w) {
 589       r = *pr;
 590       rr = r + (r >> 1);
 591       if (rr < r) rr = ~0;
 592       g = *pg;
 593       gg = g + (g >> 1);
 594       if (gg < g) gg = ~0;
 595       b = *pb;
 596       bb = b + (b >> 1);
 597       if (bb < b) bb = ~0;
 598
 599       *pr = rr;
 600       *pg = gg;
 601       *pb = bb;
 602
 603       r = *(pr + wh);
 604       rr = (r >> 2) + (r >> 1);
 605       if (rr > r) rr = 0;
 606       g = *(pg + wh);
 607       gg = (g >> 2) + (g >> 1);
 608       if (gg > g) gg = 0;
 609       b = *(pb + wh);
 610       bb = (b >> 2) + (b >> 1);
 611       if (bb > b) bb = 0;
 612
 613       *((pr++) + wh) = rr;
 614       *((pg++) + wh) = gg;
 615       *((pb++) + wh) = bb;
 616     }
 617
 618     r = *pr;
 619     rr = r + (r >> 1);
 620     if (rr < r) rr = ~0;
 621     g = *pg;
 622     gg = g + (g >> 1);
 623     if (gg < g) gg = ~0;
 624     b = *pb;
 625     bb = b + (b >> 1);
 626     if (bb < b) bb = ~0;
 627
 628     *pr = rr;
 629     *pg = gg;
 630     *pb = bb;
 631
 632     r = *(pr + wh);
 633     rr = (r >> 2) + (r >> 1);
 634     if (rr > r) rr = 0;
 635     g = *(pg + wh);
 636     gg = (g >> 2) + (g >> 1);
 637     if (gg > g) gg = 0;
 638     b = *(pb + wh);
 639     bb = (b >> 2) + (b >> 1);
 640     if (bb > b) bb = 0;
 641
 642     *(pr + wh) = rr;
 643     *(pg + wh) = gg;
 644     *(pb + wh) = bb;
 645
 646     pr = red + width;
 647     pg = green + width;
 648     pb = blue + width;
 649
 650     while (--h) {
 651       r = *pr;
 652       rr = r + (r >> 1);
 653       if (rr < r) rr = ~0;
 654       g = *pg;
 655       gg = g + (g >> 1);
 656       if (gg < g) gg = ~0;
 657       b = *pb;
 658       bb = b + (b >> 1);
 659       if (bb < b) bb = ~0;
 660
 661       *pr = rr;
 662       *pg = gg;
 663       *pb = bb;
 664
 665       pr += width - 1;
 666       pg += width - 1;
 667       pb += width - 1;
 668
 669       r = *pr;
 670       rr = (r >> 2) + (r >> 1);
 671       if (rr > r) rr = 0;
 672       g = *pg;
 673       gg = (g >> 2) + (g >> 1);
 674       if (gg > g) gg = 0;
 675       b = *pb;
 676       bb = (b >> 2) + (b >> 1);
 677       if (bb > b) bb = 0;
 678
 679       *(pr++) = rr;
 680       *(pg++) = gg;
 681       *(pb++) = bb;
 682     }
 683
 684     r = *pr;
 685     rr = r + (r >> 1);
 686     if (rr < r) rr = ~0;
 687     g = *pg;
 688     gg = g + (g >> 1);
 689     if (gg < g) gg = ~0;
 690     b = *pb;
 691     bb = b + (b >> 1);
 692     if (bb < b) bb = ~0;
 693
 694     *pr = rr;
 695     *pg = gg;
 696     *pb = bb;
 697
 698     pr += width - 1;
 699     pg += width - 1;
 700     pb += width - 1;
 701
 702     r = *pr;
 703     rr = (r >> 2) + (r >> 1);
 704     if (rr > r) rr = 0;
 705     g = *pg;
 706     gg = (g >> 2) + (g >> 1);
 707     if (gg > g) gg = 0;
 708     b = *pb;
 709     bb = (b >> 2) + (b >> 1);
 710     if (bb > b) bb = 0;
 711
 712     *pr = rr;
 713     *pg = gg;
 714     *pb = bb;
 715   }
 716 }
 717
 718
 719 void BImage::bevel2(void) {
 720   if (width > 4 && height > 4) {
 721     unsigned char r, g, b, rr ,gg ,bb, *pr = red + width + 1,
 722       *pg = green + width + 1, *pb = blue + width + 1;
 723     unsigned int w = width - 2, h = height - 1, wh = width * (height - 3);
 724
 725     while (--w) {
 726       r = *pr;
 727       rr = r + (r >> 1);
 728       if (rr < r) rr = ~0;
 729       g = *pg;
 730       gg = g + (g >> 1);
 731       if (gg < g) gg = ~0;
 732       b = *pb;
 733       bb = b + (b >> 1);
 734       if (bb < b) bb = ~0;
 735
 736       *pr = rr;
 737       *pg = gg;
 738       *pb = bb;
 739
 740       r = *(pr + wh);
 741       rr = (r >> 2) + (r >> 1);
 742       if (rr > r) rr = 0;
 743       g = *(pg + wh);
 744       gg = (g >> 2) + (g >> 1);
 745       if (gg > g) gg = 0;
 746       b = *(pb + wh);
 747       bb = (b >> 2) + (b >> 1);
 748       if (bb > b) bb = 0;
 749
 750       *((pr++) + wh) = rr;
 751       *((pg++) + wh) = gg;
 752       *((pb++) + wh) = bb;
 753     }
 754
 755     pr = red + width;
 756     pg = green + width;
 757     pb = blue + width;
 758
 759     while (--h) {
 760       r = *pr;
 761       rr = r + (r >> 1);
 762       if (rr < r) rr = ~0;
 763       g = *pg;
 764       gg = g + (g >> 1);
 765       if (gg < g) gg = ~0;
 766       b = *pb;
 767       bb = b + (b >> 1);
 768       if (bb < b) bb = ~0;
 769
 770       *(++pr) = rr;
 771       *(++pg) = gg;
 772       *(++pb) = bb;
 773
 774       pr += width - 3;
 775       pg += width - 3;
 776       pb += width - 3;
 777
 778       r = *pr;
 779       rr = (r >> 2) + (r >> 1);
 780       if (rr > r) rr = 0;
 781       g = *pg;
 782       gg = (g >> 2) + (g >> 1);
 783       if (gg > g) gg = 0;
 784       b = *pb;
 785       bb = (b >> 2) + (b >> 1);
 786       if (bb > b) bb = 0;
 787
 788       *(pr++) = rr;
 789       *(pg++) = gg;
 790       *(pb++) = bb;
 791
 792       pr++; pg++; pb++;
 793     }
 794   }
 795 }
 796
 797
 798 void BImage::border(const BTexture &texture) {
 799   if (width < 2 || height < 2) return;
 800
 801   register unsigned int i;
 802   int r = texture.borderColor().red(),
 803     g = texture.borderColor().green(),
 804     b = texture.borderColor().blue();
 805
 806   unsigned char *pr, *pg, *pb;
 807
 808   // top line
 809   pr = red;
 810   pg = green;
 811   pb = blue;
 812   for (i = 0; i < width; ++i) {
 813     *pr++ = r;
 814     *pg++ = g;
 815     *pb++ = b;
 816   }
 817
 818   if (height > 2) {
 819     // left and right lines (pr,pg,pb are already lined up)
 820     for (i = 1; i < height - 1; ++i) {
 821       *pr = r;
 822       *pg = g;
 823       *pb = b;
 824       pr += width - 1;
 825       pg += width - 1;
 826       pb += width - 1;
 827       *pr++ = r;
 828       *pg++ = g;
 829       *pb++ = b;
 830     }
 831   }
 832
 833   // bottom line (pr,pg,pb are already lined up)
 834   for (i = 0; i < width; ++i) {
 835     *pr++ = r;
 836     *pg++ = g;
 837     *pb++ = b;
 838   }
 839 }
 840
 841
 842 void BImage::invert(void) {
 843   register unsigned int i, j, wh = (width * height) - 1;
 844   unsigned char tmp;
 845
 846   for (i = 0, j = wh; j > i; j--, i++) {
 847     tmp = *(red + j);
 848     *(red + j) = *(red + i);
 849     *(red + i) = tmp;
 850
 851     tmp = *(green + j);
 852     *(green + j) = *(green + i);
 853     *(green + i) = tmp;
 854
 855     tmp = *(blue + j);
 856     *(blue + j) = *(blue + i);
 857     *(blue + i) = tmp;
 858   }
 859 }
 860
 861
 862 void BImage::dgradient(void) {
 863   // diagonal gradient code was written by Mike Cole <mike@mydot.com>
 864   // modified for interlacing by Brad Hughes
 865
 866   float drx, dgx, dbx, dry, dgy, dby, yr = 0.0, yg = 0.0, yb = 0.0,
 867     xr = (float) from.red(),
 868     xg = (float) from.green(),
 869     xb = (float) from.blue();
 870   unsigned char *pr = red, *pg = green, *pb = blue;
 871   unsigned int w = width * 2, h = height * 2, *xt = xtable, *yt = ytable;
 872
 873   register unsigned int x, y;
 874
 875   dry = drx = (float) (to.red() - from.red());
 876   dgy = dgx = (float) (to.green() - from.green());
 877   dby = dbx = (float) (to.blue() - from.blue());
 878
 879   // Create X table
 880   drx /= w;
 881   dgx /= w;
 882   dbx /= w;
 883
 884   for (x = 0; x < width; x++) {
 885     *(xt++) = (unsigned char) (xr);
 886     *(xt++) = (unsigned char) (xg);
 887     *(xt++) = (unsigned char) (xb);
 888
 889     xr += drx;
 890     xg += dgx;
 891     xb += dbx;
 892   }
 893
 894   // Create Y table
 895   dry /= h;
 896   dgy /= h;
 897   dby /= h;
 898
 899   for (y = 0; y < height; y++) {
 900     *(yt++) = ((unsigned char) yr);
 901     *(yt++) = ((unsigned char) yg);
 902     *(yt++) = ((unsigned char) yb);
 903
 904     yr += dry;
 905     yg += dgy;
 906     yb += dby;
 907   }
 908
 909   // Combine tables to create gradient
 910
 911   if (! interlaced) {
 912     // normal dgradient
 913     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
 914       for (xt = xtable, x = 0; x < width; x++) {
 915         *(pr++) = *(xt++) + *(yt);
 916         *(pg++) = *(xt++) + *(yt + 1);
 917         *(pb++) = *(xt++) + *(yt + 2);
 918       }
 919     }
 920   } else {
 921     // faked interlacing effect
 922     unsigned char channel, channel2;
 923
 924     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
 925       for (xt = xtable, x = 0; x < width; x++) {
 926         if (y & 1) {
 927           channel = *(xt++) + *(yt);
 928           channel2 = (channel >> 1) + (channel >> 2);
 929           if (channel2 > channel) channel2 = 0;
 930           *(pr++) = channel2;
 931
 932           channel = *(xt++) + *(yt + 1);
 933           channel2 = (channel >> 1) + (channel >> 2);
 934           if (channel2 > channel) channel2 = 0;
 935           *(pg++) = channel2;
 936
 937           channel = *(xt++) + *(yt + 2);
 938           channel2 = (channel >> 1) + (channel >> 2);
 939           if (channel2 > channel) channel2 = 0;
 940           *(pb++) = channel2;
 941         } else {
 942           channel = *(xt++) + *(yt);
 943           channel2 = channel + (channel >> 3);
 944           if (channel2 < channel) channel2 = ~0;
 945           *(pr++) = channel2;
 946
 947           channel = *(xt++) + *(yt + 1);
 948           channel2 = channel + (channel >> 3);
 949           if (channel2 < channel) channel2 = ~0;
 950           *(pg++) = channel2;
 951
 952           channel = *(xt++) + *(yt + 2);
 953           channel2 = channel + (channel >> 3);
 954           if (channel2 < channel) channel2 = ~0;
 955           *(pb++) = channel2;
 956         }
 957       }
 958     }
 959   }
 960 }
 961
 962
 963 void BImage::hgradient(void) {
 964   float drx, dgx, dbx,
 965     xr = (float) from.red(),
 966     xg = (float) from.green(),
 967     xb = (float) from.blue();
 968   unsigned char *pr = red, *pg = green, *pb = blue;
 969
 970   register unsigned int x, y;
 971
 972   drx = (float) (to.red() - from.red());
 973   dgx = (float) (to.green() - from.green());
 974   dbx = (float) (to.blue() - from.blue());
 975
 976   drx /= width;
 977   dgx /= width;
 978   dbx /= width;
 979
 980   if (interlaced && height > 2) {
 981     // faked interlacing effect
 982     unsigned char channel, channel2;
 983
 984     for (x = 0; x < width; x++, pr++, pg++, pb++) {
 985       channel = (unsigned char) xr;
 986       channel2 = (channel >> 1) + (channel >> 2);
 987       if (channel2 > channel) channel2 = 0;
 988       *pr = channel2;
 989
 990       channel = (unsigned char) xg;
 991       channel2 = (channel >> 1) + (channel >> 2);
 992       if (channel2 > channel) channel2 = 0;
 993       *pg = channel2;
 994
 995       channel = (unsigned char) xb;
 996       channel2 = (channel >> 1) + (channel >> 2);
 997       if (channel2 > channel) channel2 = 0;
 998       *pb = channel2;
 999
1000
1001       channel = (unsigned char) xr;
1002       channel2 = channel + (channel >> 3);
1003       if (channel2 < channel) channel2 = ~0;
1004       *(pr + width) = channel2;
1005
1006       channel = (unsigned char) xg;
1007       channel2 = channel + (channel >> 3);
1008       if (channel2 < channel) channel2 = ~0;
1009       *(pg + width) = channel2;
1010
1011       channel = (unsigned char) xb;
1012       channel2 = channel + (channel >> 3);
1013       if (channel2 < channel) channel2 = ~0;
1014       *(pb + width) = channel2;
1015
1016       xr += drx;
1017       xg += dgx;
1018       xb += dbx;
1019     }
1020
1021     pr += width;
1022     pg += width;
1023     pb += width;
1024
1025     int offset;
1026
1027     for (y = 2; y < height; y++, pr += width, pg += width, pb += width) {
1028       if (y & 1) offset = width; else offset = 0;
1029
1030       memcpy(pr, (red + offset), width);
1031       memcpy(pg, (green + offset), width);
1032       memcpy(pb, (blue + offset), width);
1033     }
1034   } else {
1035     // normal hgradient
1036     for (x = 0; x < width; x++) {
1037       *(pr++) = (unsigned char) (xr);
1038       *(pg++) = (unsigned char) (xg);
1039       *(pb++) = (unsigned char) (xb);
1040
1041       xr += drx;
1042       xg += dgx;
1043       xb += dbx;
1044     }
1045
1046     for (y = 1; y < height; y++, pr += width, pg += width, pb += width) {
1047       memcpy(pr, red, width);
1048       memcpy(pg, green, width);
1049       memcpy(pb, blue, width);
1050     }
1051   }
1052 }
1053
1054
1055 void BImage::vgradient(void) {
1056   float dry, dgy, dby,
1057     yr = (float) from.red(),
1058     yg = (float) from.green(),
1059     yb = (float) from.blue();
1060   unsigned char *pr = red, *pg = green, *pb = blue;
1061
1062   register unsigned int y;
1063
1064   dry = (float) (to.red() - from.red());
1065   dgy = (float) (to.green() - from.green());
1066   dby = (float) (to.blue() - from.blue());
1067
1068   dry /= height;
1069   dgy /= height;
1070   dby /= height;
1071
1072   if (interlaced) {
1073     // faked interlacing effect
1074     unsigned char channel, channel2;
1075
1076     for (y = 0; y < height; y++, pr += width, pg += width, pb += width) {
1077       if (y & 1) {
1078         channel = (unsigned char) yr;
1079         channel2 = (channel >> 1) + (channel >> 2);
1080         if (channel2 > channel) channel2 = 0;
1081         memset(pr, channel2, width);
1082
1083         channel = (unsigned char) yg;
1084         channel2 = (channel >> 1) + (channel >> 2);
1085         if (channel2 > channel) channel2 = 0;
1086         memset(pg, channel2, width);
1087
1088         channel = (unsigned char) yb;
1089         channel2 = (channel >> 1) + (channel >> 2);
1090         if (channel2 > channel) channel2 = 0;
1091         memset(pb, channel2, width);
1092       } else {
1093         channel = (unsigned char) yr;
1094         channel2 = channel + (channel >> 3);
1095         if (channel2 < channel) channel2 = ~0;
1096         memset(pr, channel2, width);
1097
1098         channel = (unsigned char) yg;
1099         channel2 = channel + (channel >> 3);
1100         if (channel2 < channel) channel2 = ~0;
1101         memset(pg, channel2, width);
1102
1103         channel = (unsigned char) yb;
1104         channel2 = channel + (channel >> 3);
1105         if (channel2 < channel) channel2 = ~0;
1106         memset(pb, channel2, width);
1107       }
1108
1109       yr += dry;
1110       yg += dgy;
1111       yb += dby;
1112     }
1113   } else {
1114     // normal vgradient
1115     for (y = 0; y < height; y++, pr += width, pg += width, pb += width) {
1116       memset(pr, (unsigned char) yr, width);
1117       memset(pg, (unsigned char) yg, width);
1118       memset(pb, (unsigned char) yb, width);
1119
1120       yr += dry;
1121       yg += dgy;
1122       yb += dby;
1123     }
1124   }
1125 }
1126
1127
1128 void BImage::pgradient(void) {
1129   // pyramid gradient -  based on original dgradient, written by
1130   // Mosfet (mosfet@kde.org)
1131   // adapted from kde sources for Blackbox by Brad Hughes
1132
1133   float yr, yg, yb, drx, dgx, dbx, dry, dgy, dby,
1134     xr, xg, xb;
1135   int rsign, gsign, bsign;
1136   unsigned char *pr = red, *pg = green, *pb = blue;
1137   unsigned int tr = to.red(), tg = to.green(), tb = to.blue(),
1138     *xt = xtable, *yt = ytable;
1139
1140   register unsigned int x, y;
1141
1142   dry = drx = (float) (to.red() - from.red());
1143   dgy = dgx = (float) (to.green() - from.green());
1144   dby = dbx = (float) (to.blue() - from.blue());
1145
1146   rsign = (drx < 0) ? -1 : 1;
1147   gsign = (dgx < 0) ? -1 : 1;
1148   bsign = (dbx < 0) ? -1 : 1;
1149
1150   xr = yr = (drx / 2);
1151   xg = yg = (dgx / 2);
1152   xb = yb = (dbx / 2);
1153
1154   // Create X table
1155   drx /= width;
1156   dgx /= width;
1157   dbx /= width;
1158
1159   for (x = 0; x < width; x++) {
1160     *(xt++) = (unsigned char) ((xr < 0) ? -xr : xr);
1161     *(xt++) = (unsigned char) ((xg < 0) ? -xg : xg);
1162     *(xt++) = (unsigned char) ((xb < 0) ? -xb : xb);
1163
1164     xr -= drx;
1165     xg -= dgx;
1166     xb -= dbx;
1167   }
1168
1169   // Create Y table
1170   dry /= height;
1171   dgy /= height;
1172   dby /= height;
1173
1174   for (y = 0; y < height; y++) {
1175     *(yt++) = ((unsigned char) ((yr < 0) ? -yr : yr));
1176     *(yt++) = ((unsigned char) ((yg < 0) ? -yg : yg));
1177     *(yt++) = ((unsigned char) ((yb < 0) ? -yb : yb));
1178
1179     yr -= dry;
1180     yg -= dgy;
1181     yb -= dby;
1182   }
1183
1184   // Combine tables to create gradient
1185
1186   if (! interlaced) {
1187     // normal pgradient
1188     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1189       for (xt = xtable, x = 0; x < width; x++) {
1190         *(pr++) = (unsigned char) (tr - (rsign * (*(xt++) + *(yt))));
1191         *(pg++) = (unsigned char) (tg - (gsign * (*(xt++) + *(yt + 1))));
1192         *(pb++) = (unsigned char) (tb - (bsign * (*(xt++) + *(yt + 2))));
1193       }
1194     }
1195   } else {
1196     // faked interlacing effect
1197     unsigned char channel, channel2;
1198
1199     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1200       for (xt = xtable, x = 0; x < width; x++) {
1201         if (y & 1) {
1202           channel = (unsigned char) (tr - (rsign * (*(xt++) + *(yt))));
1203           channel2 = (channel >> 1) + (channel >> 2);
1204           if (channel2 > channel) channel2 = 0;
1205           *(pr++) = channel2;
1206
1207           channel = (unsigned char) (tg - (gsign * (*(xt++) + *(yt + 1))));
1208           channel2 = (channel >> 1) + (channel >> 2);
1209           if (channel2 > channel) channel2 = 0;
1210           *(pg++) = channel2;
1211
1212           channel = (unsigned char) (tb - (bsign * (*(xt++) + *(yt + 2))));
1213           channel2 = (channel >> 1) + (channel >> 2);
1214           if (channel2 > channel) channel2 = 0;
1215           *(pb++) = channel2;
1216         } else {
1217           channel = (unsigned char) (tr - (rsign * (*(xt++) + *(yt))));
1218           channel2 = channel + (channel >> 3);
1219           if (channel2 < channel) channel2 = ~0;
1220           *(pr++) = channel2;
1221
1222           channel = (unsigned char) (tg - (gsign * (*(xt++) + *(yt + 1))));
1223           channel2 = channel + (channel >> 3);
1224           if (channel2 < channel) channel2 = ~0;
1225           *(pg++) = channel2;
1226
1227           channel = (unsigned char) (tb - (bsign * (*(xt++) + *(yt + 2))));
1228           channel2 = channel + (channel >> 3);
1229           if (channel2 < channel) channel2 = ~0;
1230           *(pb++) = channel2;
1231         }
1232       }
1233     }
1234   }
1235 }
1236
1237
1238 void BImage::rgradient(void) {
1239   // rectangle gradient -  based on original dgradient, written by
1240   // Mosfet (mosfet@kde.org)
1241   // adapted from kde sources for Blackbox by Brad Hughes
1242
1243   float drx, dgx, dbx, dry, dgy, dby, xr, xg, xb, yr, yg, yb;
1244   int rsign, gsign, bsign;
1245   unsigned char *pr = red, *pg = green, *pb = blue;
1246   unsigned int tr = to.red(), tg = to.green(), tb = to.blue(),
1247     *xt = xtable, *yt = ytable;
1248
1249   register unsigned int x, y;
1250
1251   dry = drx = (float) (to.red() - from.red());
1252   dgy = dgx = (float) (to.green() - from.green());
1253   dby = dbx = (float) (to.blue() - from.blue());
1254
1255   rsign = (drx < 0) ? -2 : 2;
1256   gsign = (dgx < 0) ? -2 : 2;
1257   bsign = (dbx < 0) ? -2 : 2;
1258
1259   xr = yr = (drx / 2);
1260   xg = yg = (dgx / 2);
1261   xb = yb = (dbx / 2);
1262
1263   // Create X table
1264   drx /= width;
1265   dgx /= width;
1266   dbx /= width;
1267
1268   for (x = 0; x < width; x++) {
1269     *(xt++) = (unsigned char) ((xr < 0) ? -xr : xr);
1270     *(xt++) = (unsigned char) ((xg < 0) ? -xg : xg);
1271     *(xt++) = (unsigned char) ((xb < 0) ? -xb : xb);
1272
1273     xr -= drx;
1274     xg -= dgx;
1275     xb -= dbx;
1276   }
1277
1278   // Create Y table
1279   dry /= height;
1280   dgy /= height;
1281   dby /= height;
1282
1283   for (y = 0; y < height; y++) {
1284     *(yt++) = ((unsigned char) ((yr < 0) ? -yr : yr));
1285     *(yt++) = ((unsigned char) ((yg < 0) ? -yg : yg));
1286     *(yt++) = ((unsigned char) ((yb < 0) ? -yb : yb));
1287
1288     yr -= dry;
1289     yg -= dgy;
1290     yb -= dby;
1291   }
1292
1293   // Combine tables to create gradient
1294
1295   if (! interlaced) {
1296     // normal rgradient
1297     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1298       for (xt = xtable, x = 0; x < width; x++) {
1299         *(pr++) = (unsigned char) (tr - (rsign * max(*(xt++), *(yt))));
1300         *(pg++) = (unsigned char) (tg - (gsign * max(*(xt++), *(yt + 1))));
1301         *(pb++) = (unsigned char) (tb - (bsign * max(*(xt++), *(yt + 2))));
1302       }
1303     }
1304   } else {
1305     // faked interlacing effect
1306     unsigned char channel, channel2;
1307
1308     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1309       for (xt = xtable, x = 0; x < width; x++) {
1310         if (y & 1) {
1311           channel = (unsigned char) (tr - (rsign * max(*(xt++), *(yt))));
1312           channel2 = (channel >> 1) + (channel >> 2);
1313           if (channel2 > channel) channel2 = 0;
1314           *(pr++) = channel2;
1315
1316           channel = (unsigned char) (tg - (gsign * max(*(xt++), *(yt + 1))));
1317           channel2 = (channel >> 1) + (channel >> 2);
1318           if (channel2 > channel) channel2 = 0;
1319           *(pg++) = channel2;
1320
1321           channel = (unsigned char) (tb - (bsign * max(*(xt++), *(yt + 2))));
1322           channel2 = (channel >> 1) + (channel >> 2);
1323           if (channel2 > channel) channel2 = 0;
1324           *(pb++) = channel2;
1325         } else {
1326           channel = (unsigned char) (tr - (rsign * max(*(xt++), *(yt))));
1327           channel2 = channel + (channel >> 3);
1328           if (channel2 < channel) channel2 = ~0;
1329           *(pr++) = channel2;
1330
1331           channel = (unsigned char) (tg - (gsign * max(*(xt++), *(yt + 1))));
1332           channel2 = channel + (channel >> 3);
1333           if (channel2 < channel) channel2 = ~0;
1334           *(pg++) = channel2;
1335
1336           channel = (unsigned char) (tb - (bsign * max(*(xt++), *(yt + 2))));
1337           channel2 = channel + (channel >> 3);
1338           if (channel2 < channel) channel2 = ~0;
1339           *(pb++) = channel2;
1340         }
1341       }
1342     }
1343   }
1344 }
1345
1346
1347 void BImage::egradient(void) {
1348   // elliptic gradient -  based on original dgradient, written by
1349   // Mosfet (mosfet@kde.org)
1350   // adapted from kde sources for Blackbox by Brad Hughes
1351
1352   float drx, dgx, dbx, dry, dgy, dby, yr, yg, yb, xr, xg, xb;
1353   int rsign, gsign, bsign;
1354   unsigned char *pr = red, *pg = green, *pb = blue;
1355   unsigned int *xt = xtable, *yt = ytable,
1356     tr = (unsigned long) to.red(),
1357     tg = (unsigned long) to.green(),
1358     tb = (unsigned long) to.blue();
1359
1360   register unsigned int x, y;
1361
1362   dry = drx = (float) (to.red() - from.red());
1363   dgy = dgx = (float) (to.green() - from.green());
1364   dby = dbx = (float) (to.blue() - from.blue());
1365
1366   rsign = (drx < 0) ? -1 : 1;
1367   gsign = (dgx < 0) ? -1 : 1;
1368   bsign = (dbx < 0) ? -1 : 1;
1369
1370   xr = yr = (drx / 2);
1371   xg = yg = (dgx / 2);
1372   xb = yb = (dbx / 2);
1373
1374   // Create X table
1375   drx /= width;
1376   dgx /= width;
1377   dbx /= width;
1378
1379   for (x = 0; x < width; x++) {
1380     *(xt++) = (unsigned long) (xr * xr);
1381     *(xt++) = (unsigned long) (xg * xg);
1382     *(xt++) = (unsigned long) (xb * xb);
1383
1384     xr -= drx;
1385     xg -= dgx;
1386     xb -= dbx;
1387   }
1388
1389   // Create Y table
1390   dry /= height;
1391   dgy /= height;
1392   dby /= height;
1393
1394   for (y = 0; y < height; y++) {
1395     *(yt++) = (unsigned long) (yr * yr);
1396     *(yt++) = (unsigned long) (yg * yg);
1397     *(yt++) = (unsigned long) (yb * yb);
1398
1399     yr -= dry;
1400     yg -= dgy;
1401     yb -= dby;
1402   }
1403
1404   // Combine tables to create gradient
1405
1406   if (! interlaced) {
1407     // normal egradient
1408     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1409       for (xt = xtable, x = 0; x < width; x++) {
1410         *(pr++) = (unsigned char)
1411           (tr - (rsign * control->getSqrt(*(xt++) + *(yt))));
1412         *(pg++) = (unsigned char)
1413           (tg - (gsign * control->getSqrt(*(xt++) + *(yt + 1))));
1414         *(pb++) = (unsigned char)
1415           (tb - (bsign * control->getSqrt(*(xt++) + *(yt + 2))));
1416       }
1417     }
1418   } else {
1419     // faked interlacing effect
1420     unsigned char channel, channel2;
1421
1422     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1423       for (xt = xtable, x = 0; x < width; x++) {
1424         if (y & 1) {
1425           channel = (unsigned char)
1426             (tr - (rsign * control->getSqrt(*(xt++) + *(yt))));
1427           channel2 = (channel >> 1) + (channel >> 2);
1428           if (channel2 > channel) channel2 = 0;
1429           *(pr++) = channel2;
1430
1431           channel = (unsigned char)
1432             (tg - (gsign * control->getSqrt(*(xt++) + *(yt + 1))));
1433           channel2 = (channel >> 1) + (channel >> 2);
1434           if (channel2 > channel) channel2 = 0;
1435           *(pg++) = channel2;
1436
1437           channel = (unsigned char)
1438             (tb - (bsign * control->getSqrt(*(xt++) + *(yt + 2))));
1439           channel2 = (channel >> 1) + (channel >> 2);
1440           if (channel2 > channel) channel2 = 0;
1441           *(pb++) = channel2;
1442         } else {
1443           channel = (unsigned char)
1444             (tr - (rsign * control->getSqrt(*(xt++) + *(yt))));
1445           channel2 = channel + (channel >> 3);
1446           if (channel2 < channel) channel2 = ~0;
1447           *(pr++) = channel2;
1448
1449           channel = (unsigned char)
1450           (tg - (gsign * control->getSqrt(*(xt++) + *(yt + 1))));
1451           channel2 = channel + (channel >> 3);
1452           if (channel2 < channel) channel2 = ~0;
1453           *(pg++) = channel2;
1454
1455           channel = (unsigned char)
1456             (tb - (bsign * control->getSqrt(*(xt++) + *(yt + 2))));
1457           channel2 = channel + (channel >> 3);
1458           if (channel2 < channel) channel2 = ~0;
1459           *(pb++) = channel2;
1460         }
1461       }
1462     }
1463   }
1464 }
1465
1466
1467 void BImage::pcgradient(void) {
1468   // pipe cross gradient -  based on original dgradient, written by
1469   // Mosfet (mosfet@kde.org)
1470   // adapted from kde sources for Blackbox by Brad Hughes
1471
1472   float drx, dgx, dbx, dry, dgy, dby, xr, xg, xb, yr, yg, yb;
1473   int rsign, gsign, bsign;
1474   unsigned char *pr = red, *pg = green, *pb = blue;
1475   unsigned int *xt = xtable, *yt = ytable,
1476     tr = to.red(),
1477     tg = to.green(),
1478     tb = to.blue();
1479
1480   register unsigned int x, y;
1481
1482   dry = drx = (float) (to.red() - from.red());
1483   dgy = dgx = (float) (to.green() - from.green());
1484   dby = dbx = (float) (to.blue() - from.blue());
1485
1486   rsign = (drx < 0) ? -2 : 2;
1487   gsign = (dgx < 0) ? -2 : 2;
1488   bsign = (dbx < 0) ? -2 : 2;
1489
1490   xr = yr = (drx / 2);
1491   xg = yg = (dgx / 2);
1492   xb = yb = (dbx / 2);
1493
1494   // Create X table
1495   drx /= width;
1496   dgx /= width;
1497   dbx /= width;
1498
1499   for (x = 0; x < width; x++) {
1500     *(xt++) = (unsigned char) ((xr < 0) ? -xr : xr);
1501     *(xt++) = (unsigned char) ((xg < 0) ? -xg : xg);
1502     *(xt++) = (unsigned char) ((xb < 0) ? -xb : xb);
1503
1504     xr -= drx;
1505     xg -= dgx;
1506     xb -= dbx;
1507   }
1508
1509   // Create Y table
1510   dry /= height;
1511   dgy /= height;
1512   dby /= height;
1513
1514   for (y = 0; y < height; y++) {
1515     *(yt++) = ((unsigned char) ((yr < 0) ? -yr : yr));
1516     *(yt++) = ((unsigned char) ((yg < 0) ? -yg : yg));
1517     *(yt++) = ((unsigned char) ((yb < 0) ? -yb : yb));
1518
1519     yr -= dry;
1520     yg -= dgy;
1521     yb -= dby;
1522   }
1523
1524   // Combine tables to create gradient
1525
1526   if (! interlaced) {
1527     // normal pcgradient
1528     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1529       for (xt = xtable, x = 0; x < width; x++) {
1530         *(pr++) = (unsigned char) (tr - (rsign * min(*(xt++), *(yt))));
1531         *(pg++) = (unsigned char) (tg - (gsign * min(*(xt++), *(yt + 1))));
1532         *(pb++) = (unsigned char) (tb - (bsign * min(*(xt++), *(yt + 2))));
1533       }
1534     }
1535   } else {
1536     // faked interlacing effect
1537     unsigned char channel, channel2;
1538
1539     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1540       for (xt = xtable, x = 0; x < width; x++) {
1541         if (y & 1) {
1542           channel = (unsigned char) (tr - (rsign * min(*(xt++), *(yt))));
1543           channel2 = (channel >> 1) + (channel >> 2);
1544           if (channel2 > channel) channel2 = 0;
1545           *(pr++) = channel2;
1546
1547           channel = (unsigned char) (tg - (bsign * min(*(xt++), *(yt + 1))));
1548           channel2 = (channel >> 1) + (channel >> 2);
1549           if (channel2 > channel) channel2 = 0;
1550           *(pg++) = channel2;
1551
1552           channel = (unsigned char) (tb - (gsign * min(*(xt++), *(yt + 2))));
1553           channel2 = (channel >> 1) + (channel >> 2);
1554           if (channel2 > channel) channel2 = 0;
1555           *(pb++) = channel2;
1556         } else {
1557           channel = (unsigned char) (tr - (rsign * min(*(xt++), *(yt))));
1558           channel2 = channel + (channel >> 3);
1559           if (channel2 < channel) channel2 = ~0;
1560           *(pr++) = channel2;
1561
1562           channel = (unsigned char) (tg - (gsign * min(*(xt++), *(yt + 1))));
1563           channel2 = channel + (channel >> 3);
1564           if (channel2 < channel) channel2 = ~0;
1565           *(pg++) = channel2;
1566
1567           channel = (unsigned char) (tb - (bsign * min(*(xt++), *(yt + 2))));
1568           channel2 = channel + (channel >> 3);
1569           if (channel2 < channel) channel2 = ~0;
1570           *(pb++) = channel2;
1571         }
1572       }
1573     }
1574   }
1575 }
1576
1577
1578 void BImage::cdgradient(void) {
1579   // cross diagonal gradient -  based on original dgradient, written by
1580   // Mosfet (mosfet@kde.org)
1581   // adapted from kde sources for Blackbox by Brad Hughes
1582
1583   float drx, dgx, dbx, dry, dgy, dby, yr = 0.0, yg = 0.0, yb = 0.0,
1584     xr = (float) from.red(),
1585     xg = (float) from.green(),
1586     xb = (float) from.blue();
1587   unsigned char *pr = red, *pg = green, *pb = blue;
1588   unsigned int w = width * 2, h = height * 2, *xt, *yt;
1589
1590   register unsigned int x, y;
1591
1592   dry = drx = (float) (to.red() - from.red());
1593   dgy = dgx = (float) (to.green() - from.green());
1594   dby = dbx = (float) (to.blue() - from.blue());
1595
1596   // Create X table
1597   drx /= w;
1598   dgx /= w;
1599   dbx /= w;
1600
1601   for (xt = (xtable + (width * 3) - 1), x = 0; x < width; x++) {
1602     *(xt--) = (unsigned char) xb;
1603     *(xt--) = (unsigned char) xg;
1604     *(xt--) = (unsigned char) xr;
1605
1606     xr += drx;
1607     xg += dgx;
1608     xb += dbx;
1609   }
1610
1611   // Create Y table
1612   dry /= h;
1613   dgy /= h;
1614   dby /= h;
1615
1616   for (yt = ytable, y = 0; y < height; y++) {
1617     *(yt++) = (unsigned char) yr;
1618     *(yt++) = (unsigned char) yg;
1619     *(yt++) = (unsigned char) yb;
1620
1621     yr += dry;
1622     yg += dgy;
1623     yb += dby;
1624   }
1625
1626   // Combine tables to create gradient
1627
1628   if (! interlaced) {
1629     // normal cdgradient
1630     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1631       for (xt = xtable, x = 0; x < width; x++) {
1632         *(pr++) = *(xt++) + *(yt);
1633         *(pg++) = *(xt++) + *(yt + 1);
1634         *(pb++) = *(xt++) + *(yt + 2);
1635       }
1636     }
1637   } else {
1638     // faked interlacing effect
1639     unsigned char channel, channel2;
1640
1641     for (yt = ytable, y = 0; y < height; y++, yt += 3) {
1642       for (xt = xtable, x = 0; x < width; x++) {
1643         if (y & 1) {
1644           channel = *(xt++) + *(yt);
1645           channel2 = (channel >> 1) + (channel >> 2);
1646           if (channel2 > channel) channel2 = 0;
1647           *(pr++) = channel2;
1648
1649           channel = *(xt++) + *(yt + 1);
1650           channel2 = (channel >> 1) + (channel >> 2);
1651           if (channel2 > channel) channel2 = 0;
1652           *(pg++) = channel2;
1653
1654           channel = *(xt++) + *(yt + 2);
1655           channel2 = (channel >> 1) + (channel >> 2);
1656           if (channel2 > channel) channel2 = 0;
1657           *(pb++) = channel2;
1658         } else {
1659           channel = *(xt++) + *(yt);
1660           channel2 = channel + (channel >> 3);
1661           if (channel2 < channel) channel2 = ~0;
1662           *(pr++) = channel2;
1663
1664           channel = *(xt++) + *(yt + 1);
1665           channel2 = channel + (channel >> 3);
1666           if (channel2 < channel) channel2 = ~0;
1667           *(pg++) = channel2;
1668
1669           channel = *(xt++) + *(yt + 2);
1670           channel2 = channel + (channel >> 3);
1671           if (channel2 < channel) channel2 = ~0;
1672           *(pb++) = channel2;
1673         }
1674       }
1675     }
1676   }
1677 }