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