]>
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/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 | ||
32 | extern GtkWidget *wxGetRootWindow(); | |
33 | ||
34 | //----------------------------------------------------------------------------- | |
35 | // wxMask | |
36 | //----------------------------------------------------------------------------- | |
37 | ||
38 | IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject) | |
39 | ||
40 | wxMask::wxMask() | |
41 | { | |
42 | m_bitmap = (GdkBitmap *) NULL; | |
43 | } | |
44 | ||
45 | wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour ) | |
46 | { | |
47 | m_bitmap = (GdkBitmap *) NULL; | |
48 | Create( bitmap, colour ); | |
49 | } | |
50 | ||
51 | #if wxUSE_PALETTE | |
52 | wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex ) | |
53 | { | |
54 | m_bitmap = (GdkBitmap *) NULL; | |
55 | Create( bitmap, paletteIndex ); | |
56 | } | |
57 | #endif // wxUSE_PALETTE | |
58 | ||
59 | wxMask::wxMask( const wxBitmap& bitmap ) | |
60 | { | |
61 | m_bitmap = (GdkBitmap *) NULL; | |
62 | Create( bitmap ); | |
63 | } | |
64 | ||
65 | wxMask::~wxMask() | |
66 | { | |
67 | if (m_bitmap) | |
68 | g_object_unref (m_bitmap); | |
69 | } | |
70 | ||
71 | bool 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 | |
138 | bool 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 | ||
151 | bool 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 | ||
175 | GdkBitmap *wxMask::GetBitmap() const | |
176 | { | |
177 | return m_bitmap; | |
178 | } | |
179 | ||
180 | //----------------------------------------------------------------------------- | |
181 | // wxBitmap | |
182 | //----------------------------------------------------------------------------- | |
183 | ||
184 | class wxBitmapRefData: public wxGDIRefData | |
185 | { | |
186 | public: | |
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 | ||
203 | wxBitmapRefData::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 | ||
216 | wxBitmapRefData::~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 | ||
232 | IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject) | |
233 | ||
234 | wxBitmap::wxBitmap(int width, int height, int depth) | |
235 | { | |
236 | Create(width, height, depth); | |
237 | } | |
238 | ||
239 | wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type) | |
240 | { | |
241 | LoadFile(filename, type); | |
242 | } | |
243 | ||
244 | wxBitmap::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 | ||
255 | wxBitmap::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 | ||
269 | wxBitmap::~wxBitmap() | |
270 | { | |
271 | } | |
272 | ||
273 | bool 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 | ||
303 | wxBitmap 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 | ||
370 | bool 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 | ||
388 | bool 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 | ||
466 | bool 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 | ||
499 | wxImage 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 | ||
602 | int wxBitmap::GetHeight() const | |
603 | { | |
604 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
605 | ||
606 | return M_BMPDATA->m_height; | |
607 | } | |
608 | ||
609 | int wxBitmap::GetWidth() const | |
610 | { | |
611 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
612 | ||
613 | return M_BMPDATA->m_width; | |
614 | } | |
615 | ||
616 | int wxBitmap::GetDepth() const | |
617 | { | |
618 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
619 | ||
620 | return M_BMPDATA->m_bpp; | |
621 | } | |
622 | ||
623 | wxMask *wxBitmap::GetMask() const | |
624 | { | |
625 | wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") ); | |
626 | ||
627 | return M_BMPDATA->m_mask; | |
628 | } | |
629 | ||
630 | void 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 | ||
639 | bool wxBitmap::CopyFromIcon(const wxIcon& icon) | |
640 | { | |
641 | *this = icon; | |
642 | return Ok(); | |
643 | } | |
644 | ||
645 | wxBitmap 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 | ||
688 | bool 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 | ||
704 | bool 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 | |
732 | wxPalette *wxBitmap::GetPalette() const | |
733 | { | |
734 | wxCHECK_MSG(Ok(), NULL, wxT("invalid bitmap")); | |
735 | ||
736 | return M_BMPDATA->m_palette; | |
737 | } | |
738 | ||
739 | void wxBitmap::SetPalette(const wxPalette& WXUNUSED(palette)) | |
740 | { | |
741 | // TODO | |
742 | } | |
743 | #endif // wxUSE_PALETTE | |
744 | ||
745 | void wxBitmap::SetHeight( int height ) | |
746 | { | |
747 | AllocExclusive(); | |
748 | M_BMPDATA->m_height = height; | |
749 | } | |
750 | ||
751 | void wxBitmap::SetWidth( int width ) | |
752 | { | |
753 | AllocExclusive(); | |
754 | M_BMPDATA->m_width = width; | |
755 | } | |
756 | ||
757 | void wxBitmap::SetDepth( int depth ) | |
758 | { | |
759 | AllocExclusive(); | |
760 | M_BMPDATA->m_bpp = depth; | |
761 | } | |
762 | ||
763 | void 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 | ||
777 | GdkPixmap *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 | ||
801 | bool wxBitmap::HasPixmap() const | |
802 | { | |
803 | wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") ); | |
804 | ||
805 | return M_BMPDATA->m_pixmap != NULL; | |
806 | } | |
807 | ||
808 | GdkPixbuf *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 | ||
857 | bool wxBitmap::HasPixbuf() const | |
858 | { | |
859 | wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") ); | |
860 | ||
861 | return M_BMPDATA->m_pixbuf != NULL; | |
862 | } | |
863 | ||
864 | void 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 | ||
884 | void 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 | ||
898 | void *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 | ||
916 | void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data)) | |
917 | { | |
918 | } | |
919 | ||
920 | bool 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 | ||
926 | wxGDIRefData* wxBitmap::CreateGDIRefData() const | |
927 | { | |
928 | return new wxBitmapRefData; | |
929 | } | |
930 | ||
931 | wxGDIRefData* 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 | } |