Dogcows Code - chaz/openbox/blob - otk/truerendercontrol.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #ifdef    HAVE_CONFIG_H
   4 #  include "../config.h"
   5 #endif // HAVE_CONFIG_H
   6
   7 #include "truerendercontrol.hh"
   8 #include "display.hh"
   9 #include "screeninfo.hh"
  10 #include "surface.hh"
  11 #include "rendertexture.hh"
  12
  13 extern "C" {
  14 #ifdef    HAVE_STDLIB_H
  15 #  include <stdlib.h>
  16 #endif // HAVE_STDLIB_H
  17
  18 #include "../src/gettext.h"
  19 #define _(str) gettext(str)
  20 }
  21
  22 namespace otk {
  23
  24 TrueRenderControl::TrueRenderControl(int screen)
  25   : RenderControl(screen),
  26     _red_offset(0),
  27     _green_offset(0),
  28     _blue_offset(0)
  29 {
  30   const ScreenInfo *info = display->screenInfo(_screen);
  31   XImage *timage = XCreateImage(**display, info->visual(), info->depth(),
  32                                 ZPixmap, 0, NULL, 1, 1, 32, 0);
  33   printf("Initializing TrueColor RenderControl\n");
  34
  35   unsigned long red_mask, green_mask, blue_mask;
  36
  37   // find the offsets for each color in the visual's masks
  38   red_mask = timage->red_mask;
  39   green_mask = timage->green_mask;
  40   blue_mask = timage->blue_mask;
  41
  42   while (! (red_mask & 1))   { _red_offset++;   red_mask   >>= 1; }
  43   while (! (green_mask & 1)) { _green_offset++; green_mask >>= 1; }
  44   while (! (blue_mask & 1))  { _blue_offset++;  blue_mask  >>= 1; }
  45
  46   _red_shift = _green_shift = _blue_shift = 8;
  47   while (red_mask)   { red_mask   >>= 1; _red_shift--;   }
  48   while (green_mask) { green_mask >>= 1; _green_shift--; }
  49   while (blue_mask)  { blue_mask  >>= 1; _blue_shift--;  }
  50   XFree(timage);
  51 }
  52
  53 TrueRenderControl::~TrueRenderControl()
  54 {
  55   printf("Destroying TrueColor RenderControl\n");
  56 }
  57
  58 void TrueRenderControl::drawGradientBackground(
  59      Surface &sf, const RenderTexture &texture) const
  60 {
  61   unsigned int r,g,b;
  62   int w = sf.size().width(), h = sf.size().height();
  63   int off, x;
  64
  65   const ScreenInfo *info = display->screenInfo(_screen);
  66   XImage *im = XCreateImage(**display, info->visual(), info->depth(),
  67                             ZPixmap, 0, NULL, w, h, 32, 0);
  68   im->byte_order = endian;
  69   pixel32 *data = new pixel32[h*w];
  70   pixel32 current;
  71
  72   switch (texture.gradient()) {
  73   case RenderTexture::Vertical:
  74     verticalGradient(sf, texture, data);
  75     break;
  76   case RenderTexture::Diagonal:
  77     diagonalGradient(sf, texture, data);
  78     break;
  79   case RenderTexture::CrossDiagonal:
  80     crossDiagonalGradient(sf, texture, data);
  81     break;
  82   default:
  83     printf("unhandled gradient\n");
  84   }
  85
  86   if (texture.relief() == RenderTexture::Flat && texture.border()) {
  87     r = texture.borderColor().red();
  88     g = texture.borderColor().green();
  89     b = texture.borderColor().blue();
  90     current = (r << default_red_shift)
  91             + (g << default_green_shift)
  92             + (b << default_blue_shift);
  93     for (off = 0, x = 0; x < w; ++x, off++) {
  94       *(data + off) = current;
  95       *(data + off + ((h-1) * w)) = current;
  96     }
  97     for (off = 0, x = 0; x < h; ++x, off++) {
  98       *(data + (off * w)) = current;
  99       *(data + (off * w) + w - 1) = current;
 100     }
 101   }
 102
 103   if (texture.relief() != RenderTexture::Flat) {
 104     if (texture.bevel() == RenderTexture::Bevel1) {
 105       for (off = 1, x = 1; x < w - 1; ++x, off++)
 106         highlight(data + off,
 107                   data + off + (h-1) * w,
 108                   texture.relief()==RenderTexture::Raised);
 109       for (off = 0, x = 0; x < h; ++x, off++)
 110         highlight(data + off * w,
 111                   data + off * w + w - 1,
 112                   texture.relief()==RenderTexture::Raised);
 113     }
 114
 115     if (texture.bevel() == RenderTexture::Bevel2) {
 116       for (off = 2, x = 2; x < w - 2; ++x, off++)
 117         highlight(data + off + w,
 118                   data + off + (h-2) * w,
 119                   texture.relief()==RenderTexture::Raised);
 120       for (off = 1, x = 1; x < h-1; ++x, off++)
 121         highlight(data + off * w + 1,
 122                   data + off * w + w - 2,
 123                   texture.relief()==RenderTexture::Raised);
 124     }
 125   }
 126
 127   reduceDepth(im, data);
 128
 129   im->data = (char*) data;
 130
 131   sf.setPixmap(im);
 132
 133   delete [] im->data;
 134   im->data = NULL;
 135   XDestroyImage(im);
 136 }
 137
 138 void TrueRenderControl::verticalGradient(Surface &sf,
 139                                          const RenderTexture &texture,
 140                                          pixel32 *data) const
 141 {
 142   pixel32 current;
 143   float dr, dg, db;
 144   unsigned int r,g,b;
 145   int w = sf.size().width(), h = sf.size().height();
 146
 147   dr = (float)(texture.secondary_color().red() - texture.color().red());
 148   dr/= (float)h;
 149
 150   dg = (float)(texture.secondary_color().green() - texture.color().green());
 151   dg/= (float)h;
 152
 153   db = (float)(texture.secondary_color().blue() - texture.color().blue());
 154   db/= (float)h;
 155
 156   for (int y = 0; y < h; ++y) {
 157     r = texture.color().red() + (int)(dr * y);
 158     g = texture.color().green() + (int)(dg * y);
 159     b = texture.color().blue() + (int)(db * y);
 160     current = (r << default_red_shift)
 161             + (g << default_green_shift)
 162             + (b << default_blue_shift);
 163     for (int x = 0; x < w; ++x, ++data)
 164       *data = current;
 165   }
 166 }
 167
 168 void TrueRenderControl::diagonalGradient(Surface &sf,
 169                                          const RenderTexture &texture,
 170                                          pixel32 *data) const
 171 {
 172   pixel32 current;
 173   float drx, dgx, dbx, dry, dgy, dby;
 174   unsigned int r,g,b;
 175   int w = sf.size().width(), h = sf.size().height();
 176
 177   for (int y = 0; y < h; ++y) {
 178     drx = (float)(texture.secondary_color().red() - texture.color().red());
 179     dry = drx/(float)h;
 180     drx/= (float)w;
 181
 182     dgx = (float)(texture.secondary_color().green() - texture.color().green());
 183     dgy = dgx/(float)h;
 184     dgx/= (float)w;
 185
 186     dbx = (float)(texture.secondary_color().blue() - texture.color().blue());
 187     dby = dbx/(float)h;
 188     dbx/= (float)w;
 189     for (int x = 0; x < w; ++x, ++data) {
 190       r = texture.color().red() + ((int)(drx * x) + (int)(dry * y))/2;
 191       g = texture.color().green() + ((int)(dgx * x) + (int)(dgy * y))/2;
 192       b = texture.color().blue() + ((int)(dbx * x) + (int)(dby * y))/2;
 193       current = (r << default_red_shift)
 194               + (g << default_green_shift)
 195               + (b << default_blue_shift);
 196       *data = current;
 197     }
 198   }
 199 }
 200
 201 void TrueRenderControl::crossDiagonalGradient(Surface &sf,
 202                                               const RenderTexture &texture,
 203                                               pixel32 *data) const
 204 {
 205   pixel32 current;
 206   float drx, dgx, dbx, dry, dgy, dby;
 207   unsigned int r,g,b;
 208   int w = sf.size().width(), h = sf.size().height();
 209
 210   for (int y = 0; y < h; ++y) {
 211     drx = (float)(texture.secondary_color().red() - texture.color().red());
 212     dry = drx/(float)h;
 213     drx/= (float)w;
 214
 215     dgx = (float)(texture.secondary_color().green() - texture.color().green());
 216     dgy = dgx/(float)h;
 217     dgx/= (float)w;
 218
 219     dbx = (float)(texture.secondary_color().blue() - texture.color().blue());
 220     dby = dbx/(float)h;
 221     dbx/= (float)w;
 222     for (int x = w; x > 0; --x, ++data) {
 223       r = texture.color().red() + ((int)(drx * (x-1)) + (int)(dry * y))/2;
 224       g = texture.color().green() + ((int)(dgx * (x-1)) + (int)(dgy * y))/2;
 225       b = texture.color().blue() + ((int)(dbx * (x-1)) + (int)(dby * y))/2;
 226       current = (r << default_red_shift)
 227               + (g << default_green_shift)
 228               + (b << default_blue_shift);
 229       *data = current;
 230     }
 231   }
 232 }
 233
 234 void TrueRenderControl::reduceDepth(XImage *im, pixel32 *data) const
 235 {
 236 // since pixel32 is the largest possible pixel size, we can share the array
 237   int r, g, b;
 238   int x,y;
 239   pixel16 *p = (pixel16*) data;
 240   switch (im->bits_per_pixel) {
 241   case 32:
 242     if ((_red_offset != default_red_shift) ||
 243         (_blue_offset != default_blue_shift) ||
 244         (_green_offset != default_green_shift)) {
 245       printf("cross endian conversion\n");
 246       for (y = 0; y < im->height; y++) {
 247         for (x = 0; x < im->width; x++) {
 248           r = (data[x] >> default_red_shift) & 0xFF;
 249           g = (data[x] >> default_green_shift) & 0xFF;
 250           b = (data[x] >> default_blue_shift) & 0xFF;
 251           data[x] = (r << _red_offset) + (g << _green_offset) +
 252             (b << _blue_offset);
 253         }
 254         data += im->width;
 255       }
 256    }
 257    return;
 258   case 16:
 259     for (y = 0; y < im->height; y++) {
 260       for (x = 0; x < im->width; x++) {
 261         r = (data[x] >> default_red_shift) & 0xFF;
 262         r = r >> _red_shift;
 263         g = (data[x] >> default_green_shift) & 0xFF;
 264         g = g >> _green_shift;
 265         b = (data[x] >> default_blue_shift) & 0xFF;
 266         b = b >> _blue_shift;
 267         p[x] = (r << _red_offset) + (g << _green_offset) + (b << _blue_offset);
 268       }
 269       data += im->width;
 270       p += im->bytes_per_line/2;
 271     }
 272     break;
 273   default:
 274     printf("your bit depth is currently unhandled\n");
 275   }
 276 }
 277
 278 void TrueRenderControl::highlight(pixel32 *x, pixel32 *y, bool raised) const
 279 {
 280   int r, g, b;
 281
 282   pixel32 *up, *down;
 283   if (raised) {
 284     up = x;
 285     down = y;
 286   } else {
 287     up = y;
 288     down = x;
 289   }
 290   r = (*up >> default_red_shift) & 0xFF;
 291   r += r >> 1;
 292   g = (*up >> default_green_shift) & 0xFF;
 293   g += g >> 1;
 294   b = (*up >> default_blue_shift) & 0xFF;
 295   b += b >> 1;
 296   if (r > 255) r = 255;
 297   if (g > 255) g = 255;
 298   if (b > 255) b = 255;
 299   *up = (r << default_red_shift) + (g << default_green_shift)
 300       + (b << default_blue_shift);
 301
 302   r = (*down >> default_red_shift) & 0xFF;
 303   r = (r >> 1) + (r >> 2);
 304   g = (*down >> default_green_shift) & 0xFF;
 305   g = (g >> 1) + (g >> 2);
 306   b = (*down >> default_blue_shift) & 0xFF;
 307   b = (b >> 1) + (b >> 2);
 308   *down = (r << default_red_shift) + (g << default_green_shift)
 309         + (b << default_blue_shift);
 310 }
 311
 312 void TrueRenderControl::drawBackground(Surface& sf,
 313                                        const RenderTexture &texture) const
 314 {
 315   assert(_screen == sf._screen);
 316   assert(_screen == texture.color().screen());
 317
 318   if (texture.gradient() == RenderTexture::Solid)
 319     drawSolidBackground(sf, texture);
 320   else
 321     drawGradientBackground(sf, texture);
 322 }
 323
 324 }