]> git.saurik.com Git - wxWidgets.git/blob - src/common/image.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxObjArrays code compiles again
[wxWidgets.git] / src / common / image.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: image.cpp
3 // Purpose: wxImage
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "image.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #include "wx/image.h"
22 #include "wx/bitmap.h"
23 #include "wx/debug.h"
24 #include "wx/log.h"
25 #ifdef wxUSE_LIBPNG
26 #include "../png/png.h"
27 #endif
28 #include "wx/filefn.h"
29
30 #ifdef __WXMSW__
31 #include <windows.h>
32 #endif
33
34 //-----------------------------------------------------------------------------
35 // wxImage
36 //-----------------------------------------------------------------------------
37
38 class wxImageRefData: public wxObjectRefData
39 {
40
41 public:
42 wxImageRefData(void);
43 ~wxImageRefData(void);
44
45 int m_width;
46 int m_height;
47 unsigned char *m_data;
48 bool m_hasMask;
49 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
50 bool m_ok;
51 };
52
53 wxImageRefData::wxImageRefData(void)
54 {
55 m_width = 0;
56 m_height = 0;
57 m_data = (unsigned char*) NULL;
58 m_ok = FALSE;
59 m_maskRed = 0;
60 m_maskGreen = 0;
61 m_maskBlue = 0;
62 m_hasMask = FALSE;
63 }
64
65 wxImageRefData::~wxImageRefData(void)
66 {
67 if (m_data) free( m_data );
68 }
69
70 wxList wxImage::sm_handlers;
71
72 //-----------------------------------------------------------------------------
73
74 #define M_IMGDATA ((wxImageRefData *)m_refData)
75
76 #if !USE_SHARED_LIBRARIES
77 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
78 #endif
79
80 wxImage::wxImage()
81 {
82 }
83
84 wxImage::wxImage( int width, int height )
85 {
86 Create( width, height );
87 }
88
89 wxImage::wxImage( const wxString& name, long type )
90 {
91 LoadFile( name, type );
92 }
93
94 wxImage::wxImage( const wxImage& image )
95 {
96 Ref(image);
97 }
98
99 wxImage::wxImage( const wxImage* image )
100 {
101 if (image) Ref(*image);
102 }
103
104 void wxImage::Create( int width, int height )
105 {
106 m_refData = new wxImageRefData();
107
108 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
109 if (M_IMGDATA->m_data)
110 {
111 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
112
113 M_IMGDATA->m_width = width;
114 M_IMGDATA->m_height = height;
115 M_IMGDATA->m_ok = TRUE;
116 }
117 else
118 {
119 UnRef();
120 }
121 }
122
123 void wxImage::Destroy()
124 {
125 UnRef();
126 }
127
128 wxImage wxImage::Scale( int width, int height )
129 {
130 wxImage image;
131
132 wxCHECK_MSG( Ok(), image, "invlaid image" );
133
134 wxCHECK_MSG( (width > 0) && (height > 0), image, "invalid image size" );
135
136 image.Create( width, height );
137
138 char unsigned *data = image.GetData();
139
140 wxCHECK_MSG( data, image, "unable to create image" );
141
142 if (M_IMGDATA->m_hasMask)
143 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
144
145 double xscale = (double)width / (double)M_IMGDATA->m_width;
146 double yscale = (double)height / (double)M_IMGDATA->m_height;
147
148 for (int j = 0; j < height; j++)
149 {
150 for (int i = 0; i < width; i++)
151 {
152 int new_pos = 3*(j*width + i);
153 int old_pos = 3*((long)(j/yscale)*M_IMGDATA->m_width + (long)(i/xscale));
154 data[ new_pos ] = M_IMGDATA->m_data[ old_pos ];
155 data[ new_pos+1 ] = M_IMGDATA->m_data[ old_pos+1 ];
156 data[ new_pos+2 ] = M_IMGDATA->m_data[ old_pos+2 ];
157 }
158 }
159
160 return image;
161 }
162
163 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
164 {
165 wxCHECK_RET( Ok(), "invalid image" );
166
167 int w = M_IMGDATA->m_width;
168 int h = M_IMGDATA->m_height;
169
170 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), "invalid image index" );
171
172 long pos = (y * w + x) * 3;
173
174 M_IMGDATA->m_data[ pos ] = r;
175 M_IMGDATA->m_data[ pos+1 ] = g;
176 M_IMGDATA->m_data[ pos+2 ] = b;
177 }
178
179 unsigned char wxImage::GetRed( int x, int y )
180 {
181 wxCHECK_MSG( Ok(), 0, "invalid image" );
182
183 int w = M_IMGDATA->m_width;
184 int h = M_IMGDATA->m_height;
185
186 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
187
188 long pos = (y * w + x) * 3;
189
190 return M_IMGDATA->m_data[pos];
191 }
192
193 unsigned char wxImage::GetGreen( int x, int y )
194 {
195 wxCHECK_MSG( Ok(), 0, "invalid image" );
196
197 int w = M_IMGDATA->m_width;
198 int h = M_IMGDATA->m_height;
199
200 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
201
202 long pos = (y * w + x) * 3;
203
204 return M_IMGDATA->m_data[pos+1];
205 }
206
207 unsigned char wxImage::GetBlue( int x, int y )
208 {
209 wxCHECK_MSG( Ok(), 0, "invalid image" );
210
211 int w = M_IMGDATA->m_width;
212 int h = M_IMGDATA->m_height;
213
214 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
215
216 long pos = (y * w + x) * 3;
217
218 return M_IMGDATA->m_data[pos+2];
219 }
220
221 bool wxImage::Ok() const
222 {
223 return (M_IMGDATA && M_IMGDATA->m_ok);
224 }
225
226 char unsigned *wxImage::GetData() const
227 {
228 wxCHECK_MSG( Ok(), (char unsigned *)NULL, "invalid image" );
229
230 return M_IMGDATA->m_data;
231 }
232
233 void wxImage::SetData( char unsigned *WXUNUSED(data) )
234 {
235 wxCHECK_RET( Ok(), "invalid image" );
236 }
237
238 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
239 {
240 wxCHECK_RET( Ok(), "invalid image" );
241
242 M_IMGDATA->m_maskRed = r;
243 M_IMGDATA->m_maskGreen = g;
244 M_IMGDATA->m_maskBlue = b;
245 M_IMGDATA->m_hasMask = TRUE;
246 }
247
248 unsigned char wxImage::GetMaskRed() const
249 {
250 wxCHECK_MSG( Ok(), 0, "invalid image" );
251
252 return M_IMGDATA->m_maskRed;
253 }
254
255 unsigned char wxImage::GetMaskGreen() const
256 {
257 wxCHECK_MSG( Ok(), 0, "invalid image" );
258
259 return M_IMGDATA->m_maskGreen;
260 }
261
262 unsigned char wxImage::GetMaskBlue() const
263 {
264 wxCHECK_MSG( Ok(), 0, "invalid image" );
265
266 return M_IMGDATA->m_maskBlue;
267 }
268
269 void wxImage::SetMask( bool mask )
270 {
271 wxCHECK_RET( Ok(), "invalid image" );
272
273 M_IMGDATA->m_hasMask = mask;
274 }
275
276 bool wxImage::HasMask() const
277 {
278 wxCHECK_MSG( Ok(), FALSE, "invalid image" );
279
280 return M_IMGDATA->m_hasMask;
281 }
282
283 int wxImage::GetWidth() const
284 {
285 wxCHECK_MSG( Ok(), 0, "invalid image" );
286
287 return M_IMGDATA->m_width;
288 }
289
290 int wxImage::GetHeight() const
291 {
292 wxCHECK_MSG( Ok(), 0, "invalid image" );
293
294 return M_IMGDATA->m_height;
295 }
296
297 bool wxImage::LoadFile( const wxString& filename, long type )
298 {
299 UnRef();
300
301 if (!wxFileExists(filename))
302 {
303 wxLogWarning( "Image file does not exist." );
304
305 return FALSE;
306 }
307
308 m_refData = new wxImageRefData;
309
310 wxImageHandler *handler = FindHandler(type);
311
312 if (handler == NULL)
313 {
314 wxLogWarning( "No image handler for type %d defined.", type );
315
316 return FALSE;
317 }
318
319 return handler->LoadFile( this, filename );
320 }
321
322 bool wxImage::SaveFile( const wxString& filename, int type )
323 {
324 wxCHECK_MSG( Ok(), FALSE, "invalid image" );
325
326 wxImageHandler *handler = FindHandler(type);
327
328 if (handler == NULL)
329 {
330 wxLogWarning( "No image handler for type %d defined.", type );
331
332 return FALSE;
333 }
334
335 return handler->SaveFile( this, filename );
336 }
337
338 void wxImage::AddHandler( wxImageHandler *handler )
339 {
340 sm_handlers.Append( handler );
341 }
342
343 void wxImage::InsertHandler( wxImageHandler *handler )
344 {
345 sm_handlers.Insert( handler );
346 }
347
348 bool wxImage::RemoveHandler( const wxString& name )
349 {
350 wxImageHandler *handler = FindHandler(name);
351 if (handler)
352 {
353 sm_handlers.DeleteObject(handler);
354 return TRUE;
355 }
356 else
357 return FALSE;
358 }
359
360 wxImageHandler *wxImage::FindHandler( const wxString& name )
361 {
362 wxNode *node = sm_handlers.First();
363 while (node)
364 {
365 wxImageHandler *handler = (wxImageHandler*)node->Data();
366 if (handler->GetName() == name) return handler;
367 node = node->Next();
368 }
369 return (wxImageHandler *)NULL;
370 }
371
372 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
373 {
374 wxNode *node = sm_handlers.First();
375 while (node)
376 {
377 wxImageHandler *handler = (wxImageHandler*)node->Data();
378 if ( handler->GetExtension() == extension &&
379 (bitmapType == -1 || handler->GetType() == bitmapType) )
380 return handler;
381 node = node->Next();
382 }
383 return (wxImageHandler*)NULL;
384 }
385
386 wxImageHandler *wxImage::FindHandler( long bitmapType )
387 {
388 wxNode *node = sm_handlers.First();
389 while (node)
390 {
391 wxImageHandler *handler = (wxImageHandler *)node->Data();
392 if (handler->GetType() == bitmapType) return handler;
393 node = node->Next();
394 }
395 return NULL;
396 }
397
398 void wxImage::InitStandardHandlers()
399 {
400 AddHandler( new wxBMPHandler );
401 #ifdef wxUSE_LIBPNG
402 AddHandler( new wxPNGHandler );
403 #endif
404 }
405
406 void wxImage::CleanUpHandlers()
407 {
408 wxNode *node = sm_handlers.First();
409 while (node)
410 {
411 wxImageHandler *handler = (wxImageHandler *)node->Data();
412 wxNode *next = node->Next();
413 delete handler;
414 delete node;
415 node = next;
416 }
417 }
418
419 //-----------------------------------------------------------------------------
420 // wxImageHandler
421 //-----------------------------------------------------------------------------
422
423 #if !USE_SHARED_LIBRARIES
424 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
425 #endif
426
427 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), const wxString& WXUNUSED(name) )
428 {
429 return FALSE;
430 }
431
432 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), const wxString& WXUNUSED(name) )
433 {
434 return FALSE;
435 }
436
437 //-----------------------------------------------------------------------------
438 // wxPNGHandler
439 //-----------------------------------------------------------------------------
440
441 #ifdef wxUSE_LIBPNG
442
443 #if !USE_SHARED_LIBRARIES
444 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
445 #endif
446
447 bool wxPNGHandler::LoadFile( wxImage *image, const wxString& name )
448 {
449 image->Destroy();
450
451 png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
452 (voidp) NULL, (png_error_ptr) NULL, (png_error_ptr) NULL );
453 if (!png_ptr) return FALSE;
454
455 png_infop info_ptr = png_create_info_struct( png_ptr );
456 if (!info_ptr)
457 {
458 png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
459 return FALSE;
460 }
461
462 if (setjmp(png_ptr->jmpbuf))
463 {
464 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
465 return FALSE;
466 }
467
468 if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
469 {
470 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
471 return FALSE;
472 }
473
474 FILE *f = fopen( name, "rb" );
475 png_init_io( png_ptr, f );
476
477 png_uint_32 width,height;
478 int bit_depth,color_type,interlace_type;
479
480 png_read_info( png_ptr, info_ptr );
481 png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
482
483 if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_expand( png_ptr );
484
485 png_set_strip_16( png_ptr );
486 png_set_packing( png_ptr );
487 if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_expand( png_ptr );
488 png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
489
490 image->Create( width, height );
491
492 if (!image->Ok())
493 {
494 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
495 return FALSE;
496 }
497
498 unsigned char **lines = (unsigned char **)malloc( height * sizeof(unsigned char *) );
499 if (lines == NULL)
500 {
501 image->Destroy();
502 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
503 return FALSE;
504 }
505
506 for (unsigned int i = 0; i < height; i++)
507 {
508 if ((lines[i] = (unsigned char *)malloc(width * (sizeof(unsigned char) * 4))) == NULL)
509 {
510 image->Destroy();
511 for (unsigned int n = 0; n < i; n++) free( lines[n] );
512 free( lines );
513 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
514 return FALSE;
515 }
516 }
517
518
519 int transp = 0;
520 png_read_image( png_ptr, lines );
521 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
522 unsigned char *ptr = image->GetData();
523 if ((color_type == PNG_COLOR_TYPE_GRAY) ||
524 (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
525 {
526 for (unsigned int y = 0; y < height; y++)
527 {
528 unsigned char *ptr2 = lines[y];
529 for (unsigned int x = 0; x < width; x++)
530 {
531 unsigned char r = *ptr2++;
532 unsigned char a = *ptr2++;
533 if (a < 128)
534 {
535 *ptr++ = 255;
536 *ptr++ = 0;
537 *ptr++ = 255;
538 transp = 1;
539 }
540 else
541 {
542 *ptr++ = r;
543 *ptr++ = r;
544 *ptr++ = r;
545 }
546 }
547 }
548 }
549 else
550 {
551 for (unsigned int y = 0; y < height; y++)
552 {
553 unsigned char *ptr2 = lines[y];
554 for (unsigned int x = 0; x < width; x++)
555 {
556 unsigned char r = *ptr2++;
557 unsigned char g = *ptr2++;
558 unsigned char b = *ptr2++;
559 unsigned char a = *ptr2++;
560 if (a < 128)
561 {
562 *ptr++ = 255;
563 *ptr++ = 0;
564 *ptr++ = 255;
565 transp = 1;
566 }
567 else
568 {
569 if ((r == 255) && (g == 0) && (b == 255)) r = 254;
570 *ptr++ = r;
571 *ptr++ = g;
572 *ptr++ = b;
573 }
574 }
575 }
576 }
577
578 for (unsigned int j = 0; j < height; j++) free( lines[j] );
579 free( lines );
580
581 if (transp)
582 {
583 image->SetMaskColour( 255, 0, 255 );
584 }
585 else
586 {
587 image->SetMask( FALSE );
588 }
589
590 return TRUE;
591 }
592
593
594 bool wxPNGHandler::SaveFile( wxImage *image, const wxString& name )
595 {
596 FILE *f = fopen( name, "wb" );
597 if (!f) return FALSE;
598
599 png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING,
600 (voidp) NULL, (png_error_ptr) NULL, (png_error_ptr) NULL);
601 if (!png_ptr)
602 {
603 fclose( f );
604 return FALSE;
605 }
606
607 png_infop info_ptr = png_create_info_struct(png_ptr);
608 if (info_ptr == NULL)
609 {
610 fclose(f);
611 png_destroy_write_struct( &png_ptr, (png_infopp) NULL );
612 return FALSE;
613 }
614
615 if (setjmp(png_ptr->jmpbuf))
616 {
617 fclose( f );
618 png_destroy_write_struct( &png_ptr, (png_infopp) NULL );
619 return FALSE;
620 }
621
622 png_init_io( png_ptr, f );
623 png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
624 PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
625 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
626
627 png_color_8 sig_bit;
628 sig_bit.red = 8;
629 sig_bit.green = 8;
630 sig_bit.blue = 8;
631 sig_bit.alpha = 8;
632 png_set_sBIT( png_ptr, info_ptr, &sig_bit );
633 png_write_info( png_ptr, info_ptr );
634 png_set_shift( png_ptr, &sig_bit );
635 png_set_packing( png_ptr );
636
637 unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
638 if (!data)
639 {
640 fclose( f );
641 png_destroy_write_struct( &png_ptr, (png_infopp) NULL );
642 return FALSE;
643 }
644
645 for (int y = 0; y < image->GetHeight(); y++)
646 {
647 unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
648 for (int x = 0; x < image->GetWidth(); x++)
649 {
650 data[(x << 2) + 0] = *ptr++;
651 data[(x << 2) + 1] = *ptr++;
652 data[(x << 2) + 2] = *ptr++;
653 if ((data[(x << 2) + 0] == image->GetMaskRed()) &&
654 (data[(x << 2) + 1] == image->GetMaskGreen()) &&
655 (data[(x << 2) + 2] == image->GetMaskBlue()))
656 {
657 data[(x << 2) + 3] = 0;
658 }
659 else
660 {
661 data[(x << 2) + 3] = 255;
662 }
663 }
664 png_bytep row_ptr = data;
665 png_write_rows( png_ptr, &row_ptr, 1 );
666 }
667
668 free(data);
669 png_write_end( png_ptr, info_ptr );
670 png_destroy_write_struct( &png_ptr, (png_infopp) NULL );
671
672 fclose(f);
673
674 return TRUE;
675 }
676
677 #endif
678
679 // wxUSE_LIBPNG
680
681 //-----------------------------------------------------------------------------
682 // wxBMPHandler
683 //-----------------------------------------------------------------------------
684
685 #if !USE_SHARED_LIBRARIES
686 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
687 #endif
688
689 bool wxBMPHandler::LoadFile( wxImage *image, const wxString& name )
690 {
691 FILE *file;
692 unsigned char *data, *ptr;
693 int done, i, bpp, planes, comp, ncolors, line, column,
694 linesize, linepos, rshift = 0, gshift = 0, bshift = 0;
695 unsigned char aByte;
696 short int word;
697 long int dbuf[4], dword, rmask = 0, gmask = 0, bmask = 0, offset,
698 size;
699 signed char bbuf[4];
700 struct _cmap
701 {
702 unsigned char r, g, b;
703 }
704 *cmap = NULL;
705 #ifndef BI_RGB
706 #define BI_RGB 0
707 #define BI_RLE8 1
708 #define BI_RLE4 2
709 #endif
710
711 #ifndef BI_BITFIELDS
712 #define BI_BITFIELDS 3
713 #endif
714
715 image->Destroy();
716
717 file = fopen(name, "r");
718 if (!file)
719 return NULL;
720
721 done = 0;
722 /*
723 * Reading the bmp header
724 */
725
726 fread(&bbuf, 1, 2, file);
727
728 fread(dbuf, 4, 4, file);
729
730 size = dbuf[0];
731 offset = dbuf[2];
732
733 fread(dbuf, 4, 2, file);
734 int width = (int)dbuf[0];
735 int height = (int)dbuf[1];
736 if (width > 32767)
737 {
738 wxLogError( "Image width > 32767 pixels for file\n" );
739 fclose(file);
740 return FALSE;
741 }
742 if (height > 32767)
743 {
744 wxLogError( "Image height > 32767 pixels for file\n" );
745 fclose(file);
746 return FALSE;
747 }
748 fread(&word, 2, 1, file);
749 planes = (int)word;
750 fread(&word, 2, 1, file);
751 bpp = (int)word;
752 if (bpp != 1 && bpp != 4 && bpp != 8 && bpp && 16 && bpp != 24 && bpp != 32)
753 {
754 wxLogError( "unknown bitdepth in file\n" );
755 fclose(file);
756 return FALSE;
757 }
758 fread(dbuf, 4, 4, file);
759 comp = (int)dbuf[0];
760 if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
761 {
762 wxLogError( "unknown encoding in Windows BMP file\n" );
763 fclose(file);
764 return FALSE;
765 }
766 fread(dbuf, 4, 2, file);
767 ncolors = (int)dbuf[0];
768 if (ncolors == 0)
769 ncolors = 1 << bpp;
770 /* some more sanity checks */
771 if (((comp == BI_RLE4) && (bpp != 4)) || ((comp == BI_RLE8) && (bpp != 8)) || ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
772 {
773 wxLogError( "encoding of BMP doesn't match bitdepth\n" );
774 fclose(file);
775 return FALSE;
776 }
777 if (bpp < 16)
778 {
779 cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
780
781 if (!cmap)
782 {
783 wxLogError( "Cannot allocate RAM for color map in BMP file\n" );
784 fclose(file);
785 return FALSE;
786 }
787 }
788 else
789 cmap = NULL;
790
791 image->Create( width, height );
792 ptr = image->GetData();
793 if (!ptr)
794 {
795 wxLogError( "Cannot allocate RAM for RGB data in file\n" );
796 fclose(file);
797 if (cmap)
798 free(cmap);
799 return FALSE;
800 }
801
802 /*
803 * Reading the palette, if it exists.
804 */
805 if (bpp < 16 && ncolors != 0)
806 {
807 for (i = 0; i < ncolors; i++)
808 {
809 fread(bbuf, 1, 4, file);
810 cmap[i].b = bbuf[0];
811 cmap[i].g = bbuf[1];
812 cmap[i].r = bbuf[2];
813 }
814 }
815 else if (bpp == 16 || bpp == 32)
816 {
817 if (comp == BI_BITFIELDS)
818 {
819 int bit = 0;
820
821 fread(dbuf, 4, 3, file);
822 bmask = dbuf[0];
823 gmask = dbuf[1];
824 rmask = dbuf[2];
825 /* find shift amount.. ugly, but i can't think of a better way */
826 for (bit = 0; bit < bpp; bit++)
827 {
828 if (bmask & (1 << bit))
829 bshift = bit;
830 if (gmask & (1 << bit))
831 gshift = bit;
832 if (rmask & (1 << bit))
833 rshift = bit;
834 }
835 }
836 else if (bpp == 16)
837 {
838 rmask = 0x7C00;
839 gmask = 0x03E0;
840 bmask = 0x001F;
841 rshift = 10;
842 gshift = 5;
843 bshift = 0;
844 }
845 else if (bpp == 32)
846 {
847 rmask = 0x00FF0000;
848 gmask = 0x0000FF00;
849 bmask = 0x000000FF;
850 rshift = 16;
851 gshift = 8;
852 bshift = 0;
853 }
854 }
855
856 /*
857 * Reading the image data
858 */
859 fseek(file, offset, SEEK_SET);
860 data = ptr;
861
862 /* set the whole image to the background color */
863 if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8))
864 {
865 for (i = 0; i < width * height; i++)
866 {
867 *ptr++ = cmap[0].r;
868 *ptr++ = cmap[0].g;
869 *ptr++ = cmap[0].b;
870 }
871 ptr = data;
872 }
873 line = 0;
874 column = 0;
875 #define poffset (line * width * 3 + column * 3)
876
877 /*
878 * BMPs are stored upside down... hmmmmmmmmmm....
879 */
880
881 linesize = ((width * bpp + 31) / 32) * 4;
882 for (line = (height - 1); line >= 0; line--)
883 {
884 linepos = 0;
885 for (column = 0; column < width;)
886 {
887 if (bpp < 16)
888 {
889 int index;
890
891 linepos++;
892 aByte = getc(file);
893 if (bpp == 1)
894 {
895 int bit = 0;
896
897 for (bit = 0; bit < 8; bit++)
898 {
899 index = ((aByte & (0x80 >> bit)) ? 1 : 0);
900 ptr[poffset] = cmap[index].r;
901 ptr[poffset + 1] = cmap[index].g;
902 ptr[poffset + 2] = cmap[index].b;
903 column++;
904 }
905 }
906 else if (bpp == 4)
907 {
908 if (comp == BI_RLE4)
909 {
910 wxLogError( "can't deal with 4bit encoded yet.\n");
911 image->Destroy();
912 free(cmap);
913 return FALSE;
914 }
915 else
916 {
917 int nibble = 0;
918
919 for (nibble = 0; nibble < 2; nibble++)
920 {
921 index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
922 if (index >= 16)
923 index = 15;
924 ptr[poffset] = cmap[index].r;
925 ptr[poffset + 1] = cmap[index].g;
926 ptr[poffset + 2] = cmap[index].b;
927 column++;
928 }
929 }
930 }
931 else if (bpp == 8)
932 {
933 if (comp == BI_RLE8)
934 {
935 unsigned char first;
936
937 first = aByte;
938 aByte = getc(file);
939 if (first == 0)
940 {
941 if (aByte == 0)
942 {
943 /* column = width; */
944 }
945 else if (aByte == 1)
946 {
947 column = width;
948 line = -1;
949 }
950 else if (aByte == 2)
951 {
952 aByte = getc(file);
953 column += aByte;
954 linepos = column * bpp / 8;
955 aByte = getc(file);
956 line += aByte;
957 }
958 else
959 {
960 int absolute = aByte;
961
962 for (i = 0; i < absolute; i++)
963 {
964 linepos++;
965 aByte = getc(file);
966 ptr[poffset] = cmap[aByte].r;
967 ptr[poffset + 1] = cmap[aByte].g;
968 ptr[poffset + 2] = cmap[aByte].b;
969 column++;
970 }
971 if (absolute & 0x01)
972 aByte = getc(file);
973 }
974 }
975 else
976 {
977 for (i = 0; i < first; i++)
978 {
979 ptr[poffset] = cmap[aByte].r;
980 ptr[poffset + 1] = cmap[aByte].g;
981 ptr[poffset + 2] = cmap[aByte].b;
982 column++;
983 linepos++;
984 }
985 }
986 }
987 else
988 {
989 ptr[poffset] = cmap[aByte].r;
990 ptr[poffset + 1] = cmap[aByte].g;
991 ptr[poffset + 2] = cmap[aByte].b;
992 column++;
993 linepos += size;
994 }
995 }
996 }
997 else if (bpp == 24)
998 {
999 linepos += fread(&bbuf, 1, 3, file);
1000 ptr[poffset] = (unsigned char)bbuf[2];
1001 ptr[poffset + 1] = (unsigned char)bbuf[1];
1002 ptr[poffset + 2] = (unsigned char)bbuf[0];
1003 column++;
1004 }
1005 else if (bpp == 16)
1006 {
1007 unsigned char temp;
1008
1009 linepos += fread(&word, 2, 1, file);
1010 temp = (word & rmask) >> rshift;
1011 ptr[poffset] = temp;
1012 temp = (word & gmask) >> gshift;
1013 ptr[poffset + 1] = temp;
1014 temp = (word & bmask) >> gshift;
1015 ptr[poffset + 2] = temp;
1016 column++;
1017 }
1018 else
1019 {
1020 unsigned char temp;
1021
1022 linepos += fread(&dword, 4, 1, file);
1023 temp = (dword & rmask) >> rshift;
1024 ptr[poffset] = temp;
1025 temp = (dword & gmask) >> gshift;
1026 ptr[poffset + 1] = temp;
1027 temp = (dword & bmask) >> bshift;
1028 ptr[poffset + 2] = temp;
1029 column++;
1030 }
1031 }
1032 while ((linepos < linesize) && (comp != 1) && (comp != 2))
1033 {
1034 int temp = fread(&aByte, 1, 1, file);
1035
1036 linepos += temp;
1037 if (!temp)
1038 break;
1039 }
1040 }
1041 if (cmap) free(cmap);
1042
1043 image->SetMask( FALSE );
1044
1045 fclose(file);
1046 return TRUE;
1047 }
1048
1049 #ifdef __WXMSW__
1050
1051 wxBitmap wxImage::ConvertToBitmap() const
1052 {
1053
1054 wxBitmap bitmap;
1055 wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1056 int width = GetWidth();
1057 int height = GetHeight();
1058 bitmap.SetWidth( width );
1059 bitmap.SetHeight( height );
1060 bitmap.SetDepth( wxDisplayDepth() );
1061
1062 int headersize = sizeof(BITMAPINFOHEADER);
1063 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1064 wxCHECK_MSG( lpDIBh, bitmap, "could not allocate memory for DIB header" );
1065
1066 // Fill in the DIB header
1067 lpDIBh->bmiHeader.biSize = headersize;
1068 lpDIBh->bmiHeader.biWidth = width;
1069 lpDIBh->bmiHeader.biHeight = -height;
1070 lpDIBh->bmiHeader.biSizeImage = width * height * 3;
1071
1072 lpDIBh->bmiHeader.biPlanes = 1;
1073 lpDIBh->bmiHeader.biBitCount = 24;
1074 lpDIBh->bmiHeader.biCompression = BI_RGB;
1075 lpDIBh->bmiHeader.biClrUsed = 0;
1076
1077 // These seem not needed for our purpose here.
1078 // lpDIBh->bmiHeader.biClrImportant = 0;
1079 // lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1080 // lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1081
1082 unsigned char *lpBits = (unsigned char *) malloc( width*height*3 );
1083 if( !lpBits )
1084 {
1085 wxFAIL_MSG( "could not allocate memory for DIB" );
1086 free( lpDIBh );
1087 return bitmap;
1088 }
1089
1090 unsigned char *data = GetData();
1091
1092 unsigned char *ptdata = data, *ptbits = lpBits;
1093 for( int i=0; i<width*height; i++ )
1094 {
1095 *(ptbits++) = *(ptdata+2);
1096 *(ptbits++) = *(ptdata+1);
1097 *(ptbits++) = *(ptdata );
1098 ptdata += 3;
1099 }
1100
1101 HDC hdc = ::GetDC(NULL);
1102
1103 HBITMAP hbitmap;
1104 hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
1105
1106 // The above line is equivalent to the following two lines.
1107 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1108 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
1109 // or the following lines
1110 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1111 // HDC memdc = ::CreateCompatibleDC( hdc );
1112 // ::SelectObject( memdc, hbitmap);
1113 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
1114 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
1115 // ::SelectObject( memdc, 0 );
1116 // ::DeleteDC( memdc );
1117
1118 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
1119
1120 if( HasMask() )
1121 {
1122 unsigned char r = GetMaskRed();
1123 unsigned char g = GetMaskGreen();
1124 unsigned char b = GetMaskBlue();
1125 unsigned char zero = 0, one = 255;
1126 ptdata = data;
1127 ptbits = lpBits;
1128 for( int i=0; i<width*height; i++ )
1129 {
1130 if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
1131 {
1132 *(ptbits++) = one;
1133 *(ptbits++) = one;
1134 *(ptbits++) = one;
1135 }
1136 else
1137 {
1138 *(ptbits++) = zero;
1139 *(ptbits++) = zero;
1140 *(ptbits++) = zero;
1141 }
1142 }
1143 hbitmap = ::CreateBitmap( (WORD)width, (WORD)height, 1, 1, NULL );
1144 ::SetDIBits( hdc, hbitmap, 0, (WORD)height, lpBits, lpDIBh, DIB_RGB_COLORS);
1145 wxMask *mask = new wxMask();
1146 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
1147 bitmap.SetMask( mask );
1148
1149 /* The following can also be used but is slow to run
1150 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1151 wxMask *mask = new wxMask( bitmap, colour );
1152 bitmap.SetMask( mask );
1153 */
1154 }
1155
1156 ::ReleaseDC(NULL, hdc);
1157 free(lpDIBh);
1158 free(lpBits);
1159
1160 if( bitmap.GetHBITMAP() )
1161 bitmap.SetOk( TRUE );
1162 else
1163 bitmap.SetOk( FALSE );
1164
1165 return bitmap;
1166 }
1167
1168
1169 wxImage::wxImage( const wxBitmap &bitmap )
1170 {
1171 if( !bitmap.Ok() )
1172 {
1173 wxFAIL_MSG( "invalid bitmap" );
1174 return;
1175 }
1176
1177 int width = bitmap.GetWidth();
1178 int height = bitmap.GetHeight();
1179 Create( width, height );
1180 unsigned char *data = GetData();
1181 if( !data )
1182 {
1183 wxFAIL_MSG( "could not allocate data for image" );
1184 return;
1185 }
1186
1187 int headersize = sizeof(BITMAPINFOHEADER);
1188 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1189 if( !lpDIBh )
1190 {
1191 wxFAIL_MSG( "could not allocate data for DIB header" );
1192 free( data );
1193 return;
1194 }
1195
1196 // Fill in the DIB header
1197 lpDIBh->bmiHeader.biSize = headersize;
1198 lpDIBh->bmiHeader.biWidth = width;
1199 lpDIBh->bmiHeader.biHeight = -height;
1200 lpDIBh->bmiHeader.biSizeImage = width * height * 3;
1201
1202 lpDIBh->bmiHeader.biPlanes = 1;
1203 lpDIBh->bmiHeader.biBitCount = 24;
1204 lpDIBh->bmiHeader.biCompression = BI_RGB;
1205 lpDIBh->bmiHeader.biClrUsed = 0;
1206
1207 // These seem not needed for our purpose here.
1208 // lpDIBh->bmiHeader.biClrImportant = 0;
1209 // lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1210 // lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1211
1212 unsigned char *lpBits = (unsigned char *) malloc( width*height*3 );
1213 if( !lpBits )
1214 {
1215 wxFAIL_MSG( "could not allocate data for DIB" );
1216 free( data );
1217 free( lpDIBh );
1218 return;
1219 }
1220
1221 HBITMAP hbitmap;
1222 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1223 HDC hdc = ::GetDC(NULL);
1224 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1225
1226 unsigned char *ptdata = data, *ptbits = lpBits;
1227 for( int i=0; i<width*height; i++ )
1228 {
1229 *(ptdata++) = *(ptbits+2);
1230 *(ptdata++) = *(ptbits+1);
1231 *(ptdata++) = *(ptbits );
1232 ptbits += 3;
1233 }
1234
1235 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1236 {
1237 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1238 HDC memdc = ::CreateCompatibleDC( hdc );
1239 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1240 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1241 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1242 ::DeleteDC( memdc );
1243 unsigned char r=16, g=16, b=16; // background set to RGB(16,16,16)
1244 ptdata = data;
1245 ptbits = lpBits;
1246 for( int i=0; i<width*height; i++ )
1247 {
1248 if( *ptbits != 0 )
1249 {
1250 *(ptdata++) = r;
1251 *(ptdata++) = g;
1252 *(ptdata++) = b;
1253 }
1254 ptbits += 3;
1255 }
1256 SetMaskColour( r, g, b );
1257 }
1258
1259 ::ReleaseDC(NULL, hdc);
1260 free(lpDIBh);
1261 free(lpBits);
1262 }
1263
1264 #endif
1265
1266 #ifdef __WXGTK__
1267
1268 #include "gtk/gtk.h"
1269 #include "gdk/gdk.h"
1270 #include "gdk/gdkx.h"
1271
1272 wxBitmap wxImage::ConvertToBitmap() const
1273 {
1274 wxBitmap bitmap;
1275
1276 wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1277
1278 int width = GetWidth();
1279 int height = GetHeight();
1280
1281 bitmap.SetHeight( height );
1282 bitmap.SetWidth( width );
1283
1284 // Create picture
1285
1286 GdkImage *data_image =
1287 gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
1288
1289 bitmap.SetPixmap( gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 ) );
1290
1291 // Create mask
1292
1293 GdkImage *mask_image = (GdkImage*) NULL;
1294
1295 if (HasMask())
1296 {
1297 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1298
1299 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1300
1301 wxMask *mask = new wxMask();
1302 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1303
1304 bitmap.SetMask( mask );
1305 }
1306
1307 // Retrieve depth
1308
1309 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1310 if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1311 int bpp = visual->depth;
1312
1313 bitmap.SetDepth( bpp );
1314
1315 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1316 if (bpp < 8) bpp = 8;
1317
1318 // Render
1319
1320 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1321 byte_order b_o = RGB;
1322
1323 if (bpp >= 24)
1324 {
1325 GdkVisual *visual = gdk_visual_get_system();
1326 if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask)) b_o = RGB;
1327 else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask)) b_o = RGB;
1328 else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask)) b_o = BRG;
1329 else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1330 else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask)) b_o = GRB;
1331 else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask)) b_o = GBR;
1332 }
1333
1334 int r_mask = GetMaskRed();
1335 int g_mask = GetMaskGreen();
1336 int b_mask = GetMaskBlue();
1337
1338 unsigned char* data = GetData();
1339
1340 int index = 0;
1341 for (int y = 0; y < height; y++)
1342 {
1343 for (int x = 0; x < width; x++)
1344 {
1345 int r = data[index];
1346 index++;
1347 int g = data[index];
1348 index++;
1349 int b = data[index];
1350 index++;
1351
1352 if (HasMask())
1353 {
1354 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1355 gdk_image_put_pixel( mask_image, x, y, 1 );
1356 else
1357 gdk_image_put_pixel( mask_image, x, y, 0 );
1358 }
1359
1360 switch (bpp)
1361 {
1362 case 8:
1363 {
1364 GdkColormap *cmap = gtk_widget_get_default_colormap();
1365 GdkColor *colors = cmap->colors;
1366 int max = 3 * (65536);
1367 int index = -1;
1368
1369 for (int i = 0; i < cmap->size; i++)
1370 {
1371 int rdiff = (r << 8) - colors[i].red;
1372 int gdiff = (g << 8) - colors[i].green;
1373 int bdiff = (b << 8) - colors[i].blue;
1374 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1375 if (sum < max) { index = i; max = sum; }
1376 }
1377
1378 gdk_image_put_pixel( data_image, x, y, index );
1379
1380 break;
1381 }
1382 case 15:
1383 {
1384 guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1385 gdk_image_put_pixel( data_image, x, y, pixel );
1386 break;
1387 }
1388 case 16:
1389 {
1390 guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1391 gdk_image_put_pixel( data_image, x, y, pixel );
1392 break;
1393 }
1394 case 32:
1395 case 24:
1396 {
1397 guint32 pixel = 0;
1398 switch (b_o)
1399 {
1400 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1401 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1402 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1403 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1404 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1405 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1406 }
1407 gdk_image_put_pixel( data_image, x, y, pixel );
1408 }
1409 default: break;
1410 }
1411 } // for
1412 } // for
1413
1414 // Blit picture
1415
1416 GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1417
1418 gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1419
1420 gdk_image_destroy( data_image );
1421 gdk_gc_unref( data_gc );
1422
1423 // Blit mask
1424
1425 if (HasMask())
1426 {
1427 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1428
1429 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1430
1431 gdk_image_destroy( mask_image );
1432 gdk_gc_unref( mask_gc );
1433 }
1434
1435 return bitmap;
1436 }
1437
1438 wxImage::wxImage( const wxBitmap &bitmap )
1439 {
1440 wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
1441
1442 GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
1443 0, 0,
1444 bitmap.GetWidth(), bitmap.GetHeight() );
1445
1446 wxCHECK_RET( gdk_image, "couldn't create image" );
1447
1448 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1449 char unsigned *data = GetData();
1450
1451 if (!data)
1452 {
1453 gdk_image_destroy( gdk_image );
1454 wxFAIL_MSG( "couldn't create image" );
1455 return;
1456 }
1457
1458 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1459 if (bitmap.GetMask())
1460 {
1461 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1462 0, 0,
1463 bitmap.GetWidth(), bitmap.GetHeight() );
1464
1465 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1466 }
1467
1468 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1469 if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1470 int bpp = visual->depth;
1471 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1472
1473 GdkColormap *cmap = gtk_widget_get_default_colormap();
1474
1475 long pos = 0;
1476 for (int j = 0; j < bitmap.GetHeight(); j++)
1477 {
1478 for (int i = 0; i < bitmap.GetWidth(); i++)
1479 {
1480 int pixel = gdk_image_get_pixel( gdk_image, i, j );
1481 if (bpp <= 8)
1482 {
1483 data[pos] = cmap->colors[pixel].red >> 8;
1484 data[pos+1] = cmap->colors[pixel].green >> 8;
1485 data[pos+2] = cmap->colors[pixel].blue >> 8;
1486 } else if (bpp == 15)
1487 {
1488 data[pos] = (pixel >> 7) & 0xf8;
1489 data[pos+1] = (pixel >> 2) & 0xf8;
1490 data[pos+2] = (pixel << 3) & 0xf8;
1491 } else if (bpp == 16)
1492 {
1493 data[pos] = (pixel >> 8) & 0xf8;
1494 data[pos+1] = (pixel >> 3) & 0xfc;
1495 data[pos+2] = (pixel << 3) & 0xf8;
1496 } else
1497 {
1498 data[pos] = (pixel >> 16) & 0xff;
1499 data[pos+1] = (pixel >> 8) & 0xff;
1500 data[pos+2] = pixel & 0xff;
1501 }
1502
1503 if (gdk_image_mask)
1504 {
1505 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1506 if (mask_pixel == 0)
1507 {
1508 data[pos] = 16;
1509 data[pos+1] = 16;
1510 data[pos+2] = 16;
1511 }
1512 }
1513
1514 pos += 3;
1515 }
1516 }
1517
1518 gdk_image_destroy( gdk_image );
1519 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1520 }
1521
1522 #endif
wxWidgets (Impactor)