1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/bitmap.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 #include "wx/bitmap.h"
17 #include "wx/palette.h"
21 #include "wx/colour.h"
24 #include "wx/rawbmp.h"
28 //-----------------------------------------------------------------------------
30 //-----------------------------------------------------------------------------
32 extern GtkWidget
*wxGetRootWindow();
34 //-----------------------------------------------------------------------------
36 //-----------------------------------------------------------------------------
38 IMPLEMENT_DYNAMIC_CLASS(wxMask
,wxObject
)
42 m_bitmap
= (GdkBitmap
*) NULL
;
45 wxMask
::wxMask( const wxBitmap
& bitmap
, const wxColour
& colour
)
47 m_bitmap
= (GdkBitmap
*) NULL
;
48 Create( bitmap
, colour
);
52 wxMask
::wxMask( const wxBitmap
& bitmap
, int paletteIndex
)
54 m_bitmap
= (GdkBitmap
*) NULL
;
55 Create( bitmap
, paletteIndex
);
57 #endif // wxUSE_PALETTE
59 wxMask
::wxMask( const wxBitmap
& bitmap
)
61 m_bitmap
= (GdkBitmap
*) NULL
;
68 g_object_unref (m_bitmap
);
71 bool wxMask
::Create( const wxBitmap
& bitmap
,
72 const wxColour
& colour
)
76 g_object_unref (m_bitmap
);
77 m_bitmap
= (GdkBitmap
*) NULL
;
80 const int w
= bitmap
.GetWidth();
81 const int h
= bitmap
.GetHeight();
83 // create mask as XBM format bitmap
85 // one bit per pixel, each row starts on a byte boundary
86 const size_t out_size
= size_t((w
+ 7) / 8) * unsigned(h
);
87 wxByte
* out
= new wxByte
[out_size
];
88 // set bits are unmasked
89 memset(out
, 0xff, out_size
);
90 unsigned bit_index
= 0;
91 if (bitmap
.HasPixbuf())
93 const wxByte r_mask
= colour
.Red();
94 const wxByte g_mask
= colour
.Green();
95 const wxByte b_mask
= colour
.Blue();
96 GdkPixbuf
* pixbuf
= bitmap
.GetPixbuf();
97 const wxByte
* in
= gdk_pixbuf_get_pixels(pixbuf
);
98 const int inc
= 3 + int(gdk_pixbuf_get_has_alpha(pixbuf
) != 0);
99 const int rowpadding
= gdk_pixbuf_get_rowstride(pixbuf
) - inc
* w
;
100 for (int y
= 0; y
< h
; y
++, in
+= rowpadding
)
102 for (int x
= 0; x
< w
; x
++, in
+= inc
, bit_index
++)
103 if (in
[0] == r_mask
&& in
[1] == g_mask
&& in
[2] == b_mask
)
104 out
[bit_index
>> 3] ^= 1 << (bit_index
& 7);
105 // move index to next byte boundary
106 bit_index
= (bit_index
+ 7) & ~7u;
111 GdkImage
* image
= gdk_drawable_get_image(bitmap
.GetPixmap(), 0, 0, w
, h
);
112 GdkColormap
* colormap
= gdk_image_get_colormap(image
);
114 if (colormap
== NULL
)
115 // mono bitmap, white is pixel value 0
116 mask_pixel
= guint32(colour
.Red() != 255 || colour
.Green() != 255 || colour
.Blue() != 255);
120 c
.CalcPixel(colormap
);
121 mask_pixel
= c
.GetPixel();
123 for (int y
= 0; y
< h
; y
++)
125 for (int x
= 0; x
< w
; x
++, bit_index
++)
126 if (gdk_image_get_pixel(image
, x
, y
) == mask_pixel
)
127 out
[bit_index
>> 3] ^= 1 << (bit_index
& 7);
128 bit_index
= (bit_index
+ 7) & ~7u;
130 g_object_unref(image
);
132 m_bitmap
= gdk_bitmap_create_from_data(wxGetRootWindow()->window
, (char*)out
, w
, h
);
138 bool wxMask
::Create( const wxBitmap
& bitmap
, int paletteIndex
)
141 wxPalette
*pal
= bitmap
.GetPalette();
143 wxCHECK_MSG( pal
, false, wxT("Cannot create mask from bitmap without palette") );
145 pal
->GetRGB(paletteIndex
, &r
, &g
, &b
);
147 return Create(bitmap
, wxColour(r
, g
, b
));
149 #endif // wxUSE_PALETTE
151 bool wxMask
::Create( const wxBitmap
& bitmap
)
155 g_object_unref (m_bitmap
);
156 m_bitmap
= (GdkBitmap
*) NULL
;
159 if (!bitmap
.Ok()) return false;
161 wxCHECK_MSG( bitmap
.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
163 m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, bitmap
.GetWidth(), bitmap
.GetHeight(), 1 );
165 if (!m_bitmap
) return false;
167 GdkGC
*gc
= gdk_gc_new( m_bitmap
);
168 gdk_gc_set_function(gc
, GDK_COPY_INVERT
);
169 gdk_draw_drawable(m_bitmap
, gc
, bitmap
.GetPixmap(), 0, 0, 0, 0, bitmap
.GetWidth(), bitmap
.GetHeight());
175 GdkBitmap
*wxMask
::GetBitmap() const
180 //-----------------------------------------------------------------------------
182 //-----------------------------------------------------------------------------
184 class wxBitmapRefData
: public wxObjectRefData
188 virtual ~wxBitmapRefData();
197 wxPalette
*m_palette
;
198 #endif // wxUSE_PALETTE
201 wxBitmapRefData
::wxBitmapRefData()
203 m_pixmap
= (GdkPixmap
*) NULL
;
204 m_pixbuf
= (GdkPixbuf
*) NULL
;
205 m_mask
= (wxMask
*) NULL
;
210 m_palette
= (wxPalette
*) NULL
;
211 #endif // wxUSE_PALETTE
214 wxBitmapRefData
::~wxBitmapRefData()
217 g_object_unref (m_pixmap
);
219 g_object_unref (m_pixbuf
);
223 #endif // wxUSE_PALETTE
226 //-----------------------------------------------------------------------------
228 #define M_BMPDATA wx_static_cast(wxBitmapRefData*, m_refData)
230 IMPLEMENT_DYNAMIC_CLASS(wxBitmap
,wxGDIObject
)
232 wxBitmap
::wxBitmap(int width
, int height
, int depth
)
234 Create(width
, height
, depth
);
237 wxBitmap
::wxBitmap(const wxString
&filename
, wxBitmapType type
)
239 LoadFile(filename
, type
);
242 wxBitmap
::wxBitmap(const char bits
[], int width
, int height
, int depth
)
244 wxASSERT(depth
== 1);
245 if (width
> 0 && height
> 0 && depth
== 1)
247 SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window
, bits
, width
, height
));
249 wxASSERT_MSG( M_BMPDATA
->m_pixmap
, wxT("couldn't create bitmap") );
253 wxBitmap
::wxBitmap(const char* const* bits
)
255 wxCHECK2_MSG(bits
!= NULL
, return, wxT("invalid bitmap data"));
257 GdkBitmap
* mask
= NULL
;
258 SetPixmap(gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window
, &mask
, NULL
, wx_const_cast(char**, bits
)));
260 if (M_BMPDATA
->m_pixmap
!= NULL
&& mask
!= NULL
)
262 M_BMPDATA
->m_mask
= new wxMask
;
263 M_BMPDATA
->m_mask
->m_bitmap
= mask
;
267 wxBitmap
::~wxBitmap()
271 bool wxBitmap
::Create( int width
, int height
, int depth
)
275 if ( width
<= 0 || height
<= 0 )
282 SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB
, true, 8, width
, height
), 32);
288 const GdkVisual
* visual
= wxTheApp
->GetGdkVisual();
290 depth
= visual
->depth
;
292 wxCHECK_MSG(depth
== visual
->depth
, false, wxT("invalid bitmap depth"));
295 SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window
, width
, height
, depth
));
301 wxBitmap wxBitmap
::Rescale(int clipx
, int clipy
, int clipwidth
, int clipheight
, int newx
, int newy
) const
305 wxCHECK_MSG(Ok(), bmp
, wxT("invalid bitmap"));
307 if (newx
==M_BMPDATA
->m_width
&& newy
==M_BMPDATA
->m_height
)
310 int width
= wxMax(newx
, 1);
311 int height
= wxMax(newy
, 1);
312 width
= wxMin(width
, clipwidth
);
313 height
= wxMin(height
, clipheight
);
315 const double scale_x
= double(newx
) / M_BMPDATA
->m_width
;
316 const double scale_y
= double(newy
) / M_BMPDATA
->m_height
;
318 // Converting to pixbuf, scaling with gdk_pixbuf_scale, and converting
319 // back, is faster than scaling pixmap ourselves.
321 // use pixbuf if already available,
322 // otherwise create temporary pixbuf from pixmap
323 GdkPixbuf
* pixbuf
= M_BMPDATA
->m_pixbuf
;
325 g_object_ref(pixbuf
);
327 pixbuf
= gdk_pixbuf_get_from_drawable(
328 NULL
, M_BMPDATA
->m_pixmap
, NULL
,
329 0, 0, 0, 0, M_BMPDATA
->m_width
, M_BMPDATA
->m_height
);
331 // new pixbuf for scaled wxBitmap
332 GdkPixbuf
* pixbuf_scaled
= gdk_pixbuf_new(
333 GDK_COLORSPACE_RGB
, gdk_pixbuf_get_has_alpha(pixbuf
), 8, width
, height
);
335 // GDK_INTERP_NEAREST is the lowest-quality method for continuous-tone
336 // images, but the only one which preserves sharp edges
338 pixbuf
, pixbuf_scaled
,
339 0, 0, width
, height
, clipx
, clipy
, scale_x
, scale_y
,
342 g_object_unref(pixbuf
);
343 bmp
.SetPixbuf(pixbuf_scaled
, M_BMPDATA
->m_bpp
);
345 if (M_BMPDATA
->m_mask
)
347 pixbuf
= gdk_pixbuf_get_from_drawable(
348 NULL
, M_BMPDATA
->m_mask
->m_bitmap
, NULL
,
349 0, 0, 0, 0, M_BMPDATA
->m_width
, M_BMPDATA
->m_height
);
351 pixbuf_scaled
= gdk_pixbuf_new(
352 GDK_COLORSPACE_RGB
, false, 8, width
, height
);
355 pixbuf
, pixbuf_scaled
,
356 0, 0, width
, height
, clipx
, clipy
, scale_x
, scale_y
,
359 g_object_unref(pixbuf
);
361 // use existing functionality to create mask from scaled pixbuf
363 maskbmp
.SetPixbuf(pixbuf_scaled
);
364 bmp
.SetMask(new wxMask(maskbmp
, *wxBLACK
));
369 bool wxBitmap
::CreateFromImage(const wxImage
& image
, int depth
)
373 wxCHECK_MSG( image
.Ok(), false, wxT("invalid image") );
374 wxCHECK_MSG( depth
== -1 || depth
== 1, false, wxT("invalid bitmap depth") );
376 if (image
.GetWidth() <= 0 || image
.GetHeight() <= 0)
379 // create pixbuf if image has alpha and requested depth is compatible
380 if (image
.HasAlpha() && (depth
== -1 || depth
== 32))
381 return CreateFromImageAsPixbuf(image
);
383 // otherwise create pixmap, if alpha is present it will be converted to mask
384 return CreateFromImageAsPixmap(image
, depth
);
387 bool wxBitmap
::CreateFromImageAsPixmap(const wxImage
& image
, int depth
)
389 const int w
= image
.GetWidth();
390 const int h
= image
.GetHeight();
393 // create XBM format bitmap
395 // one bit per pixel, each row starts on a byte boundary
396 const size_t out_size
= size_t((w
+ 7) / 8) * unsigned(h
);
397 wxByte
* out
= new wxByte
[out_size
];
398 // set bits are black
399 memset(out
, 0xff, out_size
);
400 const wxByte
* in
= image
.GetData();
401 unsigned bit_index
= 0;
402 for (int y
= 0; y
< h
; y
++)
404 for (int x
= 0; x
< w
; x
++, in
+= 3, bit_index
++)
405 if (in
[0] == 255 && in
[1] == 255 && in
[2] == 255)
406 out
[bit_index
>> 3] ^= 1 << (bit_index
& 7);
407 // move index to next byte boundary
408 bit_index
= (bit_index
+ 7) & ~7u;
410 SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window
, (char*)out
, w
, h
));
415 SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window
, w
, h
, depth
));
416 GdkGC
* gc
= gdk_gc_new(M_BMPDATA
->m_pixmap
);
418 M_BMPDATA
->m_pixmap
, gc
,
420 GDK_RGB_DITHER_NONE
, image
.GetData(), w
* 3);
424 const wxByte
* alpha
= image
.GetAlpha();
425 if (alpha
!= NULL
|| image
.HasMask())
427 // create mask as XBM format bitmap
429 const size_t out_size
= size_t((w
+ 7) / 8) * unsigned(h
);
430 wxByte
* out
= new wxByte
[out_size
];
431 memset(out
, 0xff, out_size
);
432 unsigned bit_index
= 0;
435 for (int y
= 0; y
< h
; y
++)
437 for (int x
= 0; x
< w
; x
++, bit_index
++)
438 if (*alpha
++ < wxIMAGE_ALPHA_THRESHOLD
)
439 out
[bit_index
>> 3] ^= 1 << (bit_index
& 7);
440 bit_index
= (bit_index
+ 7) & ~7u;
445 const wxByte r_mask
= image
.GetMaskRed();
446 const wxByte g_mask
= image
.GetMaskGreen();
447 const wxByte b_mask
= image
.GetMaskBlue();
448 const wxByte
* in
= image
.GetData();
449 for (int y
= 0; y
< h
; y
++)
451 for (int x
= 0; x
< w
; x
++, in
+= 3, bit_index
++)
452 if (in
[0] == r_mask
&& in
[1] == g_mask
&& in
[2] == b_mask
)
453 out
[bit_index
>> 3] ^= 1 << (bit_index
& 7);
454 bit_index
= (bit_index
+ 7) & ~7u;
457 wxMask
* mask
= new wxMask
;
458 mask
->m_bitmap
= gdk_bitmap_create_from_data(M_BMPDATA
->m_pixmap
, (char*)out
, w
, h
);
465 bool wxBitmap
::CreateFromImageAsPixbuf(const wxImage
& image
)
467 wxASSERT(image
.HasAlpha());
469 int width
= image
.GetWidth();
470 int height
= image
.GetHeight();
472 Create(width
, height
, 32);
473 GdkPixbuf
* pixbuf
= M_BMPDATA
->m_pixbuf
;
478 const unsigned char* in
= image
.GetData();
479 unsigned char *out
= gdk_pixbuf_get_pixels(pixbuf
);
480 unsigned char *alpha
= image
.GetAlpha();
482 int rowpad
= gdk_pixbuf_get_rowstride(pixbuf
) - 4 * width
;
484 for (int y
= 0; y
< height
; y
++, out
+= rowpad
)
486 for (int x
= 0; x
< width
; x
++, alpha
++, out
+= 4, in
+= 3)
498 wxImage wxBitmap
::ConvertToImage() const
500 wxCHECK_MSG( Ok(), wxNullImage
, wxT("invalid bitmap") );
502 const int w
= GetWidth();
503 const int h
= GetHeight();
504 wxImage
image(w
, h
, false);
505 unsigned char *data
= image
.GetData();
507 wxCHECK_MSG(data
!= NULL
, wxNullImage
, wxT("couldn't create image") );
509 // prefer pixbuf if available, it will preserve alpha and should be quicker
512 GdkPixbuf
*pixbuf
= GetPixbuf();
513 unsigned char* alpha
= NULL
;
514 if (gdk_pixbuf_get_has_alpha(pixbuf
))
517 alpha
= image
.GetAlpha();
519 const unsigned char* in
= gdk_pixbuf_get_pixels(pixbuf
);
520 unsigned char *out
= data
;
521 const int inc
= 3 + int(alpha
!= NULL
);
522 const int rowpad
= gdk_pixbuf_get_rowstride(pixbuf
) - inc
* w
;
524 for (int y
= 0; y
< h
; y
++, in
+= rowpad
)
526 for (int x
= 0; x
< w
; x
++, in
+= inc
, out
+= 3)
538 GdkPixmap
* pixmap
= GetPixmap();
539 GdkPixmap
* pixmap_invert
= NULL
;
542 // mono bitmaps are inverted, i.e. 0 is white
543 pixmap_invert
= gdk_pixmap_new(pixmap
, w
, h
, 1);
544 GdkGC
* gc
= gdk_gc_new(pixmap_invert
);
545 gdk_gc_set_function(gc
, GDK_COPY_INVERT
);
546 gdk_draw_drawable(pixmap_invert
, gc
, pixmap
, 0, 0, 0, 0, w
, h
);
548 pixmap
= pixmap_invert
;
550 // create a pixbuf which shares data with the wxImage
551 GdkPixbuf
* pixbuf
= gdk_pixbuf_new_from_data(
552 data
, GDK_COLORSPACE_RGB
, false, 8, w
, h
, 3 * w
, NULL
, NULL
);
554 gdk_pixbuf_get_from_drawable(pixbuf
, pixmap
, NULL
, 0, 0, 0, 0, w
, h
);
556 g_object_unref(pixbuf
);
557 if (pixmap_invert
!= NULL
)
558 g_object_unref(pixmap_invert
);
560 // convert mask, unless there is already alpha
561 if (GetMask() && !image
.HasAlpha())
563 // we hard code the mask colour for now but we could also make an
564 // effort (and waste time) to choose a colour not present in the
565 // image already to avoid having to fudge the pixels below --
566 // whether it's worth to do it is unclear however
567 const int MASK_RED
= 1;
568 const int MASK_GREEN
= 2;
569 const int MASK_BLUE
= 3;
570 const int MASK_BLUE_REPLACEMENT
= 2;
572 image
.SetMaskColour(MASK_RED
, MASK_GREEN
, MASK_BLUE
);
573 GdkImage
* image_mask
= gdk_drawable_get_image(GetMask()->GetBitmap(), 0, 0, w
, h
);
575 for (int y
= 0; y
< h
; y
++)
577 for (int x
= 0; x
< w
; x
++, data
+= 3)
579 if (gdk_image_get_pixel(image_mask
, x
, y
) == 0)
582 data
[1] = MASK_GREEN
;
585 else if (data
[0] == MASK_RED
&& data
[1] == MASK_GREEN
&& data
[2] == MASK_BLUE
)
587 // we have to fudge the colour a bit to prevent
588 // this pixel from appearing transparent
589 data
[2] = MASK_BLUE_REPLACEMENT
;
593 g_object_unref(image_mask
);
599 bool wxBitmap
::IsOk() const
601 return (m_refData
!= NULL
) &&
603 M_BMPDATA
->m_pixbuf
||
608 int wxBitmap
::GetHeight() const
610 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
612 return M_BMPDATA
->m_height
;
615 int wxBitmap
::GetWidth() const
617 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
619 return M_BMPDATA
->m_width
;
622 int wxBitmap
::GetDepth() const
624 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
626 return M_BMPDATA
->m_bpp
;
629 wxMask
*wxBitmap
::GetMask() const
631 wxCHECK_MSG( Ok(), (wxMask
*) NULL
, wxT("invalid bitmap") );
633 return M_BMPDATA
->m_mask
;
636 void wxBitmap
::SetMask( wxMask
*mask
)
638 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
641 delete M_BMPDATA
->m_mask
;
642 M_BMPDATA
->m_mask
= mask
;
645 bool wxBitmap
::CopyFromIcon(const wxIcon
& icon
)
651 wxBitmap wxBitmap
::GetSubBitmap( const wxRect
& rect
) const
655 wxCHECK_MSG(Ok(), ret
, wxT("invalid bitmap"));
656 wxCHECK_MSG(rect
.x
>= 0 && rect
.y
>= 0 &&
657 rect
.x
+ rect
.width
<= M_BMPDATA
->m_width
&&
658 rect
.y
+ rect
.height
<= M_BMPDATA
->m_height
,
659 ret
, wxT("invalid bitmap region"));
661 if (HasPixbuf() || M_BMPDATA
->m_bpp
== 32)
663 GdkPixbuf
*pixbuf
= gdk_pixbuf_new(GDK_COLORSPACE_RGB
,
664 gdk_pixbuf_get_has_alpha(GetPixbuf()),
665 8, rect
.width
, rect
.height
);
666 ret
.SetPixbuf(pixbuf
, M_BMPDATA
->m_bpp
);
667 gdk_pixbuf_copy_area(GetPixbuf(),
668 rect
.x
, rect
.y
, rect
.width
, rect
.height
,
673 ret
.Create(rect
.width
, rect
.height
, M_BMPDATA
->m_bpp
);
674 GdkGC
*gc
= gdk_gc_new( ret
.GetPixmap() );
675 gdk_draw_drawable( ret
.GetPixmap(), gc
, GetPixmap(), rect
.x
, rect
.y
, 0, 0, rect
.width
, rect
.height
);
678 // make mask, unless there is already alpha
679 if (GetMask() && !HasAlpha())
681 wxMask
*mask
= new wxMask
;
682 mask
->m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, rect
.width
, rect
.height
, 1 );
684 GdkGC
*gc
= gdk_gc_new( mask
->m_bitmap
);
685 gdk_draw_drawable(mask
->m_bitmap
, gc
, M_BMPDATA
->m_mask
->m_bitmap
, rect
.x
, rect
.y
, 0, 0, rect
.width
, rect
.height
);
694 bool wxBitmap
::SaveFile( const wxString
&name
, wxBitmapType type
, const wxPalette
*WXUNUSED(palette
) ) const
696 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
698 // Try to save the bitmap via wxImage handlers:
699 wxImage image
= ConvertToImage();
700 return image
.Ok() && image
.SaveFile(name
, type
);
703 bool wxBitmap
::LoadFile( const wxString
&name
, wxBitmapType type
)
707 if (type
== wxBITMAP_TYPE_XPM
)
709 GdkBitmap
*mask
= (GdkBitmap
*) NULL
;
710 SetPixmap(gdk_pixmap_create_from_xpm(wxGetRootWindow()->window
, &mask
, NULL
, name
.fn_str()));
714 M_BMPDATA
->m_mask
= new wxMask
;
715 M_BMPDATA
->m_mask
->m_bitmap
= mask
;
718 else // try if wxImage can load it
721 if (image
.LoadFile(name
, type
) && image
.Ok())
722 CreateFromImage(image
, -1);
729 wxPalette
*wxBitmap
::GetPalette() const
731 wxCHECK_MSG(Ok(), NULL
, wxT("invalid bitmap"));
733 return M_BMPDATA
->m_palette
;
736 void wxBitmap
::SetPalette(const wxPalette
& WXUNUSED(palette
))
740 #endif // wxUSE_PALETTE
742 void wxBitmap
::SetHeight( int height
)
745 M_BMPDATA
->m_height
= height
;
748 void wxBitmap
::SetWidth( int width
)
751 M_BMPDATA
->m_width
= width
;
754 void wxBitmap
::SetDepth( int depth
)
757 M_BMPDATA
->m_bpp
= depth
;
760 void wxBitmap
::SetPixmap( GdkPixmap
*pixmap
)
763 m_refData
= new wxBitmapRefData
;
765 // AllocExclusive should not be needed for this internal function
766 wxASSERT(m_refData
->GetRefCount() == 1);
767 wxASSERT(M_BMPDATA
->m_pixmap
== NULL
);
768 M_BMPDATA
->m_pixmap
= pixmap
;
769 gdk_drawable_get_size(pixmap
, &M_BMPDATA
->m_width
, &M_BMPDATA
->m_height
);
770 M_BMPDATA
->m_bpp
= gdk_drawable_get_depth(pixmap
);
771 PurgeOtherRepresentations(Pixmap
);
774 GdkPixmap
*wxBitmap
::GetPixmap() const
776 wxCHECK_MSG( Ok(), (GdkPixmap
*) NULL
, wxT("invalid bitmap") );
778 // create the pixmap on the fly if we use Pixbuf representation:
779 if (M_BMPDATA
->m_pixmap
== NULL
)
781 GdkPixmap
** pmask
= NULL
;
782 if (gdk_pixbuf_get_has_alpha(M_BMPDATA
->m_pixbuf
))
784 // make new mask from alpha
785 delete M_BMPDATA
->m_mask
;
786 M_BMPDATA
->m_mask
= new wxMask
;
787 pmask
= &M_BMPDATA
->m_mask
->m_bitmap
;
789 gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA
->m_pixbuf
,
790 &M_BMPDATA
->m_pixmap
,
792 wxIMAGE_ALPHA_THRESHOLD
);
795 return M_BMPDATA
->m_pixmap
;
798 bool wxBitmap
::HasPixmap() const
800 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
802 return M_BMPDATA
->m_pixmap
!= NULL
;
805 GdkPixbuf
*wxBitmap
::GetPixbuf() const
807 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") );
809 if (M_BMPDATA
->m_pixbuf
== NULL
)
811 int width
= GetWidth();
812 int height
= GetHeight();
814 GdkPixbuf
*pixbuf
= gdk_pixbuf_new(GDK_COLORSPACE_RGB
,
817 M_BMPDATA
->m_pixbuf
= pixbuf
;
818 gdk_pixbuf_get_from_drawable(pixbuf
, M_BMPDATA
->m_pixmap
, NULL
,
819 0, 0, 0, 0, width
, height
);
821 // apply the mask to created pixbuf:
822 if (M_BMPDATA
->m_pixbuf
&& M_BMPDATA
->m_mask
)
825 gdk_pixbuf_get_from_drawable(NULL
,
826 M_BMPDATA
->m_mask
->GetBitmap(),
828 0, 0, 0, 0, width
, height
);
831 guchar
*bmp
= gdk_pixbuf_get_pixels(pixbuf
);
832 guchar
*mask
= gdk_pixbuf_get_pixels(pmask
);
833 int bmprowinc
= gdk_pixbuf_get_rowstride(pixbuf
) - 4 * width
;
834 int maskrowinc
= gdk_pixbuf_get_rowstride(pmask
) - 3 * width
;
836 for (int y
= 0; y
< height
;
837 y
++, bmp
+= bmprowinc
, mask
+= maskrowinc
)
839 for (int x
= 0; x
< width
; x
++, bmp
+= 4, mask
+= 3)
841 if (mask
[0] == 0 /*black pixel*/)
846 g_object_unref (pmask
);
851 return M_BMPDATA
->m_pixbuf
;
854 bool wxBitmap
::HasPixbuf() const
856 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
858 return M_BMPDATA
->m_pixbuf
!= NULL
;
861 void wxBitmap
::SetPixbuf(GdkPixbuf
* pixbuf
, int depth
)
864 m_refData
= new wxBitmapRefData
;
866 // AllocExclusive should not be needed for this internal function
867 wxASSERT(m_refData
->GetRefCount() == 1);
868 wxASSERT(M_BMPDATA
->m_pixbuf
== NULL
);
869 M_BMPDATA
->m_pixbuf
= pixbuf
;
870 M_BMPDATA
->m_width
= gdk_pixbuf_get_width(pixbuf
);
871 M_BMPDATA
->m_height
= gdk_pixbuf_get_height(pixbuf
);
872 // if depth specified
874 M_BMPDATA
->m_bpp
= depth
;
875 else if (M_BMPDATA
->m_bpp
== 0)
876 // use something reasonable
877 M_BMPDATA
->m_bpp
= wxTheApp
->GetGdkVisual()->depth
;
878 PurgeOtherRepresentations(Pixbuf
);
881 void wxBitmap
::PurgeOtherRepresentations(wxBitmap
::Representation keep
)
883 if (keep
== Pixmap
&& HasPixbuf())
885 g_object_unref (M_BMPDATA
->m_pixbuf
);
886 M_BMPDATA
->m_pixbuf
= NULL
;
888 if (keep
== Pixbuf
&& HasPixmap())
890 g_object_unref (M_BMPDATA
->m_pixmap
);
891 M_BMPDATA
->m_pixmap
= NULL
;
895 void *wxBitmap
::GetRawData(wxPixelDataBase
& data
, int bpp
)
898 GdkPixbuf
*pixbuf
= GetPixbuf();
899 const bool hasAlpha
= HasAlpha();
900 // allow access if bpp is valid and matches existence of alpha
901 if (pixbuf
!= NULL
&& (
902 bpp
== 24 && !hasAlpha
||
903 bpp
== 32 && hasAlpha
))
905 data
.m_height
= gdk_pixbuf_get_height( pixbuf
);
906 data
.m_width
= gdk_pixbuf_get_width( pixbuf
);
907 data
.m_stride
= gdk_pixbuf_get_rowstride( pixbuf
);
908 bits
= gdk_pixbuf_get_pixels(pixbuf
);
913 void wxBitmap
::UngetRawData(wxPixelDataBase
& WXUNUSED(data
))
917 bool wxBitmap
::HasAlpha() const
919 return m_refData
!= NULL
&& M_BMPDATA
->m_pixbuf
!= NULL
&&
920 gdk_pixbuf_get_has_alpha(M_BMPDATA
->m_pixbuf
);
923 void wxBitmap
::UseAlpha()
925 GdkPixbuf
* pixbuf
= GetPixbuf();
926 // add alpha if necessary
927 if (!gdk_pixbuf_get_has_alpha(pixbuf
))
929 M_BMPDATA
->m_pixbuf
= NULL
;
931 M_BMPDATA
->m_pixbuf
= gdk_pixbuf_add_alpha(pixbuf
, false, 0, 0, 0);
932 g_object_unref(pixbuf
);
936 wxObjectRefData
* wxBitmap
::CreateRefData() const
938 return new wxBitmapRefData
;
941 wxObjectRefData
* wxBitmap
::CloneRefData(const wxObjectRefData
* data
) const
943 const wxBitmapRefData
* oldRef
= wx_static_cast(const wxBitmapRefData
*, data
);
944 wxBitmapRefData
* newRef
= new wxBitmapRefData
;
945 newRef
->m_width
= oldRef
->m_width
;
946 newRef
->m_height
= oldRef
->m_height
;
947 newRef
->m_bpp
= oldRef
->m_bpp
;
948 if (oldRef
->m_pixmap
!= NULL
)
950 newRef
->m_pixmap
= gdk_pixmap_new(
951 oldRef
->m_pixmap
, oldRef
->m_width
, oldRef
->m_height
,
952 // use pixmap depth, m_bpp may not match
953 gdk_drawable_get_depth(oldRef
->m_pixmap
));
954 GdkGC
* gc
= gdk_gc_new(newRef
->m_pixmap
);
956 newRef
->m_pixmap
, gc
, oldRef
->m_pixmap
, 0, 0, 0, 0, -1, -1);
959 if (oldRef
->m_pixbuf
!= NULL
)
961 newRef
->m_pixbuf
= gdk_pixbuf_copy(oldRef
->m_pixbuf
);
963 if (oldRef
->m_mask
!= NULL
)
965 newRef
->m_mask
= new wxMask
;
966 newRef
->m_mask
->m_bitmap
= gdk_pixmap_new(
967 oldRef
->m_mask
->m_bitmap
, oldRef
->m_width
, oldRef
->m_height
, 1);
968 GdkGC
* gc
= gdk_gc_new(newRef
->m_mask
->m_bitmap
);
969 gdk_draw_drawable(newRef
->m_mask
->m_bitmap
,
970 gc
, oldRef
->m_mask
->m_bitmap
, 0, 0, 0, 0, -1, -1);
974 // implement this if SetPalette is ever implemented
975 wxASSERT(oldRef
->m_palette
== NULL
);
981 //-----------------------------------------------------------------------------
983 //-----------------------------------------------------------------------------
985 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler
, wxBitmapHandlerBase
)
987 /* static */ void wxBitmap
::InitStandardHandlers()
989 // TODO: Insert handler based on GdkPixbufs handler later