1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "bitmap.h"
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
19 #include "wx/palette.h"
20 #include "wx/bitmap.h"
22 #include "wx/filefn.h"
24 #include "wx/dcmemory.h"
28 // need this to get gdk_image_new_bitmap()
29 #define GDK_ENABLE_BROKEN
37 #include <gdk/gdkimage.h>
39 #include <gdk/gdkrgb.h>
40 #endif // GTK+ 2.0/1.2
44 extern void gdk_wx_draw_bitmap (GdkDrawable
*drawable
,
54 //-----------------------------------------------------------------------------
56 //-----------------------------------------------------------------------------
58 extern GtkWidget
*wxGetRootWindow();
60 //-----------------------------------------------------------------------------
62 //-----------------------------------------------------------------------------
64 IMPLEMENT_DYNAMIC_CLASS(wxMask
,wxObject
)
68 m_bitmap
= (GdkBitmap
*) NULL
;
71 wxMask::wxMask( const wxBitmap
& bitmap
, const wxColour
& colour
)
73 m_bitmap
= (GdkBitmap
*) NULL
;
74 Create( bitmap
, colour
);
77 wxMask::wxMask( const wxBitmap
& bitmap
, int paletteIndex
)
79 m_bitmap
= (GdkBitmap
*) NULL
;
80 Create( bitmap
, paletteIndex
);
83 wxMask::wxMask( const wxBitmap
& bitmap
)
85 m_bitmap
= (GdkBitmap
*) NULL
;
92 gdk_bitmap_unref( m_bitmap
);
95 bool wxMask::Create( const wxBitmap
& bitmap
,
96 const wxColour
& colour
)
100 gdk_bitmap_unref( m_bitmap
);
101 m_bitmap
= (GdkBitmap
*) NULL
;
104 wxImage image
= bitmap
.ConvertToImage();
105 if (!image
.Ok()) return FALSE
;
107 m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, image
.GetWidth(), image
.GetHeight(), 1 );
108 GdkGC
*gc
= gdk_gc_new( m_bitmap
);
115 gdk_gc_set_foreground( gc
, &color
);
116 gdk_gc_set_fill( gc
, GDK_SOLID
);
117 gdk_draw_rectangle( m_bitmap
, gc
, TRUE
, 0, 0, image
.GetWidth(), image
.GetHeight() );
119 unsigned char *data
= image
.GetData();
122 unsigned char red
= colour
.Red();
123 unsigned char green
= colour
.Green();
124 unsigned char blue
= colour
.Blue();
126 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
128 int bpp
= visual
->depth
;
129 if ((bpp
== 16) && (visual
->red_mask
!= 0xf800))
134 green
= green
& 0xf8;
140 green
= green
& 0xfc;
146 green
= green
& 0xf0;
154 gdk_gc_set_foreground( gc
, &color
);
156 for (int j
= 0; j
< image
.GetHeight(); j
++)
160 for (i
= 0; i
< image
.GetWidth(); i
++)
162 if ((data
[index
] == red
) &&
163 (data
[index
+1] == green
) &&
164 (data
[index
+2] == blue
))
173 gdk_draw_line( m_bitmap
, gc
, start_x
, j
, i
-1, j
);
180 gdk_draw_line( m_bitmap
, gc
, start_x
, j
, i
, j
);
188 bool wxMask::Create( const wxBitmap
& bitmap
, int paletteIndex
)
191 wxPalette
*pal
= bitmap
.GetPalette();
193 wxCHECK_MSG( pal
, FALSE
, wxT("Cannot create mask from bitmap without palette") );
195 pal
->GetRGB(paletteIndex
, &r
, &g
, &b
);
197 return Create(bitmap
, wxColour(r
, g
, b
));
200 bool wxMask::Create( const wxBitmap
& bitmap
)
204 gdk_bitmap_unref( m_bitmap
);
205 m_bitmap
= (GdkBitmap
*) NULL
;
208 if (!bitmap
.Ok()) return FALSE
;
210 wxCHECK_MSG( bitmap
.GetBitmap(), FALSE
, wxT("Cannot create mask from colour bitmap") );
212 m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, bitmap
.GetWidth(), bitmap
.GetHeight(), 1 );
214 if (!m_bitmap
) return FALSE
;
216 GdkGC
*gc
= gdk_gc_new( m_bitmap
);
218 gdk_wx_draw_bitmap( m_bitmap
, gc
, bitmap
.GetBitmap(), 0, 0, 0, 0, bitmap
.GetWidth(), bitmap
.GetHeight() );
225 GdkBitmap
*wxMask::GetBitmap() const
230 //-----------------------------------------------------------------------------
232 //-----------------------------------------------------------------------------
234 class wxBitmapRefData
: public wxObjectRefData
246 wxPalette
*m_palette
;
249 wxBitmapRefData::wxBitmapRefData()
251 m_pixmap
= (GdkPixmap
*) NULL
;
252 m_bitmap
= (GdkBitmap
*) NULL
;
253 m_mask
= (wxMask
*) NULL
;
257 m_palette
= (wxPalette
*) NULL
;
260 wxBitmapRefData::~wxBitmapRefData()
263 gdk_pixmap_unref( m_pixmap
);
265 gdk_bitmap_unref( m_bitmap
);
270 //-----------------------------------------------------------------------------
272 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
274 IMPLEMENT_DYNAMIC_CLASS(wxBitmap
,wxGDIObject
)
280 wxBitmap::wxBitmap( int width
, int height
, int depth
)
282 Create( width
, height
, depth
);
285 bool wxBitmap::Create( int width
, int height
, int depth
)
289 if ( width
<= 0 || height
<= 0 )
294 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
297 depth
= visual
->depth
;
299 wxCHECK_MSG( (depth
== visual
->depth
) || (depth
== 1), FALSE
,
300 wxT("invalid bitmap depth") )
302 m_refData
= new wxBitmapRefData();
303 M_BMPDATA
->m_mask
= (wxMask
*) NULL
;
304 M_BMPDATA
->m_width
= width
;
305 M_BMPDATA
->m_height
= height
;
308 M_BMPDATA
->m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, 1 );
309 M_BMPDATA
->m_bpp
= 1;
313 M_BMPDATA
->m_pixmap
= gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, depth
);
314 M_BMPDATA
->m_bpp
= visual
->depth
;
320 bool wxBitmap::CreateFromXpm( const char **bits
)
324 wxCHECK_MSG( bits
!= NULL
, FALSE
, wxT("invalid bitmap data") )
326 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
328 m_refData
= new wxBitmapRefData();
330 GdkBitmap
*mask
= (GdkBitmap
*) NULL
;
332 M_BMPDATA
->m_pixmap
= gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window
, &mask
, NULL
, (gchar
**) bits
);
334 wxCHECK_MSG( M_BMPDATA
->m_pixmap
, FALSE
, wxT("couldn't create pixmap") );
338 M_BMPDATA
->m_mask
= new wxMask();
339 M_BMPDATA
->m_mask
->m_bitmap
= mask
;
342 gdk_window_get_size( M_BMPDATA
->m_pixmap
, &(M_BMPDATA
->m_width
), &(M_BMPDATA
->m_height
) );
344 M_BMPDATA
->m_bpp
= visual
->depth
; // Can we get a different depth from create_from_xpm_d() ?
349 wxBitmap
wxBitmap::Rescale( int clipx
, int clipy
, int clipwidth
, int clipheight
, int newx
, int newy
)
351 wxCHECK_MSG( Ok(), wxNullBitmap
, wxT("invalid bitmap") );
353 if (newy
==M_BMPDATA
->m_width
&& newy
==M_BMPDATA
->m_height
)
356 GdkImage
*img
= (GdkImage
*) NULL
;
358 img
= gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() );
359 else if (GetBitmap())
360 img
= gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() );
362 wxFAIL_MSG( wxT("Ill-formed bitmap") );
364 wxCHECK_MSG( img
, wxNullBitmap
, wxT("couldn't create image") );
369 int width
= wxMax(newx
, 1);
370 int height
= wxMax(newy
, 1);
371 width
= wxMin(width
, clipwidth
);
372 height
= wxMin(height
, clipheight
);
375 GdkPixmap
*dstpix
= NULL
;
378 GdkVisual
*visual
= gdk_window_get_visual( GetPixmap() );
380 visual
= wxTheApp
->GetGdkVisual();
383 bmp
= wxBitmap(width
,height
,bpp
);
384 dstpix
= bmp
.GetPixmap();
385 gc
= gdk_gc_new( dstpix
);
389 long dstbyteperline
= 0;
394 dstbyteperline
= width
/8*M_BMPDATA
->m_bpp
;
395 if (width
*M_BMPDATA
->m_bpp
% 8 != 0)
397 dst
= (char*) malloc(dstbyteperline
*height
);
400 // be careful to use the right scaling factor
401 float scx
= (float)M_BMPDATA
->m_width
/(float)newx
;
402 float scy
= (float)M_BMPDATA
->m_height
/(float)newy
;
403 // prepare accel-tables
404 int *tablex
= (int *)calloc(width
,sizeof(int));
405 int *tabley
= (int *)calloc(height
,sizeof(int));
407 // accel table filled with clipped values
408 for (int x
= 0; x
< width
; x
++)
409 tablex
[x
] = (int) (scx
* (x
+clipx
));
410 for (int y
= 0; y
< height
; y
++)
411 tabley
[y
] = (int) (scy
* (y
+clipy
));
413 // Main rescaling routine starts here
414 for (int h
= 0; h
< height
; h
++)
418 for (int w
=0; w
<width
; w
++)
420 guint32 pixval
= gdk_image_get_pixel( img
, tablex
[w
], tabley
[h
] );
426 char shift
= bit
<< w
% 8;
432 dst
[h
*dstbyteperline
+w
/8]=~outbyte
;
440 gdk_gc_set_foreground( gc
, &col
);
441 gdk_draw_point( dstpix
, gc
, w
, h
);
445 // do not forget the last byte
447 dst
[h
*dstbyteperline
+width
/8] = ~outbyte
;
450 gdk_image_destroy( img
);
451 if (gc
) gdk_gc_unref( gc
);
455 bmp
= wxBitmap( (const char *)dst
, width
, height
, 1 );
462 dstbyteperline
= width
/8*bpp
;
463 if (width
*bpp
% 8 != 0)
465 dst
= (char*) malloc(dstbyteperline
*height
);
466 img
= gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() );
468 for (int h
= 0; h
< height
; h
++)
472 for (int w
=0; w
<width
; w
++)
474 guint32 pixval
= gdk_image_get_pixel( img
, tablex
[w
], tabley
[h
] );
478 char shift
= bit
<< w
% 8;
484 dst
[h
*dstbyteperline
+w
/8]=~outbyte
;
489 // do not forget the last byte
491 dst
[h
*dstbyteperline
+width
/8] = ~outbyte
;
494 wxBitmap
mask_bmp( (const char *)dst
, width
, height
, 1 );
495 wxMask
* mask
= new wxMask(mask_bmp
);
499 gdk_image_destroy( img
);
508 bool wxBitmap::CreateFromImage( const wxImage
& image
, int depth
)
512 wxCHECK_MSG( image
.Ok(), FALSE
, wxT("invalid image") )
513 wxCHECK_MSG( depth
== -1 || depth
== 1, FALSE
, wxT("invalid bitmap depth") )
515 int width
= image
.GetWidth();
516 int height
= image
.GetHeight();
518 if ( width
<= 0 || height
<= 0 )
523 m_refData
= new wxBitmapRefData();
529 // conversion to mono bitmap:
533 SetBitmap( gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, 1 ) );
537 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
539 // Create picture image
541 unsigned char *data_data
= (unsigned char*)malloc( ((width
>> 3)+8) * height
);
543 GdkImage
*data_image
=
544 gdk_image_new_bitmap( visual
, data_data
, width
, height
);
548 GdkImage
*mask_image
= (GdkImage
*) NULL
;
552 unsigned char *mask_data
= (unsigned char*)malloc( ((width
>> 3)+8) * height
);
554 mask_image
= gdk_image_new_bitmap( visual
, mask_data
, width
, height
);
556 wxMask
*mask
= new wxMask();
557 mask
->m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, 1 );
562 int r_mask
= image
.GetMaskRed();
563 int g_mask
= image
.GetMaskGreen();
564 int b_mask
= image
.GetMaskBlue();
566 unsigned char* data
= image
.GetData();
569 for (int y
= 0; y
< height
; y
++)
571 for (int x
= 0; x
< width
; x
++)
582 if ((r
== r_mask
) && (b
== b_mask
) && (g
== g_mask
))
583 gdk_image_put_pixel( mask_image
, x
, y
, 1 );
585 gdk_image_put_pixel( mask_image
, x
, y
, 0 );
588 if ((r
== 255) && (b
== 255) && (g
== 255))
589 gdk_image_put_pixel( data_image
, x
, y
, 1 );
591 gdk_image_put_pixel( data_image
, x
, y
, 0 );
598 GdkGC
*data_gc
= gdk_gc_new( GetBitmap() );
600 gdk_draw_image( GetBitmap(), data_gc
, data_image
, 0, 0, 0, 0, width
, height
);
602 gdk_image_destroy( data_image
);
603 gdk_gc_unref( data_gc
);
609 GdkGC
*mask_gc
= gdk_gc_new( GetMask()->GetBitmap() );
611 gdk_draw_image( GetMask()->GetBitmap(), mask_gc
, mask_image
, 0, 0, 0, 0, width
, height
);
613 gdk_image_destroy( mask_image
);
614 gdk_gc_unref( mask_gc
);
619 // conversion to colour bitmap:
623 SetPixmap( gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, -1 ) );
625 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
627 int bpp
= visual
->depth
;
631 if ((bpp
== 16) && (visual
->red_mask
!= 0xf800))
636 // We handle 8-bit bitmaps ourselves using the colour cube, 12-bit
637 // visuals are not supported by GDK so we do these ourselves, too.
638 // 15-bit and 16-bit should actually work and 24-bit certainly does.
640 if (!image
.HasMask() && (bpp
> 16))
642 if (!image
.HasMask() && (bpp
> 12))
645 static bool s_hasInitialized
= FALSE
;
647 if (!s_hasInitialized
)
650 s_hasInitialized
= TRUE
;
653 GdkGC
*gc
= gdk_gc_new( GetPixmap() );
655 gdk_draw_rgb_image( GetPixmap(),
667 // Create picture image
669 GdkImage
*data_image
=
670 gdk_image_new( GDK_IMAGE_FASTEST
, visual
, width
, height
);
674 GdkImage
*mask_image
= (GdkImage
*) NULL
;
678 unsigned char *mask_data
= (unsigned char*)malloc( ((width
>> 3)+8) * height
);
680 mask_image
= gdk_image_new_bitmap( visual
, mask_data
, width
, height
);
682 wxMask
*mask
= new wxMask();
683 mask
->m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, width
, height
, 1 );
690 enum byte_order
{ RGB
, RBG
, BRG
, BGR
, GRB
, GBR
};
691 byte_order b_o
= RGB
;
695 if ((visual
->red_mask
> visual
->green_mask
) && (visual
->green_mask
> visual
->blue_mask
)) b_o
= RGB
;
696 else if ((visual
->red_mask
> visual
->blue_mask
) && (visual
->blue_mask
> visual
->green_mask
)) b_o
= RBG
;
697 else if ((visual
->blue_mask
> visual
->red_mask
) && (visual
->red_mask
> visual
->green_mask
)) b_o
= BRG
;
698 else if ((visual
->blue_mask
> visual
->green_mask
) && (visual
->green_mask
> visual
->red_mask
)) b_o
= BGR
;
699 else if ((visual
->green_mask
> visual
->red_mask
) && (visual
->red_mask
> visual
->blue_mask
)) b_o
= GRB
;
700 else if ((visual
->green_mask
> visual
->blue_mask
) && (visual
->blue_mask
> visual
->red_mask
)) b_o
= GBR
;
703 int r_mask
= image
.GetMaskRed();
704 int g_mask
= image
.GetMaskGreen();
705 int b_mask
= image
.GetMaskBlue();
707 unsigned char* data
= image
.GetData();
710 for (int y
= 0; y
< height
; y
++)
712 for (int x
= 0; x
< width
; x
++)
723 if ((r
== r_mask
) && (b
== b_mask
) && (g
== g_mask
))
724 gdk_image_put_pixel( mask_image
, x
, y
, 1 );
726 gdk_image_put_pixel( mask_image
, x
, y
, 0 );
734 if (wxTheApp
->m_colorCube
)
736 pixel
= wxTheApp
->m_colorCube
[ ((r
& 0xf8) << 7) + ((g
& 0xf8) << 2) + ((b
& 0xf8) >> 3) ];
740 GdkColormap
*cmap
= gtk_widget_get_default_colormap();
741 GdkColor
*colors
= cmap
->colors
;
742 int max
= 3 * (65536);
744 for (int i
= 0; i
< cmap
->size
; i
++)
746 int rdiff
= (r
<< 8) - colors
[i
].red
;
747 int gdiff
= (g
<< 8) - colors
[i
].green
;
748 int bdiff
= (b
<< 8) - colors
[i
].blue
;
749 int sum
= ABS (rdiff
) + ABS (gdiff
) + ABS (bdiff
);
750 if (sum
< max
) { pixel
= i
; max
= sum
; }
754 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
763 case RGB
: pixel
= ((r
& 0xf0) << 4) | (g
& 0xf0) | ((b
& 0xf0) >> 4); break;
764 case RBG
: pixel
= ((r
& 0xf0) << 4) | (b
& 0xf0) | ((g
& 0xf0) >> 4); break;
765 case GRB
: pixel
= ((g
& 0xf0) << 4) | (r
& 0xf0) | ((b
& 0xf0) >> 4); break;
766 case GBR
: pixel
= ((g
& 0xf0) << 4) | (b
& 0xf0) | ((r
& 0xf0) >> 4); break;
767 case BRG
: pixel
= ((b
& 0xf0) << 4) | (r
& 0xf0) | ((g
& 0xf0) >> 4); break;
768 case BGR
: pixel
= ((b
& 0xf0) << 4) | (g
& 0xf0) | ((r
& 0xf0) >> 4); break;
770 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
778 case RGB
: pixel
= ((r
& 0xf8) << 7) | ((g
& 0xf8) << 2) | ((b
& 0xf8) >> 3); break;
779 case RBG
: pixel
= ((r
& 0xf8) << 7) | ((b
& 0xf8) << 2) | ((g
& 0xf8) >> 3); break;
780 case GRB
: pixel
= ((g
& 0xf8) << 7) | ((r
& 0xf8) << 2) | ((b
& 0xf8) >> 3); break;
781 case GBR
: pixel
= ((g
& 0xf8) << 7) | ((b
& 0xf8) << 2) | ((r
& 0xf8) >> 3); break;
782 case BRG
: pixel
= ((b
& 0xf8) << 7) | ((r
& 0xf8) << 2) | ((g
& 0xf8) >> 3); break;
783 case BGR
: pixel
= ((b
& 0xf8) << 7) | ((g
& 0xf8) << 2) | ((r
& 0xf8) >> 3); break;
785 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
790 // I actually don't know if for 16-bit displays, it is alway the green
791 // component or the second component which has 6 bits.
795 case RGB
: pixel
= ((r
& 0xf8) << 8) | ((g
& 0xfc) << 3) | ((b
& 0xf8) >> 3); break;
796 case RBG
: pixel
= ((r
& 0xf8) << 8) | ((b
& 0xfc) << 3) | ((g
& 0xf8) >> 3); break;
797 case GRB
: pixel
= ((g
& 0xf8) << 8) | ((r
& 0xfc) << 3) | ((b
& 0xf8) >> 3); break;
798 case GBR
: pixel
= ((g
& 0xf8) << 8) | ((b
& 0xfc) << 3) | ((r
& 0xf8) >> 3); break;
799 case BRG
: pixel
= ((b
& 0xf8) << 8) | ((r
& 0xfc) << 3) | ((g
& 0xf8) >> 3); break;
800 case BGR
: pixel
= ((b
& 0xf8) << 8) | ((g
& 0xfc) << 3) | ((r
& 0xf8) >> 3); break;
802 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
811 case RGB
: pixel
= (r
<< 16) | (g
<< 8) | b
; break;
812 case RBG
: pixel
= (r
<< 16) | (b
<< 8) | g
; break;
813 case BRG
: pixel
= (b
<< 16) | (r
<< 8) | g
; break;
814 case BGR
: pixel
= (b
<< 16) | (g
<< 8) | r
; break;
815 case GRB
: pixel
= (g
<< 16) | (r
<< 8) | b
; break;
816 case GBR
: pixel
= (g
<< 16) | (b
<< 8) | r
; break;
818 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
827 GdkGC
*data_gc
= gdk_gc_new( GetPixmap() );
829 gdk_draw_image( GetPixmap(), data_gc
, data_image
, 0, 0, 0, 0, width
, height
);
831 gdk_image_destroy( data_image
);
832 gdk_gc_unref( data_gc
);
838 GdkGC
*mask_gc
= gdk_gc_new( GetMask()->GetBitmap() );
840 gdk_draw_image( GetMask()->GetBitmap(), mask_gc
, mask_image
, 0, 0, 0, 0, width
, height
);
842 gdk_image_destroy( mask_image
);
843 gdk_gc_unref( mask_gc
);
850 wxImage
wxBitmap::ConvertToImage() const
852 // the colour used as transparent one in wxImage and the one it is replaced
853 // with when it really occurs in the bitmap
854 static const int MASK_RED
= 1;
855 static const int MASK_GREEN
= 2;
856 static const int MASK_BLUE
= 3;
857 static const int MASK_BLUE_REPLACEMENT
= 2;
861 wxCHECK_MSG( Ok(), wxNullImage
, wxT("invalid bitmap") );
863 GdkImage
*gdk_image
= (GdkImage
*) NULL
;
866 gdk_image
= gdk_image_get( GetPixmap(),
868 GetWidth(), GetHeight() );
870 else if (GetBitmap())
872 gdk_image
= gdk_image_get( GetBitmap(),
874 GetWidth(), GetHeight() );
878 wxFAIL_MSG( wxT("Ill-formed bitmap") );
881 wxCHECK_MSG( gdk_image
, wxNullImage
, wxT("couldn't create image") );
883 image
.Create( GetWidth(), GetHeight() );
884 char unsigned *data
= image
.GetData();
888 gdk_image_destroy( gdk_image
);
889 wxFAIL_MSG( wxT("couldn't create image") );
893 GdkImage
*gdk_image_mask
= (GdkImage
*) NULL
;
896 gdk_image_mask
= gdk_image_get( GetMask()->GetBitmap(),
898 GetWidth(), GetHeight() );
900 image
.SetMaskColour( MASK_RED
, MASK_GREEN
, MASK_BLUE
);
904 int red_shift_right
= 0;
905 int green_shift_right
= 0;
906 int blue_shift_right
= 0;
907 int red_shift_left
= 0;
908 int green_shift_left
= 0;
909 int blue_shift_left
= 0;
910 bool use_shift
= FALSE
;
914 GdkVisual
*visual
= gdk_window_get_visual( GetPixmap() );
916 visual
= wxTheApp
->GetGdkVisual();
920 bpp
= visual
->red_prec
+ visual
->green_prec
+ visual
->blue_prec
;
921 red_shift_right
= visual
->red_shift
;
922 red_shift_left
= 8-visual
->red_prec
;
923 green_shift_right
= visual
->green_shift
;
924 green_shift_left
= 8-visual
->green_prec
;
925 blue_shift_right
= visual
->blue_shift
;
926 blue_shift_left
= 8-visual
->blue_prec
;
928 use_shift
= (visual
->type
== GDK_VISUAL_TRUE_COLOR
) || (visual
->type
== GDK_VISUAL_DIRECT_COLOR
);
936 GdkColormap
*cmap
= gtk_widget_get_default_colormap();
939 for (int j
= 0; j
< GetHeight(); j
++)
941 for (int i
= 0; i
< GetWidth(); i
++)
943 wxUint32 pixel
= gdk_image_get_pixel( gdk_image
, i
, j
);
961 data
[pos
] = (pixel
>> red_shift_right
) << red_shift_left
;
962 data
[pos
+1] = (pixel
>> green_shift_right
) << green_shift_left
;
963 data
[pos
+2] = (pixel
>> blue_shift_right
) << blue_shift_left
;
965 else if (cmap
->colors
)
967 data
[pos
] = cmap
->colors
[pixel
].red
>> 8;
968 data
[pos
+1] = cmap
->colors
[pixel
].green
>> 8;
969 data
[pos
+2] = cmap
->colors
[pixel
].blue
>> 8;
973 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
978 int mask_pixel
= gdk_image_get_pixel( gdk_image_mask
, i
, j
);
981 data
[pos
] = MASK_RED
;
982 data
[pos
+1] = MASK_GREEN
;
983 data
[pos
+2] = MASK_BLUE
;
985 else if ( data
[pos
] == MASK_RED
&&
986 data
[pos
+1] == MASK_GREEN
&&
987 data
[pos
+2] == MASK_BLUE
)
989 data
[pos
+2] = MASK_BLUE_REPLACEMENT
;
997 gdk_image_destroy( gdk_image
);
998 if (gdk_image_mask
) gdk_image_destroy( gdk_image_mask
);
1003 wxBitmap::wxBitmap( const wxBitmap
& bmp
)
1009 wxBitmap::wxBitmap( const wxString
&filename
, int type
)
1011 LoadFile( filename
, type
);
1014 wxBitmap::wxBitmap( const char bits
[], int width
, int height
, int WXUNUSED(depth
))
1016 if ( width
> 0 && height
> 0 )
1018 m_refData
= new wxBitmapRefData();
1020 M_BMPDATA
->m_mask
= (wxMask
*) NULL
;
1021 M_BMPDATA
->m_bitmap
= gdk_bitmap_create_from_data
1023 wxGetRootWindow()->window
,
1028 M_BMPDATA
->m_width
= width
;
1029 M_BMPDATA
->m_height
= height
;
1030 M_BMPDATA
->m_bpp
= 1;
1032 wxASSERT_MSG( M_BMPDATA
->m_bitmap
, wxT("couldn't create bitmap") );
1036 wxBitmap::~wxBitmap()
1040 wxBitmap
& wxBitmap::operator = ( const wxBitmap
& bmp
)
1042 if ( m_refData
!= bmp
.m_refData
)
1048 bool wxBitmap::operator == ( const wxBitmap
& bmp
) const
1050 return m_refData
== bmp
.m_refData
;
1053 bool wxBitmap::operator != ( const wxBitmap
& bmp
) const
1055 return m_refData
!= bmp
.m_refData
;
1058 bool wxBitmap::Ok() const
1060 return (m_refData
!= NULL
);
1063 int wxBitmap::GetHeight() const
1065 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1067 return M_BMPDATA
->m_height
;
1070 int wxBitmap::GetWidth() const
1072 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1074 return M_BMPDATA
->m_width
;
1077 int wxBitmap::GetDepth() const
1079 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1081 return M_BMPDATA
->m_bpp
;
1084 wxMask
*wxBitmap::GetMask() const
1086 wxCHECK_MSG( Ok(), (wxMask
*) NULL
, wxT("invalid bitmap") );
1088 return M_BMPDATA
->m_mask
;
1091 void wxBitmap::SetMask( wxMask
*mask
)
1093 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
1095 if (M_BMPDATA
->m_mask
) delete M_BMPDATA
->m_mask
;
1097 M_BMPDATA
->m_mask
= mask
;
1100 bool wxBitmap::CopyFromIcon(const wxIcon
& icon
)
1106 wxBitmap
wxBitmap::GetSubBitmap( const wxRect
& rect
) const
1108 wxCHECK_MSG( Ok() &&
1109 (rect
.x
>= 0) && (rect
.y
>= 0) &&
1110 (rect
.x
+rect
.width
<= M_BMPDATA
->m_width
) && (rect
.y
+rect
.height
<= M_BMPDATA
->m_height
),
1111 wxNullBitmap
, wxT("invalid bitmap or bitmap region") );
1113 wxBitmap
ret( rect
.width
, rect
.height
, M_BMPDATA
->m_bpp
);
1114 wxASSERT_MSG( ret
.Ok(), wxT("GetSubBitmap error") );
1116 if (ret
.GetPixmap())
1118 GdkGC
*gc
= gdk_gc_new( ret
.GetPixmap() );
1119 gdk_draw_pixmap( ret
.GetPixmap(), gc
, GetPixmap(), rect
.x
, rect
.y
, 0, 0, rect
.width
, rect
.height
);
1120 gdk_gc_destroy( gc
);
1124 GdkGC
*gc
= gdk_gc_new( ret
.GetBitmap() );
1125 gdk_wx_draw_bitmap( ret
.GetBitmap(), gc
, GetBitmap(), rect
.x
, rect
.y
, 0, 0, rect
.width
, rect
.height
);
1126 gdk_gc_destroy( gc
);
1131 wxMask
*mask
= new wxMask
;
1132 mask
->m_bitmap
= gdk_pixmap_new( wxGetRootWindow()->window
, rect
.width
, rect
.height
, 1 );
1134 GdkGC
*gc
= gdk_gc_new( mask
->m_bitmap
);
1135 gdk_wx_draw_bitmap( mask
->m_bitmap
, gc
, M_BMPDATA
->m_mask
->m_bitmap
, 0, 0, rect
.x
, rect
.y
, rect
.width
, rect
.height
);
1136 gdk_gc_destroy( gc
);
1138 ret
.SetMask( mask
);
1144 bool wxBitmap::SaveFile( const wxString
&name
, int type
, wxPalette
*WXUNUSED(palette
) )
1146 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid bitmap") );
1148 // Try to save the bitmap via wxImage handlers:
1150 wxImage image
= ConvertToImage();
1151 if (image
.Ok()) return image
.SaveFile( name
, type
);
1157 bool wxBitmap::LoadFile( const wxString
&name
, int type
)
1161 if (!wxFileExists(name
))
1164 GdkVisual
*visual
= wxTheApp
->GetGdkVisual();
1166 if (type
== wxBITMAP_TYPE_XPM
)
1168 m_refData
= new wxBitmapRefData();
1170 GdkBitmap
*mask
= (GdkBitmap
*) NULL
;
1172 M_BMPDATA
->m_pixmap
= gdk_pixmap_create_from_xpm
1174 wxGetRootWindow()->window
,
1182 M_BMPDATA
->m_mask
= new wxMask();
1183 M_BMPDATA
->m_mask
->m_bitmap
= mask
;
1186 gdk_window_get_size( M_BMPDATA
->m_pixmap
, &(M_BMPDATA
->m_width
), &(M_BMPDATA
->m_height
) );
1188 M_BMPDATA
->m_bpp
= visual
->depth
;
1190 else // try if wxImage can load it
1193 if ( !image
.LoadFile( name
, type
) || !image
.Ok() )
1196 *this = wxBitmap(image
);
1202 wxPalette
*wxBitmap::GetPalette() const
1205 return (wxPalette
*) NULL
;
1207 return M_BMPDATA
->m_palette
;
1210 void wxBitmap::SetHeight( int height
)
1213 m_refData
= new wxBitmapRefData();
1215 M_BMPDATA
->m_height
= height
;
1218 void wxBitmap::SetWidth( int width
)
1221 m_refData
= new wxBitmapRefData();
1223 M_BMPDATA
->m_width
= width
;
1226 void wxBitmap::SetDepth( int depth
)
1229 m_refData
= new wxBitmapRefData();
1231 M_BMPDATA
->m_bpp
= depth
;
1234 void wxBitmap::SetPixmap( GdkPixmap
*pixmap
)
1237 m_refData
= new wxBitmapRefData();
1239 M_BMPDATA
->m_pixmap
= pixmap
;
1242 void wxBitmap::SetBitmap( GdkPixmap
*bitmap
)
1245 m_refData
= new wxBitmapRefData();
1247 M_BMPDATA
->m_bitmap
= bitmap
;
1250 GdkPixmap
*wxBitmap::GetPixmap() const
1252 wxCHECK_MSG( Ok(), (GdkPixmap
*) NULL
, wxT("invalid bitmap") );
1254 return M_BMPDATA
->m_pixmap
;
1257 GdkBitmap
*wxBitmap::GetBitmap() const
1259 wxCHECK_MSG( Ok(), (GdkBitmap
*) NULL
, wxT("invalid bitmap") );
1261 return M_BMPDATA
->m_bitmap
;