]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/bitmap.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
always use HWND first in WM_COMMAND handler to avoid mixing the controls with the...
[wxWidgets.git] / src / gtk1 / bitmap.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: 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#ifdef __GNUG__
11#pragma implementation "bitmap.h"
12#endif
13
14#include "wx/defs.h"
15
16#include "wx/palette.h"
17#include "wx/bitmap.h"
18#include "wx/icon.h"
19#include "wx/filefn.h"
20#include "wx/image.h"
21#include "wx/dcmemory.h"
22#include "wx/app.h"
23
24#include <gdk/gdk.h>
25#include <gtk/gtk.h>
26#include <gdk/gdkx.h>
27
28#if (GTK_MINOR_VERSION > 0)
29#include <gdk/gdkrgb.h>
30#endif
31
32extern void gdk_wx_draw_bitmap (GdkDrawable *drawable,
33 GdkGC *gc,
34 GdkDrawable *src,
35 gint xsrc,
36 gint ysrc,
37 gint xdest,
38 gint ydest,
39 gint width,
40 gint height);
41
42//-----------------------------------------------------------------------------
43// data
44//-----------------------------------------------------------------------------
45
46extern GtkWidget *wxGetRootWindow();
47
48//-----------------------------------------------------------------------------
49// wxMask
50//-----------------------------------------------------------------------------
51
52IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
53
54wxMask::wxMask()
55{
56 m_bitmap = (GdkBitmap *) NULL;
57}
58
59wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
60{
61 m_bitmap = (GdkBitmap *) NULL;
62 Create( bitmap, colour );
63}
64
65wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
66{
67 m_bitmap = (GdkBitmap *) NULL;
68 Create( bitmap, paletteIndex );
69}
70
71wxMask::wxMask( const wxBitmap& bitmap )
72{
73 m_bitmap = (GdkBitmap *) NULL;
74 Create( bitmap );
75}
76
77wxMask::~wxMask()
78{
79 if (m_bitmap)
80 gdk_bitmap_unref( m_bitmap );
81}
82
83bool wxMask::Create( const wxBitmap& bitmap,
84 const wxColour& colour )
85{
86 if (m_bitmap)
87 {
88 gdk_bitmap_unref( m_bitmap );
89 m_bitmap = (GdkBitmap*) NULL;
90 }
91
92 wxImage image( bitmap );
93 if (!image.Ok()) return FALSE;
94
95 m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, image.GetWidth(), image.GetHeight(), 1 );
96 GdkGC *gc = gdk_gc_new( m_bitmap );
97
98 GdkColor color;
99 color.red = 65000;
100 color.green = 65000;
101 color.blue = 65000;
102 color.pixel = 1;
103 gdk_gc_set_foreground( gc, &color );
104 gdk_gc_set_fill( gc, GDK_SOLID );
105 gdk_draw_rectangle( m_bitmap, gc, TRUE, 0, 0, image.GetWidth(), image.GetHeight() );
106
107 unsigned char *data = image.GetData();
108 int index = 0;
109
110 unsigned char red = colour.Red();
111 unsigned char green = colour.Green();
112 unsigned char blue = colour.Blue();
113
114 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
115 wxASSERT( visual );
116
117 int bpp = visual->depth;
118 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
119 if (bpp == 15)
120 {
121 red = red & 0xf8;
122 green = green & 0xf8;
123 blue = blue & 0xf8;
124 }
125 if (bpp == 16)
126 {
127 red = red & 0xf8;
128 green = green & 0xfc;
129 blue = blue & 0xf8;
130 }
131
132 color.red = 0;
133 color.green = 0;
134 color.blue = 0;
135 color.pixel = 0;
136 gdk_gc_set_foreground( gc, &color );
137
138 for (int j = 0; j < image.GetHeight(); j++)
139 {
140 int start_x = -1;
141 int i;
142 for (i = 0; i < image.GetWidth(); i++)
143 {
144 if ((data[index] == red) &&
145 (data[index+1] == green) &&
146 (data[index+2] == blue))
147 {
148 if (start_x == -1)
149 start_x = i;
150 }
151 else
152 {
153 if (start_x != -1)
154 {
155 gdk_draw_line( m_bitmap, gc, start_x, j, i-1, j );
156 start_x = -1;
157 }
158 }
159 index += 3;
160 }
161 if (start_x != -1)
162 gdk_draw_line( m_bitmap, gc, start_x, j, i, j );
163 }
164
165 gdk_gc_unref( gc );
166
167 return TRUE;
168}
169
170bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
171{
172 unsigned char r,g,b;
173 wxPalette *pal = bitmap.GetPalette();
174
175 wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") );
176
177 pal->GetRGB(paletteIndex, &r, &g, &b);
178
179 return Create(bitmap, wxColour(r, g, b));
180}
181
182bool wxMask::Create( const wxBitmap& bitmap )
183{
184 if (m_bitmap)
185 {
186 gdk_bitmap_unref( m_bitmap );
187 m_bitmap = (GdkBitmap*) NULL;
188 }
189
190 if (!bitmap.Ok()) return FALSE;
191
192 wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") );
193
194 m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
195
196 if (!m_bitmap) return FALSE;
197
198 GdkGC *gc = gdk_gc_new( m_bitmap );
199
200 gdk_wx_draw_bitmap( m_bitmap, gc, bitmap.GetBitmap(), 0, 0, 0, 0, bitmap.GetWidth(), bitmap.GetHeight() );
201
202 gdk_gc_unref( gc );
203
204 return TRUE;
205}
206
207GdkBitmap *wxMask::GetBitmap() const
208{
209 return m_bitmap;
210}
211
212//-----------------------------------------------------------------------------
213// wxBitmap
214//-----------------------------------------------------------------------------
215
216class wxBitmapRefData: public wxObjectRefData
217{
218public:
219 wxBitmapRefData();
220 ~wxBitmapRefData();
221
222 GdkPixmap *m_pixmap;
223 GdkBitmap *m_bitmap;
224 wxMask *m_mask;
225 int m_width;
226 int m_height;
227 int m_bpp;
228 wxPalette *m_palette;
229};
230
231wxBitmapRefData::wxBitmapRefData()
232{
233 m_pixmap = (GdkPixmap *) NULL;
234 m_bitmap = (GdkBitmap *) NULL;
235 m_mask = (wxMask *) NULL;
236 m_width = 0;
237 m_height = 0;
238 m_bpp = 0;
239 m_palette = (wxPalette *) NULL;
240}
241
242wxBitmapRefData::~wxBitmapRefData()
243{
244 if (m_pixmap) gdk_pixmap_unref( m_pixmap );
245 if (m_bitmap) gdk_bitmap_unref( m_bitmap );
246 if (m_mask) delete m_mask;
247 if (m_palette) delete m_palette;
248}
249
250//-----------------------------------------------------------------------------
251
252#define M_BMPDATA ((wxBitmapRefData *)m_refData)
253
254IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
255
256wxBitmap::wxBitmap()
257{
258}
259
260wxBitmap::wxBitmap( int width, int height, int depth )
261{
262 Create( width, height, depth );
263}
264
265bool wxBitmap::Create( int width, int height, int depth )
266{
267 UnRef();
268
269 wxCHECK_MSG( (width > 0) && (height > 0), FALSE, wxT("invalid bitmap size") )
270
271 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
272 wxASSERT( visual );
273
274 if (depth == -1) depth = visual->depth;
275
276 wxCHECK_MSG( (depth == visual->depth) ||
277 (depth == 1), FALSE, wxT("invalid bitmap depth") )
278
279 m_refData = new wxBitmapRefData();
280 M_BMPDATA->m_mask = (wxMask *) NULL;
281 M_BMPDATA->m_width = width;
282 M_BMPDATA->m_height = height;
283 if (depth == 1)
284 {
285 M_BMPDATA->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
286 M_BMPDATA->m_bpp = 1;
287 }
288 else
289 {
290 M_BMPDATA->m_pixmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, depth );
291 M_BMPDATA->m_bpp = visual->depth;
292 }
293
294 return Ok();
295}
296
297bool wxBitmap::CreateFromXpm( const char **bits )
298{
299 wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
300
301 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
302 wxASSERT( visual );
303
304 m_refData = new wxBitmapRefData();
305
306 GdkBitmap *mask = (GdkBitmap*) NULL;
307
308 M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window, &mask, NULL, (gchar **) bits );
309
310 wxCHECK_MSG( M_BMPDATA->m_pixmap, FALSE, wxT("couldn't create pixmap") );
311
312 if (mask)
313 {
314 M_BMPDATA->m_mask = new wxMask();
315 M_BMPDATA->m_mask->m_bitmap = mask;
316 }
317
318 gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
319
320 M_BMPDATA->m_bpp = visual->depth; // ?
321
322 return TRUE;
323}
324
325bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
326{
327 wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
328 wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
329
330 m_refData = new wxBitmapRefData();
331
332 // ------
333 // convertion to mono bitmap:
334 // ------
335 if (depth == 1)
336 {
337 int width = image.GetWidth();
338 int height = image.GetHeight();
339
340 SetHeight( height );
341 SetWidth( width );
342
343 SetBitmap( gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 ) );
344
345 SetDepth( 1 );
346
347 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
348 wxASSERT( visual );
349
350 // Create picture image
351
352 unsigned char *data_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
353
354 GdkImage *data_image =
355 gdk_image_new_bitmap( visual, data_data, width, height );
356
357 // Create mask image
358
359 GdkImage *mask_image = (GdkImage*) NULL;
360
361 if (image.HasMask())
362 {
363 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
364
365 mask_image = gdk_image_new_bitmap( visual, mask_data, width, height );
366
367 wxMask *mask = new wxMask();
368 mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
369
370 SetMask( mask );
371 }
372
373 int r_mask = image.GetMaskRed();
374 int g_mask = image.GetMaskGreen();
375 int b_mask = image.GetMaskBlue();
376
377 unsigned char* data = image.GetData();
378
379 int index = 0;
380 for (int y = 0; y < height; y++)
381 {
382 for (int x = 0; x < width; x++)
383 {
384 int r = data[index];
385 index++;
386 int g = data[index];
387 index++;
388 int b = data[index];
389 index++;
390
391 if (image.HasMask())
392 {
393 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
394 gdk_image_put_pixel( mask_image, x, y, 1 );
395 else
396 gdk_image_put_pixel( mask_image, x, y, 0 );
397 }
398
399 if ((r == 255) && (b == 255) && (g == 255))
400 gdk_image_put_pixel( data_image, x, y, 1 );
401 else
402 gdk_image_put_pixel( data_image, x, y, 0 );
403
404 } // for
405 } // for
406
407 // Blit picture
408
409 GdkGC *data_gc = gdk_gc_new( GetBitmap() );
410
411 gdk_draw_image( GetBitmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
412
413 gdk_image_destroy( data_image );
414 gdk_gc_unref( data_gc );
415
416 // Blit mask
417
418 if (image.HasMask())
419 {
420 GdkGC *mask_gc = gdk_gc_new( GetMask()->GetBitmap() );
421
422 gdk_draw_image( GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
423
424 gdk_image_destroy( mask_image );
425 gdk_gc_unref( mask_gc );
426 }
427 }
428
429 // ------
430 // convertion to colour bitmap:
431 // ------
432 else
433 {
434 int width = image.GetWidth();
435 int height = image.GetHeight();
436
437 SetHeight( height );
438 SetWidth( width );
439
440 SetPixmap( gdk_pixmap_new( wxGetRootWindow()->window, width, height, -1 ) );
441
442 // Retrieve depth
443
444 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
445 wxASSERT( visual );
446
447 int bpp = visual->depth;
448
449 SetDepth( bpp );
450
451 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
452 if (bpp < 8) bpp = 8;
453
454#if (GTK_MINOR_VERSION > 0)
455
456 if (!image.HasMask() && (bpp > 8))
457 {
458 static bool s_hasInitialized = FALSE;
459
460 if (!s_hasInitialized)
461 {
462 gdk_rgb_init();
463 s_hasInitialized = TRUE;
464 }
465
466 GdkGC *gc = gdk_gc_new( GetPixmap() );
467
468 gdk_draw_rgb_image( GetPixmap(),
469 gc,
470 0, 0,
471 width, height,
472 GDK_RGB_DITHER_NONE,
473 image.GetData(),
474 width*3 );
475
476 gdk_gc_unref( gc );
477 return TRUE;
478 }
479
480#endif
481
482 // Create picture image
483
484 GdkImage *data_image =
485 gdk_image_new( GDK_IMAGE_FASTEST, visual, width, height );
486
487 // Create mask image
488
489 GdkImage *mask_image = (GdkImage*) NULL;
490
491 if (image.HasMask())
492 {
493 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
494
495 mask_image = gdk_image_new_bitmap( visual, mask_data, width, height );
496
497 wxMask *mask = new wxMask();
498 mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
499
500 SetMask( mask );
501 }
502
503 // Render
504
505 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
506 byte_order b_o = RGB;
507
508 if (bpp >= 24)
509 {
510 if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask)) b_o = RGB;
511 else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask)) b_o = RGB;
512 else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask)) b_o = BRG;
513 else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
514 else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask)) b_o = GRB;
515 else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask)) b_o = GBR;
516 }
517
518 int r_mask = image.GetMaskRed();
519 int g_mask = image.GetMaskGreen();
520 int b_mask = image.GetMaskBlue();
521
522 unsigned char* data = image.GetData();
523
524 int index = 0;
525 for (int y = 0; y < height; y++)
526 {
527 for (int x = 0; x < width; x++)
528 {
529 int r = data[index];
530 index++;
531 int g = data[index];
532 index++;
533 int b = data[index];
534 index++;
535
536 if (image.HasMask())
537 {
538 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
539 gdk_image_put_pixel( mask_image, x, y, 1 );
540 else
541 gdk_image_put_pixel( mask_image, x, y, 0 );
542 }
543
544 switch (bpp)
545 {
546 case 8:
547 {
548 int pixel = -1;
549 if (wxTheApp->m_colorCube)
550 {
551 pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
552 }
553 else
554 {
555 GdkColormap *cmap = gtk_widget_get_default_colormap();
556 GdkColor *colors = cmap->colors;
557 int max = 3 * (65536);
558
559 for (int i = 0; i < cmap->size; i++)
560 {
561 int rdiff = (r << 8) - colors[i].red;
562 int gdiff = (g << 8) - colors[i].green;
563 int bdiff = (b << 8) - colors[i].blue;
564 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
565 if (sum < max) { pixel = i; max = sum; }
566 }
567 }
568
569 gdk_image_put_pixel( data_image, x, y, pixel );
570
571 break;
572 }
573 case 15:
574 {
575 guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
576 gdk_image_put_pixel( data_image, x, y, pixel );
577 break;
578 }
579 case 16:
580 {
581 guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
582 gdk_image_put_pixel( data_image, x, y, pixel );
583 break;
584 }
585 case 32:
586 case 24:
587 {
588 guint32 pixel = 0;
589 switch (b_o)
590 {
591 case RGB: pixel = (r << 16) | (g << 8) | b; break;
592 case RBG: pixel = (r << 16) | (b << 8) | g; break;
593 case BRG: pixel = (b << 16) | (r << 8) | g; break;
594 case BGR: pixel = (b << 16) | (g << 8) | r; break;
595 case GRB: pixel = (g << 16) | (r << 8) | b; break;
596 case GBR: pixel = (g << 16) | (b << 8) | r; break;
597 }
598 gdk_image_put_pixel( data_image, x, y, pixel );
599 }
600 default: break;
601 }
602 } // for
603 } // for
604
605 // Blit picture
606
607 GdkGC *data_gc = gdk_gc_new( GetPixmap() );
608
609 gdk_draw_image( GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
610
611 gdk_image_destroy( data_image );
612 gdk_gc_unref( data_gc );
613
614 // Blit mask
615
616 if (image.HasMask())
617 {
618 GdkGC *mask_gc = gdk_gc_new( GetMask()->GetBitmap() );
619
620 gdk_draw_image( GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
621
622 gdk_image_destroy( mask_image );
623 gdk_gc_unref( mask_gc );
624 }
625 }
626
627 return TRUE;
628}
629
630wxImage wxBitmap::ConvertToImage() const
631{
632 wxImage image;
633
634 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
635
636 GdkImage *gdk_image = (GdkImage*) NULL;
637 if (GetPixmap())
638 {
639 gdk_image = gdk_image_get( GetPixmap(),
640 0, 0,
641 GetWidth(), GetHeight() );
642 } else
643 if (GetBitmap())
644 {
645 gdk_image = gdk_image_get( GetBitmap(),
646 0, 0,
647 GetWidth(), GetHeight() );
648 } else
649 {
650 wxFAIL_MSG( wxT("Ill-formed bitmap") );
651 }
652
653 wxCHECK_MSG( gdk_image, wxNullImage, wxT("couldn't create image") );
654
655 image.Create( GetWidth(), GetHeight() );
656 char unsigned *data = image.GetData();
657
658 if (!data)
659 {
660 gdk_image_destroy( gdk_image );
661 wxFAIL_MSG( wxT("couldn't create image") );
662 return wxNullImage;
663 }
664
665 GdkImage *gdk_image_mask = (GdkImage*) NULL;
666 if (GetMask())
667 {
668 gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
669 0, 0,
670 GetWidth(), GetHeight() );
671
672 image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
673 }
674
675 int bpp = -1;
676 int red_shift_right = 0;
677 int green_shift_right = 0;
678 int blue_shift_right = 0;
679 int red_shift_left = 0;
680 int green_shift_left = 0;
681 int blue_shift_left = 0;
682 bool use_shift = FALSE;
683
684 if (GetPixmap())
685 {
686 GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
687
688 if (visual == NULL) visual = gdk_window_get_visual( wxGetRootWindow()->window );
689 bpp = visual->depth;
690 if (bpp == 16) bpp = visual->red_prec + visual->green_prec + visual->blue_prec;
691 red_shift_right = visual->red_shift;
692 red_shift_left = 8-visual->red_prec;
693 green_shift_right = visual->green_shift;
694 green_shift_left = 8-visual->green_prec;
695 blue_shift_right = visual->blue_shift;
696 blue_shift_left = 8-visual->blue_prec;
697
698 use_shift = (visual->type == GDK_VISUAL_TRUE_COLOR) || (visual->type == GDK_VISUAL_DIRECT_COLOR);
699 }
700 if (GetBitmap())
701 {
702 bpp = 1;
703 }
704
705
706 GdkColormap *cmap = gtk_widget_get_default_colormap();
707
708 long pos = 0;
709 for (int j = 0; j < GetHeight(); j++)
710 {
711 for (int i = 0; i < GetWidth(); i++)
712 {
713 wxUint32 pixel = gdk_image_get_pixel( gdk_image, i, j );
714 if (bpp == 1)
715 {
716 if (pixel == 0)
717 {
718 data[pos] = 0;
719 data[pos+1] = 0;
720 data[pos+2] = 0;
721 }
722 else
723 {
724 data[pos] = 255;
725 data[pos+1] = 255;
726 data[pos+2] = 255;
727 }
728 }
729 else if (use_shift)
730 {
731 data[pos] = (pixel >> red_shift_right) << red_shift_left;
732 data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
733 data[pos+2] = (pixel >> blue_shift_right) << blue_shift_left;
734 }
735 else if (cmap->colors)
736 {
737 data[pos] = cmap->colors[pixel].red >> 8;
738 data[pos+1] = cmap->colors[pixel].green >> 8;
739 data[pos+2] = cmap->colors[pixel].blue >> 8;
740 }
741 else
742 {
743 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
744 }
745
746 if (gdk_image_mask)
747 {
748 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
749 if (mask_pixel == 0)
750 {
751 data[pos] = 16;
752 data[pos+1] = 16;
753 data[pos+2] = 16;
754 }
755 }
756
757 pos += 3;
758 }
759 }
760
761 gdk_image_destroy( gdk_image );
762 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
763
764 return image;
765}
766
767wxBitmap::wxBitmap( const wxBitmap& bmp )
768{
769 Ref( bmp );
770}
771
772wxBitmap::wxBitmap( const wxString &filename, int type )
773{
774 LoadFile( filename, type );
775}
776
777wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth))
778{
779 m_refData = new wxBitmapRefData();
780
781 M_BMPDATA->m_mask = (wxMask *) NULL;
782 M_BMPDATA->m_bitmap =
783 gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) bits, width, height );
784 M_BMPDATA->m_width = width;
785 M_BMPDATA->m_height = height;
786 M_BMPDATA->m_bpp = 1;
787
788 wxCHECK_RET( M_BMPDATA->m_bitmap, wxT("couldn't create bitmap") );
789}
790
791wxBitmap::~wxBitmap()
792{
793}
794
795wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
796{
797 if ( m_refData != bmp.m_refData )
798 Ref( bmp );
799
800 return *this;
801}
802
803bool wxBitmap::operator == ( const wxBitmap& bmp ) const
804{
805 return m_refData == bmp.m_refData;
806}
807
808bool wxBitmap::operator != ( const wxBitmap& bmp ) const
809{
810 return m_refData != bmp.m_refData;
811}
812
813bool wxBitmap::Ok() const
814{
815 return (m_refData != NULL);
816}
817
818int wxBitmap::GetHeight() const
819{
820 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
821
822 return M_BMPDATA->m_height;
823}
824
825int wxBitmap::GetWidth() const
826{
827 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
828
829 return M_BMPDATA->m_width;
830}
831
832int wxBitmap::GetDepth() const
833{
834 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
835
836 return M_BMPDATA->m_bpp;
837}
838
839wxMask *wxBitmap::GetMask() const
840{
841 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
842
843 return M_BMPDATA->m_mask;
844}
845
846void wxBitmap::SetMask( wxMask *mask )
847{
848 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
849
850 if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
851
852 M_BMPDATA->m_mask = mask;
853}
854
855bool wxBitmap::CopyFromIcon(const wxIcon& icon)
856{
857 *this = icon;
858 return TRUE;
859}
860
861wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
862{
863 wxCHECK_MSG( Ok() &&
864 (rect.x >= 0) && (rect.y >= 0) &&
865 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
866 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
867
868 wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
869 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
870
871 if (ret.GetPixmap())
872 {
873 GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
874 gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
875 gdk_gc_destroy( gc );
876 }
877 else
878 {
879 GdkGC *gc = gdk_gc_new( ret.GetBitmap() );
880 gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
881 gdk_gc_destroy( gc );
882 }
883
884 if (GetMask())
885 {
886 wxMask *mask = new wxMask;
887 mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 );
888
889 GdkGC *gc = gdk_gc_new( mask->m_bitmap );
890 gdk_wx_draw_bitmap( mask->m_bitmap, gc, M_BMPDATA->m_mask->m_bitmap, 0, 0, rect.x, rect.y, rect.width, rect.height );
891 gdk_gc_destroy( gc );
892
893 ret.SetMask( mask );
894 }
895
896 return ret;
897}
898
899bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) )
900{
901 wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
902
903 // Try to save the bitmap via wxImage handlers:
904 {
905 wxImage image( *this );
906 if (image.Ok()) return image.SaveFile( name, type );
907 }
908
909 return FALSE;
910}
911
912bool wxBitmap::LoadFile( const wxString &name, int type )
913{
914 UnRef();
915
916 if (!wxFileExists(name)) return FALSE;
917
918 GdkVisual *visual = gdk_window_get_visual( wxGetRootWindow()->window );
919 wxASSERT( visual );
920
921 if (type == wxBITMAP_TYPE_XPM)
922 {
923 m_refData = new wxBitmapRefData();
924
925 GdkBitmap *mask = (GdkBitmap*) NULL;
926
927 M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm( wxGetRootWindow()->window, &mask, NULL, name.fn_str() );
928
929 if (mask)
930 {
931 M_BMPDATA->m_mask = new wxMask();
932 M_BMPDATA->m_mask->m_bitmap = mask;
933 }
934
935 gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
936
937 M_BMPDATA->m_bpp = visual->depth;
938 }
939 else // try if wxImage can load it
940 {
941 wxImage image;
942 if (!image.LoadFile( name, type )) return FALSE;
943 if (image.Ok()) *this = image.ConvertToBitmap();
944 else return FALSE;
945 }
946
947 return TRUE;
948}
949
950wxPalette *wxBitmap::GetPalette() const
951{
952 if (!Ok()) return (wxPalette *) NULL;
953
954 return M_BMPDATA->m_palette;
955}
956
957void wxBitmap::SetHeight( int height )
958{
959 if (!m_refData) m_refData = new wxBitmapRefData();
960
961 M_BMPDATA->m_height = height;
962}
963
964void wxBitmap::SetWidth( int width )
965{
966 if (!m_refData) m_refData = new wxBitmapRefData();
967
968 M_BMPDATA->m_width = width;
969}
970
971void wxBitmap::SetDepth( int depth )
972{
973 if (!m_refData) m_refData = new wxBitmapRefData();
974
975 M_BMPDATA->m_bpp = depth;
976}
977
978void wxBitmap::SetPixmap( GdkPixmap *pixmap )
979{
980 if (!m_refData) m_refData = new wxBitmapRefData();
981
982 M_BMPDATA->m_pixmap = pixmap;
983}
984
985void wxBitmap::SetBitmap( GdkPixmap *bitmap )
986{
987 if (!m_refData) m_refData = new wxBitmapRefData();
988
989 M_BMPDATA->m_bitmap = bitmap;
990}
991
992GdkPixmap *wxBitmap::GetPixmap() const
993{
994 wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
995
996 return M_BMPDATA->m_pixmap;
997}
998
999GdkBitmap *wxBitmap::GetBitmap() const
1000{
1001 wxCHECK_MSG( Ok(), (GdkBitmap *) NULL, wxT("invalid bitmap") );
1002
1003 return M_BMPDATA->m_bitmap;
1004}
wxWidgets (Impactor)