src/gtk/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/bitmap.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #include "wx/bitmap.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/icon.h"
  17     #include "wx/image.h"
  18     #include "wx/colour.h"
  19 #endif
  20
  21 #include "wx/rawbmp.h"
  22
  23 #include "wx/gtk/private/object.h"
  24
  25 #include <gtk/gtk.h>
  26
  27 extern GtkWidget *wxGetRootWindow();
  28
  29 static void PixmapToPixbuf(GdkPixmap* pixmap, GdkPixbuf* pixbuf, int w, int h)
  30 {
  31     gdk_pixbuf_get_from_drawable(pixbuf, pixmap, NULL, 0, 0, 0, 0, w, h);
  32     if (gdk_drawable_get_depth(pixmap) == 1)
  33     {
  34         // invert to match XBM convention
  35         guchar* p = gdk_pixbuf_get_pixels(pixbuf);
  36         const int inc = 3 + int(gdk_pixbuf_get_has_alpha(pixbuf) != 0);
  37         const int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - w * inc;
  38         for (int y = h; y; y--, p += rowpad)
  39             for (int x = w; x; x--, p += inc)
  40             {
  41                 // pixels are either (0,0,0) or (0xff,0xff,0xff)
  42                 p[0] = ~p[0];
  43                 p[1] = ~p[1];
  44                 p[2] = ~p[2];
  45             }
  46     }
  47 }
  48
  49 static void MaskToAlpha(GdkPixmap* mask, GdkPixbuf* pixbuf, int w, int h)
  50 {
  51     GdkPixbuf* mask_pixbuf = gdk_pixbuf_get_from_drawable(
  52         NULL, mask, NULL, 0, 0, 0, 0, w, h);
  53     guchar* p = gdk_pixbuf_get_pixels(pixbuf) + 3;
  54     const guchar* mask_data = gdk_pixbuf_get_pixels(mask_pixbuf);
  55     const int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - w * 4;
  56     const int mask_rowpad = gdk_pixbuf_get_rowstride(mask_pixbuf) - w * 3;
  57     for (int y = h; y; y--, p += rowpad, mask_data += mask_rowpad)
  58     {
  59         for (int x = w; x; x--, p += 4, mask_data += 3)
  60         {
  61             *p = 255;
  62             // no need to test all 3 components,
  63             //   pixels are either (0,0,0) or (0xff,0xff,0xff)
  64             if (mask_data[0] == 0)
  65                 *p = 0;
  66         }
  67     }
  68     g_object_unref(mask_pixbuf);
  69 }
  70
  71 //-----------------------------------------------------------------------------
  72 // wxMask
  73 //-----------------------------------------------------------------------------
  74
  75 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxMaskBase)
  76
  77 wxMask::wxMask()
  78 {
  79     m_bitmap = NULL;
  80 }
  81
  82 wxMask::wxMask(const wxMask& mask)
  83 {
  84     if ( !mask.m_bitmap )
  85     {
  86         m_bitmap = NULL;
  87         return;
  88     }
  89
  90     // create a copy of an existing mask
  91     gint w, h;
  92     gdk_drawable_get_size(mask.m_bitmap, &w, &h);
  93     m_bitmap = gdk_pixmap_new(mask.m_bitmap, w, h, 1);
  94
  95     wxGtkObject<GdkGC> gc(gdk_gc_new(m_bitmap));
  96     gdk_draw_drawable(m_bitmap, gc, mask.m_bitmap, 0, 0, 0, 0, -1, -1);
  97 }
  98
  99 wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
 100 {
 101     m_bitmap = NULL;
 102     InitFromColour(bitmap, colour);
 103 }
 104
 105 #if wxUSE_PALETTE
 106 wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
 107 {
 108     m_bitmap = NULL;
 109     Create( bitmap, paletteIndex );
 110 }
 111 #endif // wxUSE_PALETTE
 112
 113 wxMask::wxMask( const wxBitmap& bitmap )
 114 {
 115     m_bitmap = NULL;
 116     InitFromMonoBitmap(bitmap);
 117 }
 118
 119 wxMask::~wxMask()
 120 {
 121     if (m_bitmap)
 122         g_object_unref (m_bitmap);
 123 }
 124
 125 void wxMask::FreeData()
 126 {
 127     if (m_bitmap)
 128     {
 129         g_object_unref (m_bitmap);
 130         m_bitmap = NULL;
 131     }
 132 }
 133
 134 bool wxMask::InitFromColour(const wxBitmap& bitmap, const wxColour& colour)
 135 {
 136     const int w = bitmap.GetWidth();
 137     const int h = bitmap.GetHeight();
 138
 139     // create mask as XBM format bitmap
 140
 141     // one bit per pixel, each row starts on a byte boundary
 142     const size_t out_size = size_t((w + 7) / 8) * unsigned(h);
 143     wxByte* out = new wxByte[out_size];
 144     // set bits are unmasked
 145     memset(out, 0xff, out_size);
 146     unsigned bit_index = 0;
 147     if (bitmap.HasPixbuf())
 148     {
 149         const wxByte r_mask = colour.Red();
 150         const wxByte g_mask = colour.Green();
 151         const wxByte b_mask = colour.Blue();
 152         GdkPixbuf* pixbuf = bitmap.GetPixbuf();
 153         const wxByte* in = gdk_pixbuf_get_pixels(pixbuf);
 154         const int inc = 3 + int(gdk_pixbuf_get_has_alpha(pixbuf) != 0);
 155         const int rowpadding = gdk_pixbuf_get_rowstride(pixbuf) - inc * w;
 156         for (int y = 0; y < h; y++, in += rowpadding)
 157         {
 158             for (int x = 0; x < w; x++, in += inc, bit_index++)
 159                 if (in[0] == r_mask && in[1] == g_mask && in[2] == b_mask)
 160                     out[bit_index >> 3] ^= 1 << (bit_index & 7);
 161             // move index to next byte boundary
 162             bit_index = (bit_index + 7) & ~7u;
 163         }
 164     }
 165     else
 166     {
 167         GdkImage* image = gdk_drawable_get_image(bitmap.GetPixmap(), 0, 0, w, h);
 168         GdkColormap* colormap = gdk_image_get_colormap(image);
 169         guint32 mask_pixel;
 170         if (colormap == NULL)
 171             // mono bitmap, white is pixel value 0
 172             mask_pixel = guint32(colour.Red() != 255 || colour.Green() != 255 || colour.Blue() != 255);
 173         else
 174         {
 175             wxColor c(colour);
 176             c.CalcPixel(colormap);
 177             mask_pixel = c.GetPixel();
 178         }
 179         for (int y = 0; y < h; y++)
 180         {
 181             for (int x = 0; x < w; x++, bit_index++)
 182                 if (gdk_image_get_pixel(image, x, y) == mask_pixel)
 183                     out[bit_index >> 3] ^= 1 << (bit_index & 7);
 184             bit_index = (bit_index + 7) & ~7u;
 185         }
 186         g_object_unref(image);
 187     }
 188     m_bitmap = gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h);
 189     delete[] out;
 190     return true;
 191 }
 192
 193 bool wxMask::InitFromMonoBitmap(const wxBitmap& bitmap)
 194 {
 195     if (!bitmap.IsOk()) return false;
 196
 197     wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
 198
 199     m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
 200
 201     if (!m_bitmap) return false;
 202
 203     wxGtkObject<GdkGC> gc(gdk_gc_new( m_bitmap ));
 204     gdk_gc_set_function(gc, GDK_COPY_INVERT);
 205     gdk_draw_drawable(m_bitmap, gc, bitmap.GetPixmap(), 0, 0, 0, 0, bitmap.GetWidth(), bitmap.GetHeight());
 206
 207     return true;
 208 }
 209
 210 GdkBitmap *wxMask::GetBitmap() const
 211 {
 212     return m_bitmap;
 213 }
 214
 215 //-----------------------------------------------------------------------------
 216 // wxBitmapRefData
 217 //-----------------------------------------------------------------------------
 218
 219 class wxBitmapRefData: public wxGDIRefData
 220 {
 221 public:
 222     wxBitmapRefData(int width, int height, int depth);
 223     virtual ~wxBitmapRefData();
 224
 225     virtual bool IsOk() const;
 226
 227     GdkPixmap      *m_pixmap;
 228     GdkPixbuf      *m_pixbuf;
 229     wxMask         *m_mask;
 230     int             m_width;
 231     int             m_height;
 232     int             m_bpp;
 233     bool m_alphaRequested;
 234 };
 235
 236 wxBitmapRefData::wxBitmapRefData(int width, int height, int depth)
 237 {
 238     m_pixmap = NULL;
 239     m_pixbuf = NULL;
 240     m_mask = NULL;
 241     m_width = width;
 242     m_height = height;
 243     m_bpp = depth;
 244     if (m_bpp < 0)
 245         m_bpp = gdk_drawable_get_depth(wxGetRootWindow()->window);
 246     m_alphaRequested = depth == 32;
 247 }
 248
 249 wxBitmapRefData::~wxBitmapRefData()
 250 {
 251     if (m_pixmap)
 252         g_object_unref (m_pixmap);
 253     if (m_pixbuf)
 254         g_object_unref (m_pixbuf);
 255     delete m_mask;
 256 }
 257
 258 bool wxBitmapRefData::IsOk() const
 259 {
 260     return m_bpp != 0;
 261 }
 262
 263 //-----------------------------------------------------------------------------
 264 // wxBitmap
 265 //-----------------------------------------------------------------------------
 266
 267 #define M_BMPDATA static_cast<wxBitmapRefData*>(m_refData)
 268
 269 IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
 270
 271 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 272 {
 273     LoadFile(filename, type);
 274 }
 275
 276 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 277 {
 278     wxASSERT(depth == 1);
 279     if (width > 0 && height > 0 && depth == 1)
 280     {
 281         SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, bits, width, height));
 282     }
 283 }
 284
 285 wxBitmap::wxBitmap(const char* const* bits)
 286 {
 287     wxCHECK2_MSG(bits != NULL, return, wxT("invalid bitmap data"));
 288
 289     GdkBitmap* mask = NULL;
 290     SetPixmap(gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window, &mask, NULL, const_cast<char**>(bits)));
 291     if (!M_BMPDATA)
 292         return;
 293
 294     if (M_BMPDATA->m_pixmap != NULL && mask != NULL)
 295     {
 296         M_BMPDATA->m_mask = new wxMask;
 297         M_BMPDATA->m_mask->m_bitmap = mask;
 298     }
 299 }
 300
 301 wxBitmap::~wxBitmap()
 302 {
 303 }
 304
 305 bool wxBitmap::Create( int width, int height, int depth )
 306 {
 307     UnRef();
 308     wxCHECK_MSG(width >= 0 && height >= 0, false, "invalid bitmap size");
 309     m_refData = new wxBitmapRefData(width, height, depth);
 310     return true;
 311 }
 312
 313 #if wxUSE_IMAGE
 314
 315 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 316 {
 317     UnRef();
 318
 319     wxCHECK_MSG( image.IsOk(), false, wxT("invalid image") );
 320     wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") );
 321
 322     if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
 323         return false;
 324
 325     // create pixbuf if image has alpha and requested depth is compatible
 326     if (image.HasAlpha() && (depth == -1 || depth == 32))
 327         return CreateFromImageAsPixbuf(image);
 328
 329     // otherwise create pixmap, if alpha is present it will be converted to mask
 330     return CreateFromImageAsPixmap(image, depth);
 331 }
 332
 333 bool wxBitmap::CreateFromImageAsPixmap(const wxImage& image, int depth)
 334 {
 335     const int w = image.GetWidth();
 336     const int h = image.GetHeight();
 337     if (depth == 1)
 338     {
 339         // create XBM format bitmap
 340
 341         // one bit per pixel, each row starts on a byte boundary
 342         const size_t out_size = size_t((w + 7) / 8) * unsigned(h);
 343         wxByte* out = new wxByte[out_size];
 344         // set bits are black
 345         memset(out, 0xff, out_size);
 346         const wxByte* in = image.GetData();
 347         unsigned bit_index = 0;
 348         for (int y = 0; y < h; y++)
 349         {
 350             for (int x = 0; x < w; x++, in += 3, bit_index++)
 351                 if (in[0] == 255 && in[1] == 255 && in[2] == 255)
 352                     out[bit_index >> 3] ^= 1 << (bit_index & 7);
 353             // move index to next byte boundary
 354             bit_index = (bit_index + 7) & ~7u;
 355         }
 356         SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h));
 357         delete[] out;
 358
 359         if (!M_BMPDATA)     // SetPixmap may have failed
 360             return false;
 361     }
 362     else
 363     {
 364         SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, w, h, depth));
 365         if (!M_BMPDATA)
 366             return false;
 367
 368         wxGtkObject<GdkGC> gc(gdk_gc_new(M_BMPDATA->m_pixmap));
 369         gdk_draw_rgb_image(
 370             M_BMPDATA->m_pixmap, gc,
 371             0, 0, w, h,
 372             GDK_RGB_DITHER_NONE, image.GetData(), w * 3);
 373     }
 374
 375     const wxByte* alpha = image.GetAlpha();
 376     if (alpha != NULL || image.HasMask())
 377     {
 378         // create mask as XBM format bitmap
 379
 380         const size_t out_size = size_t((w + 7) / 8) * unsigned(h);
 381         wxByte* out = new wxByte[out_size];
 382         memset(out, 0xff, out_size);
 383         unsigned bit_index = 0;
 384         if (alpha != NULL)
 385         {
 386             for (int y = 0; y < h; y++)
 387             {
 388                 for (int x = 0; x < w; x++, bit_index++)
 389                     if (*alpha++ < wxIMAGE_ALPHA_THRESHOLD)
 390                         out[bit_index >> 3] ^= 1 << (bit_index & 7);
 391                 bit_index = (bit_index + 7) & ~7u;
 392             }
 393         }
 394         else
 395         {
 396             const wxByte r_mask = image.GetMaskRed();
 397             const wxByte g_mask = image.GetMaskGreen();
 398             const wxByte b_mask = image.GetMaskBlue();
 399             const wxByte* in = image.GetData();
 400             for (int y = 0; y < h; y++)
 401             {
 402                 for (int x = 0; x < w; x++, in += 3, bit_index++)
 403                     if (in[0] == r_mask && in[1] == g_mask && in[2] == b_mask)
 404                         out[bit_index >> 3] ^= 1 << (bit_index & 7);
 405                 bit_index = (bit_index + 7) & ~7u;
 406             }
 407         }
 408         wxMask* mask = new wxMask;
 409         mask->m_bitmap = gdk_bitmap_create_from_data(M_BMPDATA->m_pixmap, (char*)out, w, h);
 410         SetMask(mask);
 411         delete[] out;
 412     }
 413     return IsOk();
 414 }
 415
 416 bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
 417 {
 418     wxASSERT(image.HasAlpha());
 419
 420     int width = image.GetWidth();
 421     int height = image.GetHeight();
 422
 423     Create(width, height, 32);
 424     GdkPixbuf* pixbuf = GetPixbuf();
 425     if (!pixbuf)
 426         return false;
 427
 428     // Copy the data:
 429     const unsigned char* in = image.GetData();
 430     unsigned char *out = gdk_pixbuf_get_pixels(pixbuf);
 431     unsigned char *alpha = image.GetAlpha();
 432
 433     int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
 434
 435     for (int y = 0; y < height; y++, out += rowpad)
 436     {
 437         for (int x = 0; x < width; x++, alpha++, out += 4, in += 3)
 438         {
 439             out[0] = in[0];
 440             out[1] = in[1];
 441             out[2] = in[2];
 442             out[3] = *alpha;
 443         }
 444     }
 445
 446     return true;
 447 }
 448
 449 wxImage wxBitmap::ConvertToImage() const
 450 {
 451     wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
 452
 453     const int w = GetWidth();
 454     const int h = GetHeight();
 455     wxImage image(w, h, false);
 456     unsigned char *data = image.GetData();
 457
 458     wxCHECK_MSG(data != NULL, wxNullImage, wxT("couldn't create image") );
 459
 460     // prefer pixbuf if available, it will preserve alpha and should be quicker
 461     if (HasPixbuf())
 462     {
 463         GdkPixbuf *pixbuf = GetPixbuf();
 464         unsigned char* alpha = NULL;
 465         if (gdk_pixbuf_get_has_alpha(pixbuf))
 466         {
 467             image.SetAlpha();
 468             alpha = image.GetAlpha();
 469         }
 470         const unsigned char* in = gdk_pixbuf_get_pixels(pixbuf);
 471         unsigned char *out = data;
 472         const int inc = 3 + int(alpha != NULL);
 473         const int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - inc * w;
 474
 475         for (int y = 0; y < h; y++, in += rowpad)
 476         {
 477             for (int x = 0; x < w; x++, in += inc, out += 3)
 478             {
 479                 out[0] = in[0];
 480                 out[1] = in[1];
 481                 out[2] = in[2];
 482                 if (alpha != NULL)
 483                     *alpha++ = in[3];
 484             }
 485         }
 486     }
 487     else
 488     {
 489         GdkPixmap* pixmap = GetPixmap();
 490         GdkPixmap* pixmap_invert = NULL;
 491         if (GetDepth() == 1)
 492         {
 493             // mono bitmaps are inverted, i.e. 0 is white
 494             pixmap_invert = gdk_pixmap_new(pixmap, w, h, 1);
 495             wxGtkObject<GdkGC> gc(gdk_gc_new(pixmap_invert));
 496             gdk_gc_set_function(gc, GDK_COPY_INVERT);
 497             gdk_draw_drawable(pixmap_invert, gc, pixmap, 0, 0, 0, 0, w, h);
 498             pixmap = pixmap_invert;
 499         }
 500         // create a pixbuf which shares data with the wxImage
 501         GdkPixbuf* pixbuf = gdk_pixbuf_new_from_data(
 502             data, GDK_COLORSPACE_RGB, false, 8, w, h, 3 * w, NULL, NULL);
 503
 504         gdk_pixbuf_get_from_drawable(pixbuf, pixmap, NULL, 0, 0, 0, 0, w, h);
 505
 506         g_object_unref(pixbuf);
 507         if (pixmap_invert != NULL)
 508             g_object_unref(pixmap_invert);
 509     }
 510     // convert mask, unless there is already alpha
 511     if (GetMask() && !image.HasAlpha())
 512     {
 513         // we hard code the mask colour for now but we could also make an
 514         // effort (and waste time) to choose a colour not present in the
 515         // image already to avoid having to fudge the pixels below --
 516         // whether it's worth to do it is unclear however
 517         const int MASK_RED = 1;
 518         const int MASK_GREEN = 2;
 519         const int MASK_BLUE = 3;
 520         const int MASK_BLUE_REPLACEMENT = 2;
 521
 522         image.SetMaskColour(MASK_RED, MASK_GREEN, MASK_BLUE);
 523         GdkImage* image_mask = gdk_drawable_get_image(GetMask()->GetBitmap(), 0, 0, w, h);
 524
 525         for (int y = 0; y < h; y++)
 526         {
 527             for (int x = 0; x < w; x++, data += 3)
 528             {
 529                 if (gdk_image_get_pixel(image_mask, x, y) == 0)
 530                 {
 531                     data[0] = MASK_RED;
 532                     data[1] = MASK_GREEN;
 533                     data[2] = MASK_BLUE;
 534                 }
 535                 else if (data[0] == MASK_RED && data[1] == MASK_GREEN && data[2] == MASK_BLUE)
 536                 {
 537                     // we have to fudge the colour a bit to prevent
 538                     // this pixel from appearing transparent
 539                     data[2] = MASK_BLUE_REPLACEMENT;
 540                 }
 541             }
 542         }
 543         g_object_unref(image_mask);
 544     }
 545
 546     return image;
 547 }
 548
 549 #endif // wxUSE_IMAGE
 550
 551 int wxBitmap::GetHeight() const
 552 {
 553     wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 554
 555     return M_BMPDATA->m_height;
 556 }
 557
 558 int wxBitmap::GetWidth() const
 559 {
 560     wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 561
 562     return M_BMPDATA->m_width;
 563 }
 564
 565 int wxBitmap::GetDepth() const
 566 {
 567     wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 568
 569     return M_BMPDATA->m_bpp;
 570 }
 571
 572 wxMask *wxBitmap::GetMask() const
 573 {
 574     wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 575
 576     return M_BMPDATA->m_mask;
 577 }
 578
 579 void wxBitmap::SetMask( wxMask *mask )
 580 {
 581     wxCHECK_RET( IsOk(), wxT("invalid bitmap") );
 582
 583     AllocExclusive();
 584     delete M_BMPDATA->m_mask;
 585     M_BMPDATA->m_mask = mask;
 586 }
 587
 588 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 589 {
 590     *this = icon;
 591     return IsOk();
 592 }
 593
 594 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 595 {
 596     wxBitmap ret;
 597
 598     wxCHECK_MSG(IsOk(), ret, wxT("invalid bitmap"));
 599
 600     const int w = rect.width;
 601     const int h = rect.height;
 602     const wxBitmapRefData* bmpData = M_BMPDATA;
 603
 604     wxCHECK_MSG(rect.x >= 0 && rect.y >= 0 &&
 605                 rect.x + w <= bmpData->m_width &&
 606                 rect.y + h <= bmpData->m_height,
 607                 ret, wxT("invalid bitmap region"));
 608
 609     wxBitmapRefData* newRef = new wxBitmapRefData(*bmpData);
 610     ret.m_refData = newRef;
 611     newRef->m_width = w;
 612     newRef->m_height = h;
 613
 614     if (bmpData->m_pixbuf)
 615     {
 616         GdkPixbuf* pixbuf =
 617             gdk_pixbuf_new_subpixbuf(bmpData->m_pixbuf, rect.x, rect.y, w, h);
 618         newRef->m_pixbuf = gdk_pixbuf_copy(pixbuf);
 619         g_object_unref(pixbuf);
 620     }
 621     if (bmpData->m_pixmap)
 622     {
 623         newRef->m_pixmap = gdk_pixmap_new(bmpData->m_pixmap, w, h, -1);
 624         GdkGC* gc = gdk_gc_new(newRef->m_pixmap);
 625         gdk_draw_drawable(
 626             newRef->m_pixmap, gc, bmpData->m_pixmap, rect.x, rect.y, 0, 0, w, h);
 627         g_object_unref(gc);
 628     }
 629     newRef->m_mask = NULL;
 630     if (bmpData->m_mask && bmpData->m_mask->m_bitmap)
 631     {
 632         GdkPixmap* sub_mask = gdk_pixmap_new(bmpData->m_mask->m_bitmap, w, h, 1);
 633         newRef->m_mask = new wxMask;
 634         newRef->m_mask->m_bitmap = sub_mask;
 635         GdkGC* gc = gdk_gc_new(sub_mask);
 636         gdk_draw_drawable(
 637             sub_mask, gc, bmpData->m_mask->m_bitmap, rect.x, rect.y, 0, 0, w, h);
 638         g_object_unref(gc);
 639     }
 640
 641     return ret;
 642 }
 643
 644 bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalette *WXUNUSED(palette) ) const
 645 {
 646     wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 647
 648 #if wxUSE_IMAGE
 649     wxImage image = ConvertToImage();
 650     if (image.IsOk() && image.SaveFile(name, type))
 651         return true;
 652 #endif
 653     const char* type_name = NULL;
 654     switch (type)
 655     {
 656         case wxBITMAP_TYPE_BMP:  type_name = "bmp";  break;
 657         case wxBITMAP_TYPE_ICO:  type_name = "ico";  break;
 658         case wxBITMAP_TYPE_JPEG: type_name = "jpeg"; break;
 659         case wxBITMAP_TYPE_PNG:  type_name = "png";  break;
 660         default: break;
 661     }
 662     return type_name &&
 663         gdk_pixbuf_save(GetPixbuf(), name.fn_str(), type_name, NULL, NULL);
 664 }
 665
 666 bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
 667 {
 668 #if wxUSE_IMAGE
 669     wxImage image;
 670     if (image.LoadFile(name, type) && image.IsOk())
 671         *this = wxBitmap(image);
 672     else
 673 #endif
 674     {
 675         UnRef();
 676         GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file(name.fn_str(), NULL);
 677         if (pixbuf)
 678             SetPixbuf(pixbuf);
 679     }
 680
 681     return IsOk();
 682 }
 683
 684 #if wxUSE_PALETTE
 685 wxPalette *wxBitmap::GetPalette() const
 686 {
 687     return NULL;
 688 }
 689
 690 void wxBitmap::SetPalette(const wxPalette& WXUNUSED(palette))
 691 {
 692     // TODO
 693 }
 694 #endif // wxUSE_PALETTE
 695
 696 void wxBitmap::SetHeight( int height )
 697 {
 698     AllocExclusive();
 699     M_BMPDATA->m_height = height;
 700 }
 701
 702 void wxBitmap::SetWidth( int width )
 703 {
 704     AllocExclusive();
 705     M_BMPDATA->m_width = width;
 706 }
 707
 708 void wxBitmap::SetDepth( int depth )
 709 {
 710     AllocExclusive();
 711     M_BMPDATA->m_bpp = depth;
 712 }
 713
 714 void wxBitmap::SetPixmap( GdkPixmap *pixmap )
 715 {
 716     UnRef();
 717
 718     if (!pixmap)
 719         return;
 720
 721     int w, h;
 722     gdk_drawable_get_size(pixmap, &w, &h);
 723     wxBitmapRefData* bmpData = new wxBitmapRefData(w, h, 0);
 724     m_refData = bmpData;
 725     bmpData->m_pixmap = pixmap;
 726     bmpData->m_bpp = gdk_drawable_get_depth(pixmap);
 727 }
 728
 729 GdkPixmap *wxBitmap::GetPixmap() const
 730 {
 731     wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 732
 733     wxBitmapRefData* bmpData = M_BMPDATA;
 734     if (bmpData->m_pixmap)
 735         return bmpData->m_pixmap;
 736
 737     if (bmpData->m_pixbuf)
 738     {
 739         GdkPixmap** mask_pixmap = NULL;
 740         if (gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf))
 741         {
 742             // make new mask from alpha
 743             delete bmpData->m_mask;
 744             bmpData->m_mask = new wxMask;
 745             mask_pixmap = &bmpData->m_mask->m_bitmap;
 746         }
 747         gdk_pixbuf_render_pixmap_and_mask(
 748             bmpData->m_pixbuf, &bmpData->m_pixmap, mask_pixmap, 128);
 749     }
 750     else
 751     {
 752         bmpData->m_pixmap = gdk_pixmap_new(wxGetRootWindow()->window,
 753             bmpData->m_width, bmpData->m_height, bmpData->m_bpp == 1 ? 1 : -1);
 754     }
 755     return bmpData->m_pixmap;
 756 }
 757
 758 bool wxBitmap::HasPixmap() const
 759 {
 760     wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 761
 762     return M_BMPDATA->m_pixmap != NULL;
 763 }
 764
 765 GdkPixbuf *wxBitmap::GetPixbuf() const
 766 {
 767     wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 768
 769     wxBitmapRefData* bmpData = M_BMPDATA;
 770     if (bmpData->m_pixbuf)
 771         return bmpData->m_pixbuf;
 772
 773     const int w = bmpData->m_width;
 774     const int h = bmpData->m_height;
 775     GdkPixmap* mask = NULL;
 776     if (bmpData->m_mask)
 777         mask = bmpData->m_mask->m_bitmap;
 778     const bool useAlpha = bmpData->m_alphaRequested || mask;
 779     bmpData->m_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, useAlpha, 8, w, h);
 780     if (bmpData->m_pixmap)
 781         PixmapToPixbuf(bmpData->m_pixmap, bmpData->m_pixbuf, w, h);
 782     if (mask)
 783         MaskToAlpha(mask, bmpData->m_pixbuf, w, h);
 784     return bmpData->m_pixbuf;
 785 }
 786
 787 bool wxBitmap::HasPixbuf() const
 788 {
 789     wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 790
 791     return M_BMPDATA->m_pixbuf != NULL;
 792 }
 793
 794 void wxBitmap::SetPixbuf(GdkPixbuf* pixbuf)
 795 {
 796     UnRef();
 797
 798     if (!pixbuf)
 799         return;
 800
 801     int depth = -1;
 802     if (gdk_pixbuf_get_has_alpha(pixbuf))
 803         depth = 32;
 804     m_refData = new wxBitmapRefData(
 805         gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), depth);
 806
 807     M_BMPDATA->m_pixbuf = pixbuf;
 808 }
 809
 810 void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
 811 {
 812     if (keep == Pixmap && HasPixbuf())
 813     {
 814         g_object_unref (M_BMPDATA->m_pixbuf);
 815         M_BMPDATA->m_pixbuf = NULL;
 816     }
 817     if (keep == Pixbuf && HasPixmap())
 818     {
 819         g_object_unref (M_BMPDATA->m_pixmap);
 820         M_BMPDATA->m_pixmap = NULL;
 821     }
 822 }
 823
 824 #ifdef wxHAS_RAW_BITMAP
 825 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 826 {
 827     void* bits = NULL;
 828     GdkPixbuf *pixbuf = GetPixbuf();
 829     const bool hasAlpha = HasAlpha();
 830
 831     // allow access if bpp is valid and matches existence of alpha
 832     if ( pixbuf && ((bpp == 24 && !hasAlpha) || (bpp == 32 && hasAlpha)) )
 833     {
 834         data.m_height = gdk_pixbuf_get_height( pixbuf );
 835         data.m_width = gdk_pixbuf_get_width( pixbuf );
 836         data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
 837         bits = gdk_pixbuf_get_pixels(pixbuf);
 838     }
 839     return bits;
 840 }
 841
 842 void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
 843 {
 844 }
 845 #endif // wxHAS_RAW_BITMAP
 846
 847 bool wxBitmap::HasAlpha() const
 848 {
 849     const wxBitmapRefData* bmpData = M_BMPDATA;
 850     return bmpData && (bmpData->m_alphaRequested ||
 851         (bmpData->m_pixbuf && gdk_pixbuf_get_has_alpha(bmpData->m_pixbuf)));
 852 }
 853
 854 wxGDIRefData* wxBitmap::CreateGDIRefData() const
 855 {
 856     return new wxBitmapRefData(0, 0, 0);
 857 }
 858
 859 wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
 860 {
 861     const wxBitmapRefData* oldRef = static_cast<const wxBitmapRefData*>(data);
 862     wxBitmapRefData* newRef = new wxBitmapRefData(*oldRef);
 863     if (oldRef->m_pixmap != NULL)
 864     {
 865         newRef->m_pixmap = gdk_pixmap_new(
 866             oldRef->m_pixmap, oldRef->m_width, oldRef->m_height,
 867             // use pixmap depth, m_bpp may not match
 868             gdk_drawable_get_depth(oldRef->m_pixmap));
 869         wxGtkObject<GdkGC> gc(gdk_gc_new(newRef->m_pixmap));
 870         gdk_draw_drawable(
 871             newRef->m_pixmap, gc, oldRef->m_pixmap, 0, 0, 0, 0, -1, -1);
 872     }
 873     if (oldRef->m_pixbuf != NULL)
 874     {
 875         newRef->m_pixbuf = gdk_pixbuf_copy(oldRef->m_pixbuf);
 876     }
 877     if (oldRef->m_mask != NULL)
 878     {
 879         newRef->m_mask = new wxMask(*oldRef->m_mask);
 880     }
 881
 882     return newRef;
 883 }
 884
 885 /* static */ void wxBitmap::InitStandardHandlers()
 886 {
 887     // TODO: Insert handler based on GdkPixbufs handler later
 888 }