src/Fl_Bitmap.cxx

   1 //
   2 // "$Id: Fl_Bitmap.cxx 8360 2011-02-02 12:42:47Z manolo $"
   3 //
   4 // Bitmap drawing routines for the Fast Light Tool Kit (FLTK).
   5 //
   6 // Copyright 1998-2010 by Bill Spitzak and others.
   7 //
   8 // This library is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU Library General Public
  10 // License as published by the Free Software Foundation; either
  11 // version 2 of the License, or (at your option) any later version.
  12 //
  13 // This library is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // Library General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Library General Public
  19 // License along with this library; if not, write to the Free Software
  20 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21 // USA.
  22 //
  23 // Please report all bugs and problems on the following page:
  24 //
  25 //     http://www.fltk.org/str.php
  26 //
  27
  28 /** \fn Fl_Bitmap::Fl_Bitmap(const char *array, int W, int H)
  29   The constructors create a new bitmap from the specified bitmap data.*/
  30
  31 /** \fn Fl_Bitmap::Fl_Bitmap(const unsigned char *array, int W, int H)
  32   The constructors create a new bitmap from the specified bitmap data.*/
  33
  34 #include <FL/Fl.H>
  35 #include <FL/x.H>
  36 #include <FL/fl_draw.H>
  37 #include <FL/Fl_Widget.H>
  38 #include <FL/Fl_Menu_Item.H>
  39 #include <FL/Fl_Bitmap.H>
  40 #include <FL/Fl_Printer.H>
  41 #include "flstring.h"
  42
  43 #if defined(__APPLE_QUARTZ__)
  44
  45
  46 Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *array) {
  47   static uchar reverse[16] =    /* Bit reversal lookup table */
  48     { 0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
  49       0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff };
  50   int rowBytes = (w+7)>>3 ;
  51   uchar *bmask = (uchar*)malloc(rowBytes*h), *dst = bmask;
  52   const uchar *src = array;
  53   for ( int i=rowBytes*h; i>0; i--,src++ ) {
  54     *dst++ = ((reverse[*src & 0x0f] & 0xf0) | (reverse[(*src >> 4) & 0x0f] & 0x0f))^0xff;
  55   }
  56   CGDataProviderRef srcp = CGDataProviderCreateWithData( 0L, bmask, rowBytes*h, 0L);
  57   CGImageRef id_ = CGImageMaskCreate( w, h, 1, 1, rowBytes, srcp, 0L, false);
  58   CGDataProviderRelease(srcp);
  59   return (Fl_Bitmask)id_;
  60 }
  61 void fl_delete_bitmask(Fl_Bitmask bm) {
  62   if (bm) CGImageRelease((CGImageRef)bm);
  63 }
  64
  65
  66 #elif defined(WIN32) // Windows bitmask functions...
  67
  68
  69 // 'fl_create_bitmap()' - Create a 1-bit bitmap for drawing...
  70 static Fl_Bitmask fl_create_bitmap(int w, int h, const uchar *data) {
  71   // we need to pad the lines out to words & swap the bits
  72   // in each byte.
  73   int w1 = (w+7)/8;
  74   int w2 = ((w+15)/16)*2;
  75   uchar* newarray = new uchar[w2*h];
  76   const uchar* src = data;
  77   uchar* dest = newarray;
  78   Fl_Bitmask bm;
  79   static uchar reverse[16] =    /* Bit reversal lookup table */
  80               { 0x00, 0x88, 0x44, 0xcc, 0x22, 0xaa, 0x66, 0xee,
  81                 0x11, 0x99, 0x55, 0xdd, 0x33, 0xbb, 0x77, 0xff };
  82
  83   for (int y=0; y < h; y++) {
  84     for (int n = 0; n < w1; n++, src++)
  85       *dest++ = (uchar)((reverse[*src & 0x0f] & 0xf0) |
  86                         (reverse[(*src >> 4) & 0x0f] & 0x0f));
  87     dest += w2-w1;
  88   }
  89
  90   bm = CreateBitmap(w, h, 1, 1, newarray);
  91
  92   delete[] newarray;
  93
  94   return bm;
  95 }
  96
  97 // 'fl_create_bitmask()' - Create an N-bit bitmap for masking...
  98 Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data) {
  99   // this won't work when the user changes display mode during run or
 100   // has two screens with differnet depths
 101   Fl_Bitmask bm;
 102   static uchar hiNibble[16] =
 103   { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
 104     0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0 };
 105   static uchar loNibble[16] =
 106   { 0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
 107     0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f };
 108   int np  = GetDeviceCaps(fl_gc, PLANES);       //: was always one on sample machines
 109   int bpp = GetDeviceCaps(fl_gc, BITSPIXEL);//: 1,4,8,16,24,32 and more odd stuff?
 110   int Bpr = (bpp*w+7)/8;                        //: bytes per row
 111   int pad = Bpr&1, w1 = (w+7)/8, shr = ((w-1)&7)+1;
 112   if (bpp==4) shr = (shr+1)/2;
 113   uchar *newarray = new uchar[(Bpr+pad)*h];
 114   uchar *dst = newarray;
 115   const uchar *src = data;
 116
 117   for (int i=0; i<h; i++) {
 118     // This is slooow, but we do it only once per pixmap
 119     for (int j=w1; j>0; j--) {
 120       uchar b = *src++;
 121       if (bpp==1) {
 122         *dst++ = (uchar)( hiNibble[b&15] ) | ( loNibble[(b>>4)&15] );
 123       } else if (bpp==4) {
 124         for (int k=(j==1)?shr:4; k>0; k--) {
 125           *dst++ = (uchar)("\377\360\017\000"[b&3]);
 126           b = b >> 2;
 127         }
 128       } else {
 129         for (int k=(j==1)?shr:8; k>0; k--) {
 130           if (b&1) {
 131             *dst++=0;
 132             if (bpp>8) *dst++=0;
 133             if (bpp>16) *dst++=0;
 134             if (bpp>24) *dst++=0;
 135           } else {
 136             *dst++=0xff;
 137             if (bpp>8) *dst++=0xff;
 138             if (bpp>16) *dst++=0xff;
 139             if (bpp>24) *dst++=0xff;
 140           }
 141
 142           b = b >> 1;
 143         }
 144       }
 145     }
 146
 147     dst += pad;
 148   }
 149
 150   bm = CreateBitmap(w, h, np, bpp, newarray);
 151   delete[] newarray;
 152
 153   return bm;
 154 }
 155
 156
 157 void fl_delete_bitmask(Fl_Bitmask bm) {
 158   DeleteObject((HGDIOBJ)bm);
 159 }
 160
 161
 162 #else // X11 bitmask functions
 163
 164
 165 Fl_Bitmask fl_create_bitmask(int w, int h, const uchar *data) {
 166   return XCreateBitmapFromData(fl_display, fl_window, (const char *)data,
 167                                (w+7)&-8, h);
 168 }
 169
 170 void fl_delete_bitmask(Fl_Bitmask bm) {
 171   fl_delete_offscreen((Fl_Offscreen)bm);
 172 }
 173
 174
 175 #endif // __APPLE__
 176
 177
 178 // Create a 1-bit mask used for alpha blending
 179 Fl_Bitmask fl_create_alphamask(int w, int h, int d, int ld, const uchar *array) {
 180   Fl_Bitmask bm;
 181   int bmw = (w + 7) / 8;
 182   uchar *bitmap = new uchar[bmw * h];
 183   uchar *bitptr, bit;
 184   const uchar *dataptr;
 185   int x, y;
 186   static uchar dither[16][16] = { // Simple 16x16 Floyd dither
 187     { 0,   128, 32,  160, 8,   136, 40,  168,
 188       2,   130, 34,  162, 10,  138, 42,  170 },
 189     { 192, 64,  224, 96,  200, 72,  232, 104,
 190       194, 66,  226, 98,  202, 74,  234, 106 },
 191     { 48,  176, 16,  144, 56,  184, 24,  152,
 192       50,  178, 18,  146, 58,  186, 26,  154 },
 193     { 240, 112, 208, 80,  248, 120, 216, 88,
 194       242, 114, 210, 82,  250, 122, 218, 90 },
 195     { 12,  140, 44,  172, 4,   132, 36,  164,
 196       14,  142, 46,  174, 6,   134, 38,  166 },
 197     { 204, 76,  236, 108, 196, 68,  228, 100,
 198       206, 78,  238, 110, 198, 70,  230, 102 },
 199     { 60,  188, 28,  156, 52,  180, 20,  148,
 200       62,  190, 30,  158, 54,  182, 22,  150 },
 201     { 252, 124, 220, 92,  244, 116, 212, 84,
 202       254, 126, 222, 94,  246, 118, 214, 86 },
 203     { 3,   131, 35,  163, 11,  139, 43,  171,
 204       1,   129, 33,  161, 9,   137, 41,  169 },
 205     { 195, 67,  227, 99,  203, 75,  235, 107,
 206       193, 65,  225, 97,  201, 73,  233, 105 },
 207     { 51,  179, 19,  147, 59,  187, 27,  155,
 208       49,  177, 17,  145, 57,  185, 25,  153 },
 209     { 243, 115, 211, 83,  251, 123, 219, 91,
 210       241, 113, 209, 81,  249, 121, 217, 89 },
 211     { 15,  143, 47,  175, 7,   135, 39,  167,
 212       13,  141, 45,  173, 5,   133, 37,  165 },
 213     { 207, 79,  239, 111, 199, 71,  231, 103,
 214       205, 77,  237, 109, 197, 69,  229, 101 },
 215     { 63,  191, 31,  159, 55,  183, 23,  151,
 216       61,  189, 29,  157, 53,  181, 21,  149 },
 217     { 254, 127, 223, 95,  247, 119, 215, 87,
 218       253, 125, 221, 93,  245, 117, 213, 85 }
 219   };
 220
 221   // Generate a 1-bit "screen door" alpha mask; not always pretty, but
 222   // definitely fast...  In the future we may be able to support things
 223   // like the RENDER extension in XFree86, when available, to provide
 224   // true RGBA-blended rendering.  See:
 225   //
 226   //     http://www.xfree86.org/~keithp/render/protocol.html
 227   //
 228   // for more info on XRender...
 229   //
 230   // MacOS already provides alpha blending support and has its own
 231   // fl_create_alphamask() function...
 232   memset(bitmap, 0, bmw * h);
 233
 234   for (dataptr = array + d - 1, y = 0; y < h; y ++, dataptr += ld)
 235     for (bitptr = bitmap + y * bmw, bit = 1, x = 0; x < w; x ++, dataptr += d) {
 236       if (*dataptr > dither[x & 15][y & 15])
 237         *bitptr |= bit;
 238       if (bit < 128) bit <<= 1;
 239       else {
 240         bit = 1;
 241         bitptr ++;
 242       }
 243     }
 244
 245   bm = fl_create_bitmask(w, h, bitmap);
 246   delete[] bitmap;
 247
 248   return (bm);
 249 }
 250
 251 void Fl_Bitmap::draw(int XP, int YP, int WP, int HP, int cx, int cy) {
 252   fl_graphics_driver->draw(this, XP, YP, WP, HP, cx, cy);
 253 }
 254
 255 static int start(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int w, int h, int &cx, int &cy,
 256                  int &X, int &Y, int &W, int &H)
 257 {
 258   // account for current clip region (faster on Irix):
 259   fl_clip_box(XP,YP,WP,HP,X,Y,W,H);
 260   cx += X-XP; cy += Y-YP;
 261   // clip the box down to the size of image, quit if empty:
 262   if (cx < 0) {W += cx; X -= cx; cx = 0;}
 263   if (cx+W > w) W = w-cx;
 264   if (W <= 0) return 1;
 265   if (cy < 0) {H += cy; Y -= cy; cy = 0;}
 266   if (cy+H > h) H = h-cy;
 267   if (H <= 0) return 1;
 268   return 0;
 269 }
 270
 271 #ifdef __APPLE__
 272 void Fl_Quartz_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy) {
 273   int X, Y, W, H;
 274   if (!bm->array) {
 275     bm->draw_empty(XP, YP);
 276     return;
 277   }
 278   if (start(bm, XP, YP, WP, HP, bm->w(), bm->h(), cx, cy, X, Y, W, H)) {
 279     return;
 280   }
 281   if (!bm->id_) bm->id_ = fl_create_bitmask(bm->w(), bm->h(), bm->array);
 282   if (bm->id_ && fl_gc) {
 283     CGRect rect = { { X, Y }, { W, H } };
 284     Fl_X::q_begin_image(rect, cx, cy, bm->w(), bm->h());
 285     CGContextDrawImage(fl_gc, rect, (CGImageRef)bm->id_);
 286     Fl_X::q_end_image();
 287   }
 288 }
 289
 290 #elif defined(WIN32)
 291 void Fl_GDI_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy) {
 292   int X, Y, W, H;
 293   if (!bm->array) {
 294     bm->draw_empty(XP, YP);
 295     return;
 296   }
 297   if (start(bm, XP, YP, WP, HP, bm->w(), bm->h(), cx, cy, X, Y, W, H)) {
 298     return;
 299   }
 300   if (!bm->id_) bm->id_ = fl_create_bitmap(bm->w(), bm->h(), bm->array);
 301
 302   typedef BOOL (WINAPI* fl_transp_func)  (HDC,int,int,int,int,HDC,int,int,int,int,UINT);
 303   static fl_transp_func fl_TransparentBlt;
 304   HDC tempdc;
 305   int save;
 306   BOOL use_print_algo = false;
 307   if (Fl_Surface_Device::surface()->class_name() == Fl_Printer::class_id) {
 308     static HMODULE hMod = NULL;
 309     if (!hMod) {
 310       hMod = LoadLibrary("MSIMG32.DLL");
 311       if (hMod) fl_TransparentBlt = (fl_transp_func)GetProcAddress(hMod, "TransparentBlt");
 312     }
 313     if (fl_TransparentBlt) use_print_algo = true;
 314   }
 315   if (use_print_algo) { // algorithm for bitmap output to Fl_GDI_Printer
 316     Fl_Offscreen tmp_id = fl_create_offscreen(W, H);
 317     fl_begin_offscreen(tmp_id);
 318     Fl_Color save_c = fl_color(); // save bitmap's desired color
 319     uchar r, g, b;
 320     Fl::get_color(save_c, r, g, b);
 321     r = 255-r;
 322     g = 255-g;
 323     b = 255-b;
 324     Fl_Color background = fl_rgb_color(r, g, b); // a color very different from the bitmap's
 325     fl_color(background);
 326     fl_rectf(0,0,W,H); // use this color as offscreen background
 327     fl_color(save_c); // back to bitmap's color
 328     tempdc = CreateCompatibleDC(fl_gc);
 329     save = SaveDC(tempdc);
 330     SelectObject(tempdc, (HGDIOBJ)bm->id_);
 331     SelectObject(fl_gc, fl_brush()); // use bitmap's desired color
 332     BitBlt(fl_gc, 0, 0, W, H, tempdc, 0, 0, 0xE20746L); // draw bitmap to offscreen
 333     fl_end_offscreen(); // offscreen data is in tmp_id
 334     SelectObject(tempdc, (HGDIOBJ)tmp_id); // use offscreen data
 335     // draw it to printer context with background color as transparent
 336     fl_TransparentBlt(fl_gc, X,Y,W,H, tempdc, cx, cy, bm->w(), bm->h(), RGB(r, g, b) );
 337     fl_delete_offscreen(tmp_id);
 338   }
 339   else { // algorithm for bitmap output to display
 340     tempdc = CreateCompatibleDC(fl_gc);
 341     save = SaveDC(tempdc);
 342     SelectObject(tempdc, (HGDIOBJ)bm->id_);
 343     SelectObject(fl_gc, fl_brush());
 344     // secret bitblt code found in old MSWindows reference manual:
 345     BitBlt(fl_gc, X, Y, W, H, tempdc, cx, cy, 0xE20746L);
 346   }
 347   RestoreDC(tempdc, save);
 348   DeleteDC(tempdc);
 349 }
 350
 351 #else // Xlib
 352 void Fl_Xlib_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, int HP, int cx, int cy) {
 353   int X, Y, W, H;
 354   if (!bm->array) {
 355     bm->draw_empty(XP, YP);
 356     return;
 357   }
 358   if (start(bm, XP, YP, WP, HP, bm->w(), bm->h(), cx, cy, X, Y, W, H)) {
 359     return;
 360   }
 361   if (!bm->id_) bm->id_ = fl_create_bitmask(bm->w(), bm->h(), bm->array);
 362
 363   XSetStipple(fl_display, fl_gc, bm->id_);
 364   int ox = X-cx; if (ox < 0) ox += bm->w();
 365   int oy = Y-cy; if (oy < 0) oy += bm->h();
 366   XSetTSOrigin(fl_display, fl_gc, ox, oy);
 367   XSetFillStyle(fl_display, fl_gc, FillStippled);
 368   XFillRectangle(fl_display, fl_window, fl_gc, X, Y, W, H);
 369   XSetFillStyle(fl_display, fl_gc, FillSolid);
 370 }
 371 #endif
 372
 373 /**
 374   The destructor free all memory and server resources that are used by
 375   the bitmap.
 376 */
 377 Fl_Bitmap::~Fl_Bitmap() {
 378   uncache();
 379   if (alloc_array) delete[] (uchar *)array;
 380 }
 381
 382 void Fl_Bitmap::uncache() {
 383   if (id_) {
 384 #ifdef __APPLE_QUARTZ__
 385     fl_delete_bitmask((Fl_Bitmask)id_);
 386 #else
 387     fl_delete_bitmask((Fl_Offscreen)id_);
 388 #endif
 389     id_ = 0;
 390   }
 391 }
 392
 393 void Fl_Bitmap::label(Fl_Widget* widget) {
 394   widget->image(this);
 395 }
 396
 397 void Fl_Bitmap::label(Fl_Menu_Item* m) {
 398   Fl::set_labeltype(_FL_IMAGE_LABEL, labeltype, measure);
 399   m->label(_FL_IMAGE_LABEL, (const char*)this);
 400 }
 401
 402 Fl_Image *Fl_Bitmap::copy(int W, int H) {
 403   Fl_Bitmap     *new_image;     // New RGB image
 404   uchar         *new_array;     // New array for image data
 405
 406   // Optimize the simple copy where the width and height are the same...
 407   if (W == w() && H == h()) {
 408     new_array = new uchar [H * ((W + 7) / 8)];
 409     memcpy(new_array, array, H * ((W + 7) / 8));
 410
 411     new_image = new Fl_Bitmap(new_array, W, H);
 412     new_image->alloc_array = 1;
 413
 414     return new_image;
 415   }
 416   if (W <= 0 || H <= 0) return 0;
 417
 418   // OK, need to resize the image data; allocate memory and
 419   uchar         *new_ptr,       // Pointer into new array
 420                 new_bit,        // Bit for new array
 421                 old_bit;        // Bit for old array
 422   const uchar   *old_ptr;       // Pointer into old array
 423   int           sx, sy,         // Source coordinates
 424                 dx, dy,         // Destination coordinates
 425                 xerr, yerr,     // X & Y errors
 426                 xmod, ymod,     // X & Y moduli
 427                 xstep, ystep;   // X & Y step increments
 428
 429
 430   // Figure out Bresenheim step/modulus values...
 431   xmod   = w() % W;
 432   xstep  = w() / W;
 433   ymod   = h() % H;
 434   ystep  = h() / H;
 435
 436   // Allocate memory for the new image...
 437   new_array = new uchar [H * ((W + 7) / 8)];
 438   new_image = new Fl_Bitmap(new_array, W, H);
 439   new_image->alloc_array = 1;
 440
 441   memset(new_array, 0, H * ((W + 7) / 8));
 442
 443   // Scale the image using a nearest-neighbor algorithm...
 444   for (dy = H, sy = 0, yerr = H, new_ptr = new_array; dy > 0; dy --) {
 445     for (dx = W, xerr = W, old_ptr = array + sy * ((w() + 7) / 8), sx = 0, new_bit = 1;
 446          dx > 0;
 447          dx --) {
 448       old_bit = (uchar)(1 << (sx & 7));
 449       if (old_ptr[sx / 8] & old_bit) *new_ptr |= new_bit;
 450
 451       if (new_bit < 128) new_bit <<= 1;
 452       else {
 453         new_bit = 1;
 454         new_ptr ++;
 455       }
 456
 457       sx   += xstep;
 458       xerr -= xmod;
 459
 460       if (xerr <= 0) {
 461         xerr += W;
 462         sx ++;
 463       }
 464     }
 465
 466     if (new_bit > 1) new_ptr ++;
 467
 468     sy   += ystep;
 469     yerr -= ymod;
 470     if (yerr <= 0) {
 471       yerr += H;
 472       sy ++;
 473     }
 474   }
 475
 476   return new_image;
 477 }
 478
 479
 480 //
 481 // End of "$Id: Fl_Bitmap.cxx 8360 2011-02-02 12:42:47Z manolo $".
 482 //