src/x11/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      Julian Smart, Robert Roebling
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart, Robert Roebling
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "bitmap.h"
  14 #endif
  15
  16 #include "wx/bitmap.h"
  17 #include "wx/icon.h"
  18 #include "wx/log.h"
  19 #include "wx/image.h"
  20 #include "wx/app.h"
  21
  22 #include "wx/x11/private.h"
  23
  24 #if wxUSE_XPM
  25 #if wxHAVE_LIB_XPM
  26 #include <X11/xpm.h>
  27 #else
  28 #include "wx/xpmdecod.h"
  29 #include "wx/wfstream.h"
  30 #endif
  31 #endif
  32 #include <math.h>
  33
  34 //-----------------------------------------------------------------------------
  35 // wxMask
  36 //-----------------------------------------------------------------------------
  37
  38 IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
  39
  40 wxMask::wxMask()
  41 {
  42     m_bitmap = NULL;
  43     m_display = NULL;
  44 }
  45
  46 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
  47 {
  48     m_bitmap = NULL;
  49     Create( bitmap, colour );
  50 }
  51
  52 wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
  53 {
  54     m_bitmap = NULL;
  55     Create( bitmap, paletteIndex );
  56 }
  57
  58 wxMask::wxMask( const wxBitmap& bitmap )
  59 {
  60     m_bitmap = NULL;
  61     Create( bitmap );
  62 }
  63
  64 wxMask::~wxMask()
  65 {
  66     if (m_bitmap)
  67         XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
  68 }
  69
  70 bool wxMask::Create( const wxBitmap& bitmap,
  71                      const wxColour& colour )
  72 {
  73     if (m_bitmap)
  74     {
  75         XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
  76         m_bitmap = NULL;
  77     }
  78
  79     m_display = bitmap.GetDisplay();
  80
  81     wxImage image( bitmap );
  82     if (!image.Ok()) return FALSE;
  83
  84     m_display = bitmap.GetDisplay();
  85
  86     Display *xdisplay = (Display*) m_display;
  87
  88     int xscreen = DefaultScreen( xdisplay );
  89     Window xroot = RootWindow( xdisplay, xscreen );
  90     Visual* xvisual = DefaultVisual( xdisplay, xscreen );
  91     int bpp = DefaultDepth( xdisplay, xscreen );
  92
  93     m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 );
  94     GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL );
  95
  96     XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) );
  97     XSetFillStyle( xdisplay, gc, FillSolid );
  98     XFillRectangle( xdisplay, (Pixmap) m_bitmap, gc, 0, 0, image.GetWidth(), image.GetHeight() );
  99
 100     unsigned char *data = image.GetData();
 101     int index = 0;
 102
 103     unsigned char red = colour.Red();
 104     unsigned char green = colour.Green();
 105     unsigned char blue = colour.Blue();
 106
 107     XVisualInfo vinfo_template;
 108     XVisualInfo *vi;
 109
 110     vinfo_template.visual = xvisual;
 111     vinfo_template.visualid = XVisualIDFromVisual( xvisual );
 112     vinfo_template.depth = bpp;
 113     int nitem = 0;
 114
 115     vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 116     wxASSERT_MSG( vi, wxT("No visual info") );
 117
 118     if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
 119     if (bpp == 15)
 120     {
 121         red = red & 0xf8;
 122         green = green & 0xf8;
 123         blue = blue & 0xf8;
 124     } else
 125     if (bpp == 16)
 126     {
 127         red = red & 0xf8;
 128         green = green & 0xfc;
 129         blue = blue & 0xf8;
 130     } else
 131     if (bpp == 12)
 132     {
 133         red = red & 0xf0;
 134         green = green & 0xf0;
 135         blue = blue & 0xf0;
 136     }
 137
 138     XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
 139
 140     for (int j = 0; j < image.GetHeight(); j++)
 141     {
 142         int start_x = -1;
 143         int i;
 144         for (i = 0; i < image.GetWidth(); i++)
 145         {
 146             if ((data[index] == red) &&
 147                 (data[index+1] == green) &&
 148                 (data[index+2] == blue))
 149             {
 150                 if (start_x == -1)
 151                 start_x = i;
 152             }
 153             else
 154             {
 155                 if (start_x != -1)
 156                 {
 157                     XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i-1, j );
 158                     start_x = -1;
 159                 }
 160             }
 161             index += 3;
 162         }
 163         if (start_x != -1)
 164             XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j );
 165     }
 166
 167     XFreeGC( xdisplay, gc );
 168
 169     return TRUE;
 170 }
 171
 172 bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
 173 {
 174     unsigned char r,g,b;
 175     wxPalette *pal = bitmap.GetPalette();
 176
 177     wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") );
 178
 179     pal->GetRGB(paletteIndex, &r, &g, &b);
 180
 181     return Create(bitmap, wxColour(r, g, b));
 182 }
 183
 184 bool wxMask::Create( const wxBitmap& bitmap )
 185 {
 186     if (m_bitmap)
 187     {
 188         XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
 189         m_bitmap = NULL;
 190     }
 191
 192     if (!bitmap.Ok()) return FALSE;
 193
 194     wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") );
 195
 196     m_display = bitmap.GetDisplay();
 197
 198     int xscreen = DefaultScreen( (Display*) m_display );
 199     Window xroot = RootWindow( (Display*) m_display, xscreen );
 200
 201     m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 202
 203     if (!m_bitmap) return FALSE;
 204
 205     GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL );
 206
 207     XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap,
 208        gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 );
 209
 210     XFreeGC( (Display*) m_display, gc );
 211
 212     return TRUE;
 213 }
 214
 215 //-----------------------------------------------------------------------------
 216 // wxBitmap
 217 //-----------------------------------------------------------------------------
 218
 219 class wxBitmapRefData: public wxObjectRefData
 220 {
 221 public:
 222     wxBitmapRefData();
 223     ~wxBitmapRefData();
 224
 225     WXPixmap        m_pixmap;
 226     WXPixmap        m_bitmap;
 227     WXDisplay      *m_display;
 228     wxMask         *m_mask;
 229     int             m_width;
 230     int             m_height;
 231     int             m_bpp;
 232     wxPalette      *m_palette;
 233 };
 234
 235 wxBitmapRefData::wxBitmapRefData()
 236 {
 237     m_pixmap = NULL;
 238     m_bitmap = NULL;
 239     m_display = NULL;
 240     m_mask = (wxMask *) NULL;
 241     m_width = 0;
 242     m_height = 0;
 243     m_bpp = 0;
 244     m_palette = (wxPalette *) NULL;
 245 }
 246
 247 wxBitmapRefData::~wxBitmapRefData()
 248 {
 249     if (m_pixmap) XFreePixmap( (Display*) m_display, (Pixmap) m_pixmap );
 250     if (m_bitmap) XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
 251     if (m_mask) delete m_mask;
 252     if (m_palette) delete m_palette;
 253 }
 254
 255 //-----------------------------------------------------------------------------
 256
 257 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
 258
 259 IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
 260
 261 wxBitmap::wxBitmap()
 262 {
 263 }
 264
 265 wxBitmap::wxBitmap( int width, int height, int depth )
 266 {
 267     Create( width, height, depth );
 268 }
 269
 270 bool wxBitmap::Create( int width, int height, int depth )
 271 {
 272     UnRef();
 273
 274     wxCHECK_MSG( (width > 0) && (height > 0), FALSE, wxT("invalid bitmap size") )
 275
 276     m_refData = new wxBitmapRefData();
 277
 278     M_BMPDATA->m_display = wxGlobalDisplay();
 279
 280     wxASSERT_MSG( M_BMPDATA->m_display, wxT("No display") );
 281
 282     int xscreen = DefaultScreen( (Display*) M_BMPDATA->m_display );
 283     Window xroot = RootWindow( (Display*) M_BMPDATA->m_display, xscreen );
 284
 285     int bpp = DefaultDepth( (Display*) M_BMPDATA->m_display, xscreen );
 286     if (depth == -1) depth = bpp;
 287
 288     wxCHECK_MSG( (depth == bpp) ||
 289                  (depth == 1), FALSE, wxT("invalid bitmap depth") )
 290
 291     M_BMPDATA->m_mask = (wxMask *) NULL;
 292     M_BMPDATA->m_width = width;
 293     M_BMPDATA->m_height = height;
 294     if (depth == 1)
 295     {
 296         M_BMPDATA->m_bitmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, 1 );
 297
 298         wxASSERT_MSG( M_BMPDATA->m_bitmap, wxT("Bitmap creation failed") );
 299
 300         M_BMPDATA->m_bpp = 1;
 301     }
 302     else
 303     {
 304         M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, depth );
 305
 306         wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Pixmap creation failed") );
 307
 308         M_BMPDATA->m_bpp = depth;
 309     }
 310
 311     return Ok();
 312 }
 313
 314 bool wxBitmap::CreateFromXpm( const char **bits )
 315 {
 316 #if wxUSE_XPM
 317 #if wxHAVE_LIB_XPM
 318     UnRef();
 319
 320     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 321
 322     m_refData = new wxBitmapRefData();
 323
 324     M_BMPDATA->m_display = wxGlobalDisplay();
 325
 326     Display *xdisplay = (Display*) M_BMPDATA->m_display;
 327
 328     int xscreen = DefaultScreen( xdisplay );
 329     Window xroot = RootWindow( xdisplay, xscreen );
 330
 331     int bpp = DefaultDepth( xdisplay, xscreen );
 332
 333     XpmAttributes xpmAttr;
 334     xpmAttr.valuemask = XpmReturnInfos;    // nothing yet, but get infos back
 335
 336     Pixmap pixmap;
 337     Pixmap mask = 0;
 338
 339     int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits, &pixmap, &mask, &xpmAttr );
 340
 341     if (ErrorStatus == XpmSuccess)
 342     {
 343         M_BMPDATA->m_width = xpmAttr.width;
 344         M_BMPDATA->m_height = xpmAttr.height;
 345
 346         M_BMPDATA->m_bpp = bpp;  // mono as well?
 347
 348 #if __WXDEBUG__
 349         unsigned int depthRet;
 350         int xRet, yRet;
 351         unsigned int widthRet, heightRet, borderWidthRet;
 352         XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet,
 353             &widthRet, &heightRet, &borderWidthRet, &depthRet);
 354
 355         wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") )
 356 #endif
 357
 358         XpmFreeAttributes(&xpmAttr);
 359
 360         M_BMPDATA->m_pixmap = (WXPixmap) pixmap;
 361
 362         if (mask)
 363         {
 364             M_BMPDATA->m_mask = new wxMask;
 365             M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask );
 366             M_BMPDATA->m_mask->SetDisplay( xdisplay );
 367         }
 368         return TRUE;
 369     }
 370     else
 371     {
 372         UnRef();
 373
 374         return FALSE;
 375     }
 376 #else
 377     wxXPMDecoder decoder;
 378     wxImage image(decoder.ReadData(bits));
 379     if (image.Ok())
 380         return CreateFromImage(image);
 381     else
 382         return FALSE;
 383 #endif
 384 #endif
 385     return FALSE;
 386 }
 387
 388 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 389 {
 390     UnRef();
 391
 392     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
 393     wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
 394
 395     m_refData = new wxBitmapRefData();
 396
 397     M_BMPDATA->m_display = wxGlobalDisplay();
 398
 399     Display *xdisplay = (Display*) M_BMPDATA->m_display;
 400
 401     int xscreen = DefaultScreen( xdisplay );
 402     Window xroot = RootWindow( xdisplay, xscreen );
 403     Visual* xvisual = DefaultVisual( xdisplay, xscreen );
 404
 405     int bpp = DefaultDepth( xdisplay, xscreen );
 406
 407     int width = image.GetWidth();
 408     int height = image.GetHeight();
 409     M_BMPDATA->m_width = width;
 410     M_BMPDATA->m_height = height;
 411
 412     if (depth != 1) depth = bpp;
 413     M_BMPDATA->m_bpp = depth;
 414
 415     if (depth == 1)
 416     {
 417         wxFAIL_MSG( "mono images later" );
 418     }
 419     else
 420     {
 421         // Create image
 422
 423         XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
 424         data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
 425
 426         if (data_image->data == NULL)
 427         {
 428             wxLogError( wxT("Out of memory.") );  // TODO clean
 429             return FALSE;
 430         }
 431
 432         M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );
 433
 434         // Create mask
 435
 436         XImage *mask_image = (XImage*) NULL;
 437         if (image.HasMask())
 438         {
 439             mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
 440             mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
 441
 442             if (mask_image->data == NULL)
 443             {
 444                 wxLogError( wxT("Out of memory.") ); // TODO clean
 445                 return FALSE;
 446             }
 447
 448             wxMask *mask = new wxMask();
 449             mask->SetDisplay( xdisplay );
 450             mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );
 451
 452             SetMask( mask );
 453         }
 454
 455         // Retrieve info
 456
 457         XVisualInfo vinfo_template;
 458         XVisualInfo *vi;
 459
 460         vinfo_template.visual = xvisual;
 461         vinfo_template.visualid = XVisualIDFromVisual( xvisual );
 462         vinfo_template.depth = bpp;
 463         int nitem = 0;
 464
 465         vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 466         wxASSERT_MSG( vi, wxT("No visual info") );
 467
 468         if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
 469         if (bpp < 8) bpp = 8;
 470
 471         // Render
 472
 473         enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
 474         byte_order b_o = RGB;
 475
 476         if (bpp > 8)
 477         {
 478             if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
 479             else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RBG;
 480             else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
 481             else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
 482             else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
 483             else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
 484         }
 485
 486         XFree( vi );
 487
 488         int r_mask = image.GetMaskRed();
 489         int g_mask = image.GetMaskGreen();
 490         int b_mask = image.GetMaskBlue();
 491
 492         unsigned char* data = image.GetData();
 493         wxASSERT_MSG( data, "No image data" );
 494
 495         bool hasMask = image.HasMask();
 496
 497         int index = 0;
 498         for (int y = 0; y < height; y++)
 499         {
 500             for (int x = 0; x < width; x++)
 501             {
 502                 int r = data[index];
 503                 index++;
 504                 int g = data[index];
 505                 index++;
 506                 int b = data[index];
 507                 index++;
 508
 509                 if (hasMask)
 510                 {
 511                     if ((r == r_mask) && (b == b_mask) && (g == g_mask))
 512                         XPutPixel( mask_image, x, y, 0 );
 513                     else
 514                         XPutPixel( mask_image, x, y, 1 );
 515                 }
 516
 517                 switch (bpp)
 518                 {
 519                     case 8:
 520                     {
 521                         int pixel = 0;
 522 #if 0
 523                         if (wxTheApp->m_colorCube)
 524                         {
 525                             pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
 526                         }
 527                         else
 528                         {
 529                             GdkColormap *cmap = gtk_widget_get_default_colormap();
 530                             GdkColor *colors = cmap->colors;
 531                             int max = 3 * (65536);
 532
 533                             for (int i = 0; i < cmap->size; i++)
 534                             {
 535                                 int rdiff = (r << 8) - colors[i].red;
 536                                 int gdiff = (g << 8) - colors[i].green;
 537                                 int bdiff = (b << 8) - colors[i].blue;
 538                                 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
 539                                 if (sum < max) { pixel = i; max = sum; }
 540                             }
 541                         }
 542 #endif
 543                         XPutPixel( data_image, x, y, pixel );
 544                         break;
 545                     }
 546                     case 12:  // SGI only
 547                     {
 548                         int pixel = 0;
 549                         switch (b_o)
 550                         {
 551                             case RGB: pixel = ((r & 0xf0) << 4) | (g & 0xf0) | ((b & 0xf0) >> 4); break;
 552                             case RBG: pixel = ((r & 0xf0) << 4) | (b & 0xf0) | ((g & 0xf0) >> 4); break;
 553                             case GRB: pixel = ((g & 0xf0) << 4) | (r & 0xf0) | ((b & 0xf0) >> 4); break;
 554                             case GBR: pixel = ((g & 0xf0) << 4) | (b & 0xf0) | ((r & 0xf0) >> 4); break;
 555                             case BRG: pixel = ((b & 0xf0) << 4) | (r & 0xf0) | ((g & 0xf0) >> 4); break;
 556                             case BGR: pixel = ((b & 0xf0) << 4) | (g & 0xf0) | ((r & 0xf0) >> 4); break;
 557                         }
 558                         XPutPixel( data_image, x, y, pixel );
 559                         break;
 560                     }
 561                     case 15:
 562                     {
 563                         int pixel = 0;
 564                         switch (b_o)
 565                         {
 566                             case RGB: pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
 567                             case RBG: pixel = ((r & 0xf8) << 7) | ((b & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
 568                             case GRB: pixel = ((g & 0xf8) << 7) | ((r & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
 569                             case GBR: pixel = ((g & 0xf8) << 7) | ((b & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
 570                             case BRG: pixel = ((b & 0xf8) << 7) | ((r & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
 571                             case BGR: pixel = ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
 572                         }
 573                         XPutPixel( data_image, x, y, pixel );
 574                         break;
 575                     }
 576                     case 16:
 577                     {
 578                         // I actually don't know if for 16-bit displays, it is alway the green
 579                         // component or the second component which has 6 bits.
 580                         int pixel = 0;
 581                         switch (b_o)
 582                         {
 583                             case RGB: pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
 584                             case RBG: pixel = ((r & 0xf8) << 8) | ((b & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
 585                             case GRB: pixel = ((g & 0xf8) << 8) | ((r & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
 586                             case GBR: pixel = ((g & 0xf8) << 8) | ((b & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
 587                             case BRG: pixel = ((b & 0xf8) << 8) | ((r & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
 588                             case BGR: pixel = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
 589                         }
 590                         XPutPixel( data_image, x, y, pixel );
 591                         break;
 592                     }
 593                     case 32:
 594                     case 24:
 595                     {
 596                         int pixel = 0;
 597                         switch (b_o)
 598                         {
 599                             case RGB: pixel = (r << 16) | (g << 8) | b; break;
 600                             case RBG: pixel = (r << 16) | (b << 8) | g; break;
 601                             case BRG: pixel = (b << 16) | (r << 8) | g; break;
 602                             case BGR: pixel = (b << 16) | (g << 8) | r; break;
 603                             case GRB: pixel = (g << 16) | (r << 8) | b; break;
 604                             case GBR: pixel = (g << 16) | (b << 8) | r; break;
 605                         }
 606                         XPutPixel( data_image, x, y, pixel );
 607                     }
 608                     default: break;
 609                 }
 610             } // for
 611         }  // for
 612
 613         // Blit picture
 614
 615         GC gc = XCreateGC( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, 0, NULL );
 616         XPutImage( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, gc, data_image, 0, 0, 0, 0, width, height );
 617
 618         XDestroyImage( data_image );
 619         XFreeGC( xdisplay, gc );
 620
 621         // Blit mask
 622
 623         if (image.HasMask())
 624         {
 625             GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
 626             XPutImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), gc, data_image, 0, 0, 0, 0, width, height );
 627
 628             XDestroyImage( mask_image );
 629             XFreeGC( xdisplay, gc );
 630         }
 631     }
 632
 633     return TRUE;
 634 }
 635
 636 static void wxCalcPrecAndShift( unsigned long mask, int *shift, int *prec )
 637 {
 638   *shift = 0;
 639   *prec = 0;
 640
 641   while (!(mask & 0x1))
 642     {
 643       (*shift)++;
 644       mask >>= 1;
 645     }
 646
 647   while (mask & 0x1)
 648     {
 649       (*prec)++;
 650       mask >>= 1;
 651     }
 652 }
 653
 654 wxImage wxBitmap::ConvertToImage() const
 655 {
 656     wxImage image;
 657
 658     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 659
 660     Display *xdisplay = (Display*) M_BMPDATA->m_display;
 661     wxASSERT_MSG( xdisplay, wxT("No display") );
 662
 663     int xscreen = DefaultScreen( xdisplay );
 664     Visual* xvisual = DefaultVisual( xdisplay, xscreen );
 665
 666     int bpp = DefaultDepth( xdisplay, xscreen );
 667
 668     XImage *x_image = NULL;
 669     if (GetPixmap())
 670     {
 671         x_image = XGetImage( xdisplay, (Pixmap) GetPixmap(),
 672             0, 0,
 673             GetWidth(), GetHeight(),
 674             AllPlanes, ZPixmap );
 675     } else
 676     if (GetBitmap())
 677     {
 678         x_image = XGetImage( xdisplay, (Pixmap) GetBitmap(),
 679             0, 0,
 680             GetWidth(), GetHeight(),
 681             AllPlanes, ZPixmap );
 682     } else
 683     {
 684         wxFAIL_MSG( wxT("Ill-formed bitmap") );
 685     }
 686
 687     wxCHECK_MSG( x_image, wxNullImage, wxT("couldn't create image") );
 688
 689     image.Create( GetWidth(), GetHeight() );
 690     char unsigned *data = image.GetData();
 691
 692     if (!data)
 693     {
 694         XDestroyImage( x_image );
 695         wxFAIL_MSG( wxT("couldn't create image") );
 696         return wxNullImage;
 697     }
 698
 699     XImage *x_image_mask = NULL;
 700     if (GetMask())
 701     {
 702         x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(),
 703             0, 0,
 704             GetWidth(), GetHeight(),
 705             AllPlanes, ZPixmap );
 706
 707         image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
 708     }
 709
 710     int red_shift_right = 0;
 711     int green_shift_right = 0;
 712     int blue_shift_right = 0;
 713     int red_shift_left = 0;
 714     int green_shift_left = 0;
 715     int blue_shift_left = 0;
 716     bool use_shift = FALSE;
 717
 718     if (GetPixmap())
 719     {
 720         // Retrieve info
 721
 722         XVisualInfo vinfo_template;
 723         XVisualInfo *vi;
 724
 725         vinfo_template.visual = xvisual;
 726         vinfo_template.visualid = XVisualIDFromVisual( xvisual );
 727         vinfo_template.depth = bpp;
 728         int nitem = 0;
 729
 730         vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
 731         wxASSERT_MSG( vi, wxT("No visual info") );
 732
 733         int red_prec,green_prec,blue_prec;
 734         int red_shift,green_shift,blue_shift;
 735         wxCalcPrecAndShift( vi->red_mask, &red_shift, &red_prec );
 736         wxCalcPrecAndShift( vi->green_mask, &green_shift, &green_prec );
 737         wxCalcPrecAndShift( vi->blue_mask, &blue_shift, &blue_prec );
 738         if (bpp == 16) bpp = red_prec + green_prec + blue_prec;
 739
 740         red_shift_right = red_shift;
 741         red_shift_left = 8-red_prec;
 742         green_shift_right = green_shift;
 743         green_shift_left = 8-green_prec;
 744         blue_shift_right = blue_shift;
 745         blue_shift_left = 8-blue_prec;
 746
 747 #if 0
 748         use_shift = (vi->visual->c_class == TrueColor) || (vi->visual->c_class == DirectColor);
 749 #else
 750         use_shift = TRUE;
 751 #endif
 752
 753         XFree( vi );
 754     }
 755     if (GetBitmap())
 756     {
 757         bpp = 1;
 758     }
 759
 760
 761 //    GdkColormap *cmap = gtk_widget_get_default_colormap();
 762
 763     long pos = 0;
 764     for (int j = 0; j < GetHeight(); j++)
 765     {
 766         for (int i = 0; i < GetWidth(); i++)
 767         {
 768             unsigned long pixel = XGetPixel( x_image, i, j );
 769             if (bpp == 1)
 770             {
 771                 if (pixel == 0)
 772                 {
 773                     data[pos]   = 0;
 774                     data[pos+1] = 0;
 775                     data[pos+2] = 0;
 776                 }
 777                 else
 778                 {
 779                     data[pos]   = 255;
 780                     data[pos+1] = 255;
 781                     data[pos+2] = 255;
 782                 }
 783             }
 784             else if (use_shift)
 785             {
 786                 data[pos] =   (pixel >> red_shift_right)   << red_shift_left;
 787                 data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
 788                 data[pos+2] = (pixel >> blue_shift_right)  << blue_shift_left;
 789             }
 790 #if 0
 791             else if (cmap->colors)
 792             {
 793                 data[pos] =   cmap->colors[pixel].red   >> 8;
 794                 data[pos+1] = cmap->colors[pixel].green >> 8;
 795                 data[pos+2] = cmap->colors[pixel].blue  >> 8;
 796             }
 797 #endif
 798             else
 799             {
 800                 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
 801             }
 802
 803             if (x_image_mask)
 804             {
 805                 int mask_pixel = XGetPixel( x_image_mask, i, j );
 806                 if (mask_pixel == 0)
 807                 {
 808                     data[pos] = 16;
 809                     data[pos+1] = 16;
 810                     data[pos+2] = 16;
 811                 }
 812             }
 813
 814             pos += 3;
 815         }
 816     }
 817
 818     XDestroyImage( x_image );
 819     if (x_image_mask) XDestroyImage( x_image_mask );
 820
 821     return image;
 822 }
 823
 824 wxBitmap::wxBitmap( const wxBitmap& bmp )
 825 {
 826     Ref( bmp );
 827 }
 828
 829 wxBitmap::wxBitmap( const wxString &filename, int type )
 830 {
 831     LoadFile( filename, type );
 832 }
 833
 834 wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth) )
 835 {
 836     m_refData = new wxBitmapRefData();
 837
 838     M_BMPDATA->m_display = wxGlobalDisplay();
 839
 840     Display *xdisplay = (Display*) M_BMPDATA->m_display;
 841
 842     int xscreen = DefaultScreen( xdisplay );
 843     Window xroot = RootWindow( xdisplay, xscreen );
 844
 845     M_BMPDATA->m_mask = (wxMask *) NULL;
 846     M_BMPDATA->m_bitmap = (WXPixmap) XCreateBitmapFromData( xdisplay, xroot, (char *) bits, width, height );
 847     M_BMPDATA->m_width = width;
 848     M_BMPDATA->m_height = height;
 849     M_BMPDATA->m_bpp = 1;
 850
 851     wxCHECK_RET( M_BMPDATA->m_bitmap, wxT("couldn't create bitmap") );
 852 }
 853
 854 wxBitmap::~wxBitmap()
 855 {
 856 }
 857
 858 wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
 859 {
 860     if ( m_refData != bmp.m_refData )
 861         Ref( bmp );
 862
 863     return *this;
 864 }
 865
 866 bool wxBitmap::operator == ( const wxBitmap& bmp ) const
 867 {
 868     return m_refData == bmp.m_refData;
 869 }
 870
 871 bool wxBitmap::operator != ( const wxBitmap& bmp ) const
 872 {
 873     return m_refData != bmp.m_refData;
 874 }
 875
 876 bool wxBitmap::Ok() const
 877 {
 878     return (m_refData != NULL);
 879 }
 880
 881 int wxBitmap::GetHeight() const
 882 {
 883     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 884
 885     return M_BMPDATA->m_height;
 886 }
 887
 888 int wxBitmap::GetWidth() const
 889 {
 890     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 891
 892     return M_BMPDATA->m_width;
 893 }
 894
 895 int wxBitmap::GetDepth() const
 896 {
 897     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 898
 899     return M_BMPDATA->m_bpp;
 900 }
 901
 902 wxMask *wxBitmap::GetMask() const
 903 {
 904     wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
 905
 906     return M_BMPDATA->m_mask;
 907 }
 908
 909 void wxBitmap::SetMask( wxMask *mask )
 910 {
 911     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 912
 913     if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 914
 915     M_BMPDATA->m_mask = mask;
 916 }
 917
 918 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 919 {
 920     *this = icon;
 921     return TRUE;
 922 }
 923
 924 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 925 {
 926     wxCHECK_MSG( Ok() &&
 927                  (rect.x >= 0) && (rect.y >= 0) &&
 928                  (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
 929                  wxNullBitmap, wxT("invalid bitmap or bitmap region") );
 930
 931     wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
 932     wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
 933
 934
 935     wxFAIL_MSG( "wxBitmap::GetSubBitmap not yet implemented" );
 936
 937 #if 0
 938     if (ret.GetPixmap())
 939     {
 940         GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
 941         gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
 942         gdk_gc_destroy( gc );
 943     }
 944     else
 945     {
 946         GdkGC *gc = gdk_gc_new( ret.GetBitmap() );
 947         gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
 948         gdk_gc_destroy( gc );
 949     }
 950
 951     if (GetMask())
 952     {
 953         wxMask *mask = new wxMask;
 954         mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 );
 955
 956         GdkGC *gc = gdk_gc_new( mask->m_bitmap );
 957         gdk_wx_draw_bitmap( mask->m_bitmap, gc, M_BMPDATA->m_mask->m_bitmap, 0, 0, rect.x, rect.y, rect.width, rect.height );
 958         gdk_gc_destroy( gc );
 959
 960         ret.SetMask( mask );
 961     }
 962 #endif
 963
 964     return ret;
 965 }
 966
 967 bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) )
 968 {
 969     wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
 970
 971     // Try to save the bitmap via wxImage handlers:
 972     {
 973         wxImage image( *this );
 974         if (image.Ok()) return image.SaveFile( name, type );
 975     }
 976
 977     return FALSE;
 978 }
 979
 980 bool wxBitmap::LoadFile( const wxString &name, int type )
 981 {
 982     UnRef();
 983
 984     if (!wxFileExists(name)) return FALSE;
 985
 986
 987     if (type == wxBITMAP_TYPE_XPM)
 988     {
 989 #if wxUSE_XPM
 990 #if wxHAVE_LIB_XPM
 991         m_refData = new wxBitmapRefData();
 992
 993         M_BMPDATA->m_display = wxGlobalDisplay();
 994
 995         Display *xdisplay = (Display*) M_BMPDATA->m_display;
 996
 997         int xscreen = DefaultScreen( xdisplay );
 998         Window xroot = RootWindow( xdisplay, xscreen );
 999
1000         int bpp = DefaultDepth( xdisplay, xscreen );
1001
1002         XpmAttributes xpmAttr;
1003         xpmAttr.valuemask = XpmReturnInfos;    // nothing yet, but get infos back
1004
1005         Pixmap pixmap;
1006         Pixmap mask = 0;
1007
1008         int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot, (char*) name.c_str(), &pixmap, &mask, &xpmAttr);
1009
1010         if (ErrorStatus == XpmSuccess)
1011         {
1012             M_BMPDATA->m_width = xpmAttr.width;
1013             M_BMPDATA->m_height = xpmAttr.height;
1014
1015             M_BMPDATA->m_bpp = bpp;  // mono as well?
1016
1017             XpmFreeAttributes(&xpmAttr);
1018
1019             M_BMPDATA->m_bitmap = (WXPixmap) pixmap;
1020
1021             if (mask)
1022             {
1023                 M_BMPDATA->m_mask = new wxMask;
1024                 M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask );
1025                 M_BMPDATA->m_mask->SetDisplay( xdisplay );
1026             }
1027         }
1028         else
1029         {
1030             UnRef();
1031
1032             return FALSE;
1033         }
1034 #else
1035 #if wxUSE_STREAMS
1036         wxXPMDecoder decoder;
1037         wxFileInputStream stream(name);
1038         if (stream.Ok())
1039         {
1040             wxImage image(decoder.Read(stream));
1041             if (image.Ok())
1042                 return CreateFromImage(image);
1043             else
1044                 return FALSE;
1045         }
1046         else
1047             return FALSE;
1048 #else
1049         return FALSE;
1050 #endif
1051         // wxUSE_STREAMS
1052 #endif
1053         // wxHAVE_LIB_XPM
1054 #endif
1055         // wxUSE_XPM
1056         return FALSE;
1057     }
1058     else // try if wxImage can load it
1059     {
1060         wxImage image;
1061         if (!image.LoadFile( name, type )) return FALSE;
1062         if (image.Ok()) *this = image.ConvertToBitmap();
1063         else return FALSE;
1064     }
1065
1066     return TRUE;
1067 }
1068
1069 wxPalette *wxBitmap::GetPalette() const
1070 {
1071     if (!Ok()) return (wxPalette *) NULL;
1072
1073     return M_BMPDATA->m_palette;
1074 }
1075
1076 void wxBitmap::SetHeight( int height )
1077 {
1078     if (!m_refData) m_refData = new wxBitmapRefData();
1079
1080     M_BMPDATA->m_height = height;
1081 }
1082
1083 void wxBitmap::SetWidth( int width )
1084 {
1085     if (!m_refData) m_refData = new wxBitmapRefData();
1086
1087     M_BMPDATA->m_width = width;
1088 }
1089
1090 void wxBitmap::SetDepth( int depth )
1091 {
1092     if (!m_refData) m_refData = new wxBitmapRefData();
1093
1094     M_BMPDATA->m_bpp = depth;
1095 }
1096
1097 void wxBitmap::SetPixmap( WXPixmap pixmap )
1098 {
1099     if (!m_refData) m_refData = new wxBitmapRefData();
1100
1101     M_BMPDATA->m_pixmap = pixmap;
1102 }
1103
1104 void wxBitmap::SetBitmap( WXPixmap bitmap )
1105 {
1106     if (!m_refData) m_refData = new wxBitmapRefData();
1107
1108     M_BMPDATA->m_bitmap = bitmap;
1109 }
1110
1111 WXPixmap wxBitmap::GetPixmap() const
1112 {
1113     wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1114
1115     return M_BMPDATA->m_pixmap;
1116 }
1117
1118 WXPixmap wxBitmap::GetBitmap() const
1119 {
1120     wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1121
1122     return M_BMPDATA->m_bitmap;
1123 }
1124
1125 WXDisplay *wxBitmap::GetDisplay() const
1126 {
1127     wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") );
1128
1129     return M_BMPDATA->m_display;
1130 }
1131