]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/bitmap.cpp
Improve wxMenu docs
[wxWidgets.git] / src / gtk / bitmap.cpp
... / ...
CommitLineData
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/app.h"
17 #include "wx/palette.h"
18 #include "wx/icon.h"
19 #include "wx/math.h"
20 #include "wx/image.h"
21 #include "wx/colour.h"
22#endif
23
24#include "wx/rawbmp.h"
25
26#include <gtk/gtk.h>
27
28//-----------------------------------------------------------------------------
29// data
30//-----------------------------------------------------------------------------
31
32extern GtkWidget *wxGetRootWindow();
33
34//-----------------------------------------------------------------------------
35// wxMask
36//-----------------------------------------------------------------------------
37
38IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
39
40wxMask::wxMask()
41{
42 m_bitmap = (GdkBitmap *) NULL;
43}
44
45wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
46{
47 m_bitmap = (GdkBitmap *) NULL;
48 Create( bitmap, colour );
49}
50
51#if wxUSE_PALETTE
52wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
53{
54 m_bitmap = (GdkBitmap *) NULL;
55 Create( bitmap, paletteIndex );
56}
57#endif // wxUSE_PALETTE
58
59wxMask::wxMask( const wxBitmap& bitmap )
60{
61 m_bitmap = (GdkBitmap *) NULL;
62 Create( bitmap );
63}
64
65wxMask::~wxMask()
66{
67 if (m_bitmap)
68 g_object_unref (m_bitmap);
69}
70
71bool wxMask::Create( const wxBitmap& bitmap,
72 const wxColour& colour )
73{
74 if (m_bitmap)
75 {
76 g_object_unref (m_bitmap);
77 m_bitmap = (GdkBitmap*) NULL;
78 }
79
80 const int w = bitmap.GetWidth();
81 const int h = bitmap.GetHeight();
82
83 // create mask as XBM format bitmap
84
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())
92 {
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)
101 {
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;
107 }
108 }
109 else
110 {
111 GdkImage* image = gdk_drawable_get_image(bitmap.GetPixmap(), 0, 0, w, h);
112 GdkColormap* colormap = gdk_image_get_colormap(image);
113 guint32 mask_pixel;
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);
117 else
118 {
119 wxColor c(colour);
120 c.CalcPixel(colormap);
121 mask_pixel = c.GetPixel();
122 }
123 for (int y = 0; y < h; y++)
124 {
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;
129 }
130 g_object_unref(image);
131 }
132 m_bitmap = gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h);
133 delete[] out;
134 return true;
135}
136
137#if wxUSE_PALETTE
138bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
139{
140 unsigned char r,g,b;
141 wxPalette *pal = bitmap.GetPalette();
142
143 wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
144
145 pal->GetRGB(paletteIndex, &r, &g, &b);
146
147 return Create(bitmap, wxColour(r, g, b));
148}
149#endif // wxUSE_PALETTE
150
151bool wxMask::Create( const wxBitmap& bitmap )
152{
153 if (m_bitmap)
154 {
155 g_object_unref (m_bitmap);
156 m_bitmap = (GdkBitmap*) NULL;
157 }
158
159 if (!bitmap.Ok()) return false;
160
161 wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
162
163 m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
164
165 if (!m_bitmap) return false;
166
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());
170 g_object_unref (gc);
171
172 return true;
173}
174
175GdkBitmap *wxMask::GetBitmap() const
176{
177 return m_bitmap;
178}
179
180//-----------------------------------------------------------------------------
181// wxBitmap
182//-----------------------------------------------------------------------------
183
184class wxBitmapRefData: public wxGDIRefData
185{
186public:
187 wxBitmapRefData();
188 virtual ~wxBitmapRefData();
189
190 virtual bool IsOk() const { return m_pixmap || m_pixbuf; }
191
192 GdkPixmap *m_pixmap;
193 GdkPixbuf *m_pixbuf;
194 wxMask *m_mask;
195 int m_width;
196 int m_height;
197 int m_bpp;
198#if wxUSE_PALETTE
199 wxPalette *m_palette;
200#endif // wxUSE_PALETTE
201};
202
203wxBitmapRefData::wxBitmapRefData()
204{
205 m_pixmap = (GdkPixmap *) NULL;
206 m_pixbuf = (GdkPixbuf *) NULL;
207 m_mask = (wxMask *) NULL;
208 m_width = 0;
209 m_height = 0;
210 m_bpp = 0;
211#if wxUSE_PALETTE
212 m_palette = (wxPalette *) NULL;
213#endif // wxUSE_PALETTE
214}
215
216wxBitmapRefData::~wxBitmapRefData()
217{
218 if (m_pixmap)
219 g_object_unref (m_pixmap);
220 if (m_pixbuf)
221 g_object_unref (m_pixbuf);
222 delete m_mask;
223#if wxUSE_PALETTE
224 delete m_palette;
225#endif // wxUSE_PALETTE
226}
227
228//-----------------------------------------------------------------------------
229
230#define M_BMPDATA wx_static_cast(wxBitmapRefData*, m_refData)
231
232IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
233
234wxBitmap::wxBitmap(int width, int height, int depth)
235{
236 Create(width, height, depth);
237}
238
239wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
240{
241 LoadFile(filename, type);
242}
243
244wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
245{
246 wxASSERT(depth == 1);
247 if (width > 0 && height > 0 && depth == 1)
248 {
249 SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, bits, width, height));
250
251 wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("couldn't create bitmap") );
252 }
253}
254
255wxBitmap::wxBitmap(const char* const* bits)
256{
257 wxCHECK2_MSG(bits != NULL, return, wxT("invalid bitmap data"));
258
259 GdkBitmap* mask = NULL;
260 SetPixmap(gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window, &mask, NULL, wx_const_cast(char**, bits)));
261
262 if (M_BMPDATA->m_pixmap != NULL && mask != NULL)
263 {
264 M_BMPDATA->m_mask = new wxMask;
265 M_BMPDATA->m_mask->m_bitmap = mask;
266 }
267}
268
269wxBitmap::~wxBitmap()
270{
271}
272
273bool wxBitmap::Create( int width, int height, int depth )
274{
275 UnRef();
276
277 if ( width <= 0 || height <= 0 )
278 {
279 return false;
280 }
281
282 if (depth == 32)
283 {
284 SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, width, height), 32);
285 }
286 else
287 {
288 if (depth != 1)
289 {
290 const GdkVisual* visual = wxTheApp->GetGdkVisual();
291 if (depth == -1)
292 depth = visual->depth;
293
294 wxCHECK_MSG(depth == visual->depth, false, wxT("invalid bitmap depth"));
295 }
296
297 SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, width, height, depth));
298 }
299
300 return Ok();
301}
302
303wxBitmap wxBitmap::Rescale(int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy) const
304{
305 wxBitmap bmp;
306
307 wxCHECK_MSG(Ok(), bmp, wxT("invalid bitmap"));
308
309 int width = wxMax(newx, 1);
310 int height = wxMax(newy, 1);
311 width = wxMin(width, clipwidth);
312 height = wxMin(height, clipheight);
313
314 const double scale_x = double(newx) / M_BMPDATA->m_width;
315 const double scale_y = double(newy) / M_BMPDATA->m_height;
316
317 // Converting to pixbuf, scaling with gdk_pixbuf_scale, and converting
318 // back, is faster than scaling pixmap ourselves.
319
320 // use pixbuf if already available,
321 // otherwise create temporary pixbuf from pixmap
322 GdkPixbuf* pixbuf = M_BMPDATA->m_pixbuf;
323 if (pixbuf)
324 g_object_ref(pixbuf);
325 else
326 pixbuf = gdk_pixbuf_get_from_drawable(
327 NULL, M_BMPDATA->m_pixmap, NULL,
328 0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);
329
330 // new pixbuf for scaled wxBitmap
331 GdkPixbuf* pixbuf_scaled = gdk_pixbuf_new(
332 GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf), 8, width, height);
333
334 // GDK_INTERP_NEAREST is the lowest-quality method for continuous-tone
335 // images, but the only one which preserves sharp edges
336 gdk_pixbuf_scale(
337 pixbuf, pixbuf_scaled,
338 0, 0, width, height, -clipx, -clipy, scale_x, scale_y,
339 GDK_INTERP_NEAREST);
340
341 g_object_unref(pixbuf);
342 bmp.SetPixbuf(pixbuf_scaled, M_BMPDATA->m_bpp);
343
344 if (M_BMPDATA->m_mask)
345 {
346 pixbuf = gdk_pixbuf_get_from_drawable(
347 NULL, M_BMPDATA->m_mask->m_bitmap, NULL,
348 0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);
349
350 pixbuf_scaled = gdk_pixbuf_new(
351 GDK_COLORSPACE_RGB, false, 8, width, height);
352
353 gdk_pixbuf_scale(
354 pixbuf, pixbuf_scaled,
355 0, 0, width, height, -clipx, -clipy, scale_x, scale_y,
356 GDK_INTERP_NEAREST);
357
358 g_object_unref(pixbuf);
359
360 // use existing functionality to create mask from scaled pixbuf
361 wxBitmap maskbmp;
362 maskbmp.SetPixbuf(pixbuf_scaled);
363 bmp.SetMask(new wxMask(maskbmp, *wxBLACK));
364 }
365 return bmp;
366}
367
368#if wxUSE_IMAGE
369
370bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
371{
372 UnRef();
373
374 wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
375 wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") );
376
377 if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
378 return false;
379
380 // create pixbuf if image has alpha and requested depth is compatible
381 if (image.HasAlpha() && (depth == -1 || depth == 32))
382 return CreateFromImageAsPixbuf(image);
383
384 // otherwise create pixmap, if alpha is present it will be converted to mask
385 return CreateFromImageAsPixmap(image, depth);
386}
387
388bool wxBitmap::CreateFromImageAsPixmap(const wxImage& image, int depth)
389{
390 const int w = image.GetWidth();
391 const int h = image.GetHeight();
392 if (depth == 1)
393 {
394 // create XBM format bitmap
395
396 // one bit per pixel, each row starts on a byte boundary
397 const size_t out_size = size_t((w + 7) / 8) * unsigned(h);
398 wxByte* out = new wxByte[out_size];
399 // set bits are black
400 memset(out, 0xff, out_size);
401 const wxByte* in = image.GetData();
402 unsigned bit_index = 0;
403 for (int y = 0; y < h; y++)
404 {
405 for (int x = 0; x < w; x++, in += 3, bit_index++)
406 if (in[0] == 255 && in[1] == 255 && in[2] == 255)
407 out[bit_index >> 3] ^= 1 << (bit_index & 7);
408 // move index to next byte boundary
409 bit_index = (bit_index + 7) & ~7u;
410 }
411 SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h));
412 delete[] out;
413 }
414 else
415 {
416 SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, w, h, depth));
417 GdkGC* gc = gdk_gc_new(M_BMPDATA->m_pixmap);
418 gdk_draw_rgb_image(
419 M_BMPDATA->m_pixmap, gc,
420 0, 0, w, h,
421 GDK_RGB_DITHER_NONE, image.GetData(), w * 3);
422 g_object_unref(gc);
423 }
424
425 const wxByte* alpha = image.GetAlpha();
426 if (alpha != NULL || image.HasMask())
427 {
428 // create mask as XBM format bitmap
429
430 const size_t out_size = size_t((w + 7) / 8) * unsigned(h);
431 wxByte* out = new wxByte[out_size];
432 memset(out, 0xff, out_size);
433 unsigned bit_index = 0;
434 if (alpha != NULL)
435 {
436 for (int y = 0; y < h; y++)
437 {
438 for (int x = 0; x < w; x++, bit_index++)
439 if (*alpha++ < wxIMAGE_ALPHA_THRESHOLD)
440 out[bit_index >> 3] ^= 1 << (bit_index & 7);
441 bit_index = (bit_index + 7) & ~7u;
442 }
443 }
444 else
445 {
446 const wxByte r_mask = image.GetMaskRed();
447 const wxByte g_mask = image.GetMaskGreen();
448 const wxByte b_mask = image.GetMaskBlue();
449 const wxByte* in = image.GetData();
450 for (int y = 0; y < h; y++)
451 {
452 for (int x = 0; x < w; x++, in += 3, bit_index++)
453 if (in[0] == r_mask && in[1] == g_mask && in[2] == b_mask)
454 out[bit_index >> 3] ^= 1 << (bit_index & 7);
455 bit_index = (bit_index + 7) & ~7u;
456 }
457 }
458 wxMask* mask = new wxMask;
459 mask->m_bitmap = gdk_bitmap_create_from_data(M_BMPDATA->m_pixmap, (char*)out, w, h);
460 SetMask(mask);
461 delete[] out;
462 }
463 return true;
464}
465
466bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
467{
468 wxASSERT(image.HasAlpha());
469
470 int width = image.GetWidth();
471 int height = image.GetHeight();
472
473 Create(width, height, 32);
474 GdkPixbuf* pixbuf = M_BMPDATA->m_pixbuf;
475 if (!pixbuf)
476 return false;
477
478 // Copy the data:
479 const unsigned char* in = image.GetData();
480 unsigned char *out = gdk_pixbuf_get_pixels(pixbuf);
481 unsigned char *alpha = image.GetAlpha();
482
483 int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
484
485 for (int y = 0; y < height; y++, out += rowpad)
486 {
487 for (int x = 0; x < width; x++, alpha++, out += 4, in += 3)
488 {
489 out[0] = in[0];
490 out[1] = in[1];
491 out[2] = in[2];
492 out[3] = *alpha;
493 }
494 }
495
496 return true;
497}
498
499wxImage wxBitmap::ConvertToImage() const
500{
501 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
502
503 const int w = GetWidth();
504 const int h = GetHeight();
505 wxImage image(w, h, false);
506 unsigned char *data = image.GetData();
507
508 wxCHECK_MSG(data != NULL, wxNullImage, wxT("couldn't create image") );
509
510 // prefer pixbuf if available, it will preserve alpha and should be quicker
511 if (HasPixbuf())
512 {
513 GdkPixbuf *pixbuf = GetPixbuf();
514 unsigned char* alpha = NULL;
515 if (gdk_pixbuf_get_has_alpha(pixbuf))
516 {
517 image.SetAlpha();
518 alpha = image.GetAlpha();
519 }
520 const unsigned char* in = gdk_pixbuf_get_pixels(pixbuf);
521 unsigned char *out = data;
522 const int inc = 3 + int(alpha != NULL);
523 const int rowpad = gdk_pixbuf_get_rowstride(pixbuf) - inc * w;
524
525 for (int y = 0; y < h; y++, in += rowpad)
526 {
527 for (int x = 0; x < w; x++, in += inc, out += 3)
528 {
529 out[0] = in[0];
530 out[1] = in[1];
531 out[2] = in[2];
532 if (alpha != NULL)
533 *alpha++ = in[3];
534 }
535 }
536 }
537 else
538 {
539 GdkPixmap* pixmap = GetPixmap();
540 GdkPixmap* pixmap_invert = NULL;
541 if (GetDepth() == 1)
542 {
543 // mono bitmaps are inverted, i.e. 0 is white
544 pixmap_invert = gdk_pixmap_new(pixmap, w, h, 1);
545 GdkGC* gc = gdk_gc_new(pixmap_invert);
546 gdk_gc_set_function(gc, GDK_COPY_INVERT);
547 gdk_draw_drawable(pixmap_invert, gc, pixmap, 0, 0, 0, 0, w, h);
548 g_object_unref(gc);
549 pixmap = pixmap_invert;
550 }
551 // create a pixbuf which shares data with the wxImage
552 GdkPixbuf* pixbuf = gdk_pixbuf_new_from_data(
553 data, GDK_COLORSPACE_RGB, false, 8, w, h, 3 * w, NULL, NULL);
554
555 gdk_pixbuf_get_from_drawable(pixbuf, pixmap, NULL, 0, 0, 0, 0, w, h);
556
557 g_object_unref(pixbuf);
558 if (pixmap_invert != NULL)
559 g_object_unref(pixmap_invert);
560 }
561 // convert mask, unless there is already alpha
562 if (GetMask() && !image.HasAlpha())
563 {
564 // we hard code the mask colour for now but we could also make an
565 // effort (and waste time) to choose a colour not present in the
566 // image already to avoid having to fudge the pixels below --
567 // whether it's worth to do it is unclear however
568 const int MASK_RED = 1;
569 const int MASK_GREEN = 2;
570 const int MASK_BLUE = 3;
571 const int MASK_BLUE_REPLACEMENT = 2;
572
573 image.SetMaskColour(MASK_RED, MASK_GREEN, MASK_BLUE);
574 GdkImage* image_mask = gdk_drawable_get_image(GetMask()->GetBitmap(), 0, 0, w, h);
575
576 for (int y = 0; y < h; y++)
577 {
578 for (int x = 0; x < w; x++, data += 3)
579 {
580 if (gdk_image_get_pixel(image_mask, x, y) == 0)
581 {
582 data[0] = MASK_RED;
583 data[1] = MASK_GREEN;
584 data[2] = MASK_BLUE;
585 }
586 else if (data[0] == MASK_RED && data[1] == MASK_GREEN && data[2] == MASK_BLUE)
587 {
588 // we have to fudge the colour a bit to prevent
589 // this pixel from appearing transparent
590 data[2] = MASK_BLUE_REPLACEMENT;
591 }
592 }
593 }
594 g_object_unref(image_mask);
595 }
596
597 return image;
598}
599
600#endif // wxUSE_IMAGE
601
602int wxBitmap::GetHeight() const
603{
604 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
605
606 return M_BMPDATA->m_height;
607}
608
609int wxBitmap::GetWidth() const
610{
611 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
612
613 return M_BMPDATA->m_width;
614}
615
616int wxBitmap::GetDepth() const
617{
618 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
619
620 return M_BMPDATA->m_bpp;
621}
622
623wxMask *wxBitmap::GetMask() const
624{
625 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
626
627 return M_BMPDATA->m_mask;
628}
629
630void wxBitmap::SetMask( wxMask *mask )
631{
632 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
633
634 AllocExclusive();
635 delete M_BMPDATA->m_mask;
636 M_BMPDATA->m_mask = mask;
637}
638
639bool wxBitmap::CopyFromIcon(const wxIcon& icon)
640{
641 *this = icon;
642 return Ok();
643}
644
645wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
646{
647 wxBitmap ret;
648
649 wxCHECK_MSG(Ok(), ret, wxT("invalid bitmap"));
650 wxCHECK_MSG(rect.x >= 0 && rect.y >= 0 &&
651 rect.x + rect.width <= M_BMPDATA->m_width &&
652 rect.y + rect.height <= M_BMPDATA->m_height,
653 ret, wxT("invalid bitmap region"));
654
655 if (HasPixbuf() || M_BMPDATA->m_bpp == 32)
656 {
657 GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
658 gdk_pixbuf_get_has_alpha(GetPixbuf()),
659 8, rect.width, rect.height);
660 ret.SetPixbuf(pixbuf, M_BMPDATA->m_bpp);
661 gdk_pixbuf_copy_area(GetPixbuf(),
662 rect.x, rect.y, rect.width, rect.height,
663 pixbuf, 0, 0);
664 }
665 else
666 {
667 ret.Create(rect.width, rect.height, M_BMPDATA->m_bpp);
668 GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
669 gdk_draw_drawable( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
670 g_object_unref (gc);
671 }
672 // make mask, unless there is already alpha
673 if (GetMask() && !HasAlpha())
674 {
675 wxMask *mask = new wxMask;
676 mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 );
677
678 GdkGC *gc = gdk_gc_new( mask->m_bitmap );
679 gdk_draw_drawable(mask->m_bitmap, gc, M_BMPDATA->m_mask->m_bitmap, rect.x, rect.y, 0, 0, rect.width, rect.height);
680 g_object_unref (gc);
681
682 ret.SetMask( mask );
683 }
684
685 return ret;
686}
687
688bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalette *WXUNUSED(palette) ) const
689{
690 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
691
692#if wxUSE_IMAGE
693 // Try to save the bitmap via wxImage handlers:
694 wxImage image = ConvertToImage();
695 return image.Ok() && image.SaveFile(name, type);
696#else // !wxUSE_IMAGE
697 wxUnusedVar(name);
698 wxUnusedVar(type);
699
700 return false;
701#endif // wxUSE_IMAGE
702}
703
704bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
705{
706 UnRef();
707
708 if (type == wxBITMAP_TYPE_XPM)
709 {
710 GdkBitmap *mask = (GdkBitmap*) NULL;
711 SetPixmap(gdk_pixmap_create_from_xpm(wxGetRootWindow()->window, &mask, NULL, name.fn_str()));
712
713 if (mask)
714 {
715 M_BMPDATA->m_mask = new wxMask;
716 M_BMPDATA->m_mask->m_bitmap = mask;
717 }
718 }
719#if wxUSE_IMAGE
720 else // try if wxImage can load it
721 {
722 wxImage image;
723 if (image.LoadFile(name, type) && image.Ok())
724 CreateFromImage(image, -1);
725 }
726#endif // wxUSE_IMAGE
727
728 return Ok();
729}
730
731#if wxUSE_PALETTE
732wxPalette *wxBitmap::GetPalette() const
733{
734 wxCHECK_MSG(Ok(), NULL, wxT("invalid bitmap"));
735
736 return M_BMPDATA->m_palette;
737}
738
739void wxBitmap::SetPalette(const wxPalette& WXUNUSED(palette))
740{
741 // TODO
742}
743#endif // wxUSE_PALETTE
744
745void wxBitmap::SetHeight( int height )
746{
747 AllocExclusive();
748 M_BMPDATA->m_height = height;
749}
750
751void wxBitmap::SetWidth( int width )
752{
753 AllocExclusive();
754 M_BMPDATA->m_width = width;
755}
756
757void wxBitmap::SetDepth( int depth )
758{
759 AllocExclusive();
760 M_BMPDATA->m_bpp = depth;
761}
762
763void wxBitmap::SetPixmap( GdkPixmap *pixmap )
764{
765 if (!m_refData)
766 m_refData = new wxBitmapRefData;
767
768 // AllocExclusive should not be needed for this internal function
769 wxASSERT(m_refData->GetRefCount() == 1);
770 wxASSERT(M_BMPDATA->m_pixmap == NULL);
771 M_BMPDATA->m_pixmap = pixmap;
772 gdk_drawable_get_size(pixmap, &M_BMPDATA->m_width, &M_BMPDATA->m_height);
773 M_BMPDATA->m_bpp = gdk_drawable_get_depth(pixmap);
774 PurgeOtherRepresentations(Pixmap);
775}
776
777GdkPixmap *wxBitmap::GetPixmap() const
778{
779 wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
780
781 // create the pixmap on the fly if we use Pixbuf representation:
782 if (M_BMPDATA->m_pixmap == NULL)
783 {
784 GdkPixmap** pmask = NULL;
785 if (gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf))
786 {
787 // make new mask from alpha
788 delete M_BMPDATA->m_mask;
789 M_BMPDATA->m_mask = new wxMask;
790 pmask = &M_BMPDATA->m_mask->m_bitmap;
791 }
792 gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
793 &M_BMPDATA->m_pixmap,
794 pmask,
795 0x80 /* alpha threshold */);
796 }
797
798 return M_BMPDATA->m_pixmap;
799}
800
801bool wxBitmap::HasPixmap() const
802{
803 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
804
805 return M_BMPDATA->m_pixmap != NULL;
806}
807
808GdkPixbuf *wxBitmap::GetPixbuf() const
809{
810 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
811
812 if (M_BMPDATA->m_pixbuf == NULL)
813 {
814 int width = GetWidth();
815 int height = GetHeight();
816
817 GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
818 GetMask() != NULL,
819 8, width, height);
820 M_BMPDATA->m_pixbuf = pixbuf;
821 gdk_pixbuf_get_from_drawable(pixbuf, M_BMPDATA->m_pixmap, NULL,
822 0, 0, 0, 0, width, height);
823
824 // apply the mask to created pixbuf:
825 if (M_BMPDATA->m_pixbuf && M_BMPDATA->m_mask)
826 {
827 GdkPixbuf *pmask =
828 gdk_pixbuf_get_from_drawable(NULL,
829 M_BMPDATA->m_mask->GetBitmap(),
830 NULL,
831 0, 0, 0, 0, width, height);
832 if (pmask)
833 {
834 guchar *bmp = gdk_pixbuf_get_pixels(pixbuf);
835 guchar *mask = gdk_pixbuf_get_pixels(pmask);
836 int bmprowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
837 int maskrowinc = gdk_pixbuf_get_rowstride(pmask) - 3 * width;
838
839 for (int y = 0; y < height;
840 y++, bmp += bmprowinc, mask += maskrowinc)
841 {
842 for (int x = 0; x < width; x++, bmp += 4, mask += 3)
843 {
844 if (mask[0] == 0 /*black pixel*/)
845 bmp[3] = 0;
846 }
847 }
848
849 g_object_unref (pmask);
850 }
851 }
852 }
853
854 return M_BMPDATA->m_pixbuf;
855}
856
857bool wxBitmap::HasPixbuf() const
858{
859 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
860
861 return M_BMPDATA->m_pixbuf != NULL;
862}
863
864void wxBitmap::SetPixbuf(GdkPixbuf* pixbuf, int depth)
865{
866 if (!m_refData)
867 m_refData = new wxBitmapRefData;
868
869 // AllocExclusive should not be needed for this internal function
870 wxASSERT(m_refData->GetRefCount() == 1);
871 wxASSERT(M_BMPDATA->m_pixbuf == NULL);
872 M_BMPDATA->m_pixbuf = pixbuf;
873 M_BMPDATA->m_width = gdk_pixbuf_get_width(pixbuf);
874 M_BMPDATA->m_height = gdk_pixbuf_get_height(pixbuf);
875 // if depth specified
876 if (depth != 0)
877 M_BMPDATA->m_bpp = depth;
878 else if (M_BMPDATA->m_bpp == 0)
879 // use something reasonable
880 M_BMPDATA->m_bpp = wxTheApp->GetGdkVisual()->depth;
881 PurgeOtherRepresentations(Pixbuf);
882}
883
884void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
885{
886 if (keep == Pixmap && HasPixbuf())
887 {
888 g_object_unref (M_BMPDATA->m_pixbuf);
889 M_BMPDATA->m_pixbuf = NULL;
890 }
891 if (keep == Pixbuf && HasPixmap())
892 {
893 g_object_unref (M_BMPDATA->m_pixmap);
894 M_BMPDATA->m_pixmap = NULL;
895 }
896}
897
898void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
899{
900 void* bits = NULL;
901 GdkPixbuf *pixbuf = GetPixbuf();
902 const bool hasAlpha = HasAlpha();
903 // allow access if bpp is valid and matches existence of alpha
904 if (pixbuf != NULL && (
905 bpp == 24 && !hasAlpha ||
906 bpp == 32 && hasAlpha))
907 {
908 data.m_height = gdk_pixbuf_get_height( pixbuf );
909 data.m_width = gdk_pixbuf_get_width( pixbuf );
910 data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
911 bits = gdk_pixbuf_get_pixels(pixbuf);
912 }
913 return bits;
914}
915
916void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
917{
918}
919
920bool wxBitmap::HasAlpha() const
921{
922 return m_refData != NULL && M_BMPDATA->m_pixbuf != NULL &&
923 gdk_pixbuf_get_has_alpha(M_BMPDATA->m_pixbuf);
924}
925
926wxGDIRefData* wxBitmap::CreateGDIRefData() const
927{
928 return new wxBitmapRefData;
929}
930
931wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
932{
933 const wxBitmapRefData* oldRef = wx_static_cast(const wxBitmapRefData*, data);
934 wxBitmapRefData* newRef = new wxBitmapRefData;
935 newRef->m_width = oldRef->m_width;
936 newRef->m_height = oldRef->m_height;
937 newRef->m_bpp = oldRef->m_bpp;
938 if (oldRef->m_pixmap != NULL)
939 {
940 newRef->m_pixmap = gdk_pixmap_new(
941 oldRef->m_pixmap, oldRef->m_width, oldRef->m_height,
942 // use pixmap depth, m_bpp may not match
943 gdk_drawable_get_depth(oldRef->m_pixmap));
944 GdkGC* gc = gdk_gc_new(newRef->m_pixmap);
945 gdk_draw_drawable(
946 newRef->m_pixmap, gc, oldRef->m_pixmap, 0, 0, 0, 0, -1, -1);
947 g_object_unref(gc);
948 }
949 if (oldRef->m_pixbuf != NULL)
950 {
951 newRef->m_pixbuf = gdk_pixbuf_copy(oldRef->m_pixbuf);
952 }
953 if (oldRef->m_mask != NULL)
954 {
955 newRef->m_mask = new wxMask;
956 newRef->m_mask->m_bitmap = gdk_pixmap_new(
957 oldRef->m_mask->m_bitmap, oldRef->m_width, oldRef->m_height, 1);
958 GdkGC* gc = gdk_gc_new(newRef->m_mask->m_bitmap);
959 gdk_draw_drawable(newRef->m_mask->m_bitmap,
960 gc, oldRef->m_mask->m_bitmap, 0, 0, 0, 0, -1, -1);
961 g_object_unref(gc);
962 }
963#if wxUSE_PALETTE
964 // implement this if SetPalette is ever implemented
965 wxASSERT(oldRef->m_palette == NULL);
966#endif
967
968 return newRef;
969}
970
971/* static */ void wxBitmap::InitStandardHandlers()
972{
973 // TODO: Insert handler based on GdkPixbufs handler later
974}