]> 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
Corrected stupid error.
[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 #include "wx/app.h"
26 #ifdef wxUSE_LIBPNG
27 #include "../png/png.h"
28 #endif
29 #include "wx/filefn.h"
30 #include "wx/wfstream.h"
31 #include "wx/intl.h"
32
33 #ifdef __WXMSW__
34 #include <windows.h>
35 #endif
36
37 //-----------------------------------------------------------------------------
38 // wxImage
39 //-----------------------------------------------------------------------------
40
41 class wxImageRefData: public wxObjectRefData
42 {
43
44 public:
45 wxImageRefData(void);
46 ~wxImageRefData(void);
47
48 int m_width;
49 int m_height;
50 unsigned char *m_data;
51 bool m_hasMask;
52 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
53 bool m_ok;
54 };
55
56 wxImageRefData::wxImageRefData(void)
57 {
58 m_width = 0;
59 m_height = 0;
60 m_data = (unsigned char*) NULL;
61 m_ok = FALSE;
62 m_maskRed = 0;
63 m_maskGreen = 0;
64 m_maskBlue = 0;
65 m_hasMask = FALSE;
66 }
67
68 wxImageRefData::~wxImageRefData(void)
69 {
70 if (m_data) free( m_data );
71 }
72
73 wxList wxImage::sm_handlers;
74
75 //-----------------------------------------------------------------------------
76
77 #define M_IMGDATA ((wxImageRefData *)m_refData)
78
79 #if !USE_SHARED_LIBRARIES
80 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
81 #endif
82
83 wxImage::wxImage()
84 {
85 }
86
87 wxImage::wxImage( int width, int height )
88 {
89 Create( width, height );
90 }
91
92 wxImage::wxImage( const wxString& name, long type )
93 {
94 LoadFile( name, type );
95 }
96
97 wxImage::wxImage( wxInputStream& stream, long type )
98 {
99 LoadFile( stream, type );
100 }
101
102 wxImage::wxImage( const wxImage& image )
103 {
104 Ref(image);
105 }
106
107 wxImage::wxImage( const wxImage* image )
108 {
109 if (image) Ref(*image);
110 }
111
112 void wxImage::Create( int width, int height )
113 {
114 m_refData = new wxImageRefData();
115
116 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
117 if (M_IMGDATA->m_data)
118 {
119 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
120
121 M_IMGDATA->m_width = width;
122 M_IMGDATA->m_height = height;
123 M_IMGDATA->m_ok = TRUE;
124 }
125 else
126 {
127 UnRef();
128 }
129 }
130
131 void wxImage::Destroy()
132 {
133 UnRef();
134 }
135
136 wxImage wxImage::Scale( int width, int height )
137 {
138 wxImage image;
139
140 wxCHECK_MSG( Ok(), image, "invlaid image" );
141
142 wxCHECK_MSG( (width > 0) && (height > 0), image, "invalid image size" );
143
144 image.Create( width, height );
145
146 char unsigned *data = image.GetData();
147
148 wxCHECK_MSG( data, image, "unable to create image" );
149
150 if (M_IMGDATA->m_hasMask)
151 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
152
153 double xscale = (double)width / (double)M_IMGDATA->m_width;
154 double yscale = (double)height / (double)M_IMGDATA->m_height;
155
156 for (int j = 0; j < height; j++)
157 {
158 for (int i = 0; i < width; i++)
159 {
160 int new_pos = 3*(j*width + i);
161 int old_pos = 3*((long)(j/yscale)*M_IMGDATA->m_width + (long)(i/xscale));
162 data[ new_pos ] = M_IMGDATA->m_data[ old_pos ];
163 data[ new_pos+1 ] = M_IMGDATA->m_data[ old_pos+1 ];
164 data[ new_pos+2 ] = M_IMGDATA->m_data[ old_pos+2 ];
165 }
166 }
167
168 return image;
169 }
170
171 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
172 {
173 wxCHECK_RET( Ok(), "invalid image" );
174
175 int w = M_IMGDATA->m_width;
176 int h = M_IMGDATA->m_height;
177
178 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), "invalid image index" );
179
180 long pos = (y * w + x) * 3;
181
182 M_IMGDATA->m_data[ pos ] = r;
183 M_IMGDATA->m_data[ pos+1 ] = g;
184 M_IMGDATA->m_data[ pos+2 ] = b;
185 }
186
187 unsigned char wxImage::GetRed( int x, int y )
188 {
189 wxCHECK_MSG( Ok(), 0, "invalid image" );
190
191 int w = M_IMGDATA->m_width;
192 int h = M_IMGDATA->m_height;
193
194 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
195
196 long pos = (y * w + x) * 3;
197
198 return M_IMGDATA->m_data[pos];
199 }
200
201 unsigned char wxImage::GetGreen( int x, int y )
202 {
203 wxCHECK_MSG( Ok(), 0, "invalid image" );
204
205 int w = M_IMGDATA->m_width;
206 int h = M_IMGDATA->m_height;
207
208 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
209
210 long pos = (y * w + x) * 3;
211
212 return M_IMGDATA->m_data[pos+1];
213 }
214
215 unsigned char wxImage::GetBlue( int x, int y )
216 {
217 wxCHECK_MSG( Ok(), 0, "invalid image" );
218
219 int w = M_IMGDATA->m_width;
220 int h = M_IMGDATA->m_height;
221
222 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, "invalid image index" );
223
224 long pos = (y * w + x) * 3;
225
226 return M_IMGDATA->m_data[pos+2];
227 }
228
229 bool wxImage::Ok() const
230 {
231 return (M_IMGDATA && M_IMGDATA->m_ok);
232 }
233
234 char unsigned *wxImage::GetData() const
235 {
236 wxCHECK_MSG( Ok(), (char unsigned *)NULL, "invalid image" );
237
238 return M_IMGDATA->m_data;
239 }
240
241 void wxImage::SetData( char unsigned *WXUNUSED(data) )
242 {
243 wxCHECK_RET( Ok(), "invalid image" );
244 }
245
246 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
247 {
248 wxCHECK_RET( Ok(), "invalid image" );
249
250 M_IMGDATA->m_maskRed = r;
251 M_IMGDATA->m_maskGreen = g;
252 M_IMGDATA->m_maskBlue = b;
253 M_IMGDATA->m_hasMask = TRUE;
254 }
255
256 unsigned char wxImage::GetMaskRed() const
257 {
258 wxCHECK_MSG( Ok(), 0, "invalid image" );
259
260 return M_IMGDATA->m_maskRed;
261 }
262
263 unsigned char wxImage::GetMaskGreen() const
264 {
265 wxCHECK_MSG( Ok(), 0, "invalid image" );
266
267 return M_IMGDATA->m_maskGreen;
268 }
269
270 unsigned char wxImage::GetMaskBlue() const
271 {
272 wxCHECK_MSG( Ok(), 0, "invalid image" );
273
274 return M_IMGDATA->m_maskBlue;
275 }
276
277 void wxImage::SetMask( bool mask )
278 {
279 wxCHECK_RET( Ok(), "invalid image" );
280
281 M_IMGDATA->m_hasMask = mask;
282 }
283
284 bool wxImage::HasMask() const
285 {
286 wxCHECK_MSG( Ok(), FALSE, "invalid image" );
287
288 return M_IMGDATA->m_hasMask;
289 }
290
291 int wxImage::GetWidth() const
292 {
293 wxCHECK_MSG( Ok(), 0, "invalid image" );
294
295 return M_IMGDATA->m_width;
296 }
297
298 int wxImage::GetHeight() const
299 {
300 wxCHECK_MSG( Ok(), 0, "invalid image" );
301
302 return M_IMGDATA->m_height;
303 }
304
305 bool wxImage::LoadFile( const wxString& filename, long type )
306 {
307 if (wxFileExists(filename))
308 {
309 wxFileInputStream stream(filename);
310 return LoadFile(stream, type);
311 }
312
313 else {
314 wxLogWarning( "Image file does not exist." );
315
316 return FALSE;
317 }
318 }
319
320 bool wxImage::LoadFile( wxInputStream& stream, long type )
321 {
322 UnRef();
323
324 m_refData = new wxImageRefData;
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->LoadFile( this, stream );
336 }
337
338 bool wxImage::SaveFile( const wxString& filename, int type )
339 {
340 wxFileOutputStream stream(filename);
341
342 if ( stream.LastError() == wxStream_NOERROR )
343 return SaveFile(stream, type);
344 else
345 return FALSE;
346 }
347
348 bool wxImage::SaveFile( wxOutputStream& stream, int type )
349 {
350 wxCHECK_MSG( Ok(), FALSE, "invalid image" );
351
352 wxImageHandler *handler = FindHandler(type);
353
354 if (handler == NULL)
355 {
356 wxLogWarning( "No image handler for type %d defined.", type );
357
358 return FALSE;
359 }
360
361 return handler->SaveFile( this, stream );
362 }
363
364 void wxImage::AddHandler( wxImageHandler *handler )
365 {
366 // make sure that the memory will be freed at the program end
367 sm_handlers.DeleteContents(TRUE);
368
369 sm_handlers.Append( handler );
370 }
371
372 void wxImage::InsertHandler( wxImageHandler *handler )
373 {
374 // make sure that the memory will be freed at the program end
375 sm_handlers.DeleteContents(TRUE);
376
377 sm_handlers.Insert( handler );
378 }
379
380 bool wxImage::RemoveHandler( const wxString& name )
381 {
382 wxImageHandler *handler = FindHandler(name);
383 if (handler)
384 {
385 sm_handlers.DeleteObject(handler);
386 return TRUE;
387 }
388 else
389 return FALSE;
390 }
391
392 wxImageHandler *wxImage::FindHandler( const wxString& name )
393 {
394 wxNode *node = sm_handlers.First();
395 while (node)
396 {
397 wxImageHandler *handler = (wxImageHandler*)node->Data();
398 if (handler->GetName() == name) return handler;
399 node = node->Next();
400 }
401 return (wxImageHandler *)NULL;
402 }
403
404 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
405 {
406 wxNode *node = sm_handlers.First();
407 while (node)
408 {
409 wxImageHandler *handler = (wxImageHandler*)node->Data();
410 if ( handler->GetExtension() == extension &&
411 (bitmapType == -1 || handler->GetType() == bitmapType) )
412 return handler;
413 node = node->Next();
414 }
415 return (wxImageHandler*)NULL;
416 }
417
418 wxImageHandler *wxImage::FindHandler( long bitmapType )
419 {
420 wxNode *node = sm_handlers.First();
421 while (node)
422 {
423 wxImageHandler *handler = (wxImageHandler *)node->Data();
424 if (handler->GetType() == bitmapType) return handler;
425 node = node->Next();
426 }
427 return NULL;
428 }
429
430 void wxImage::InitStandardHandlers()
431 {
432 AddHandler( new wxBMPHandler );
433 #ifdef wxUSE_LIBPNG
434 AddHandler( new wxPNGHandler );
435 #endif
436 }
437
438 void wxImage::CleanUpHandlers()
439 {
440 wxNode *node = sm_handlers.First();
441 while (node)
442 {
443 wxImageHandler *handler = (wxImageHandler *)node->Data();
444 wxNode *next = node->Next();
445 delete handler;
446 delete node;
447 node = next;
448 }
449 }
450
451 //-----------------------------------------------------------------------------
452 // wxImageHandler
453 //-----------------------------------------------------------------------------
454
455 #if !USE_SHARED_LIBRARIES
456 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
457 #endif
458
459 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream) )
460 {
461 return FALSE;
462 }
463
464 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream) )
465 {
466 return FALSE;
467 }
468
469 //-----------------------------------------------------------------------------
470 // wxPNGHandler
471 //-----------------------------------------------------------------------------
472
473 #ifdef wxUSE_LIBPNG
474
475 #if !USE_SHARED_LIBRARIES
476 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
477 #endif
478
479
480 static void _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
481 {
482 ((wxInputStream*) png_get_io_ptr( png_ptr )) -> Read(data, length);
483 }
484
485 static void _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
486 {
487 ((wxOutputStream*) png_get_io_ptr( png_ptr )) -> Write(data, length);
488 }
489
490 bool wxPNGHandler::LoadFile( wxImage *image, wxInputStream& stream )
491 {
492 // VZ: as this function uses setjmp() the only fool proof error handling
493 // method is to use goto (setjmp is not really C++ dtors friendly...)
494
495 unsigned char **lines = (unsigned char **) NULL;
496 unsigned int i;
497 png_infop info_ptr = (png_infop) NULL;
498
499 image->Destroy();
500
501 png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
502 (voidp) NULL,
503 (png_error_ptr) NULL,
504 (png_error_ptr) NULL );
505 if (!png_ptr)
506 goto error;
507
508 info_ptr = png_create_info_struct( png_ptr );
509 if (!info_ptr)
510 goto error;
511
512 if (setjmp(png_ptr->jmpbuf))
513 goto error;
514
515 if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
516 goto error;
517
518 png_set_read_fn( png_ptr, &stream, _PNG_stream_reader);
519
520 png_uint_32 width,height;
521 int bit_depth,color_type,interlace_type;
522
523 png_read_info( png_ptr, info_ptr );
524 png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
525
526 if (color_type == PNG_COLOR_TYPE_PALETTE)
527 png_set_expand( png_ptr );
528
529 png_set_strip_16( png_ptr );
530 png_set_packing( png_ptr );
531 if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
532 png_set_expand( png_ptr );
533 png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
534
535 image->Create( width, height );
536
537 if (!image->Ok())
538 goto error;
539
540 lines = (unsigned char **)malloc( height * sizeof(unsigned char *) );
541 if (lines == NULL)
542 goto error;
543
544 for (i = 0; i < height; i++)
545 {
546 if ((lines[i] = (unsigned char *)malloc(width * (sizeof(unsigned char) * 4))) == NULL)
547 {
548 for ( unsigned int n = 0; n < i; n++ )
549 free( lines[n] );
550 goto error;
551 }
552 }
553
554 // loaded successfully!
555 {
556 int transp = 0;
557 png_read_image( png_ptr, lines );
558 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
559 unsigned char *ptr = image->GetData();
560 if ((color_type == PNG_COLOR_TYPE_GRAY) ||
561 (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
562 {
563 for (unsigned int y = 0; y < height; y++)
564 {
565 unsigned char *ptr2 = lines[y];
566 for (unsigned int x = 0; x < width; x++)
567 {
568 unsigned char r = *ptr2++;
569 unsigned char a = *ptr2++;
570 if (a < 128)
571 {
572 *ptr++ = 255;
573 *ptr++ = 0;
574 *ptr++ = 255;
575 transp = 1;
576 }
577 else
578 {
579 *ptr++ = r;
580 *ptr++ = r;
581 *ptr++ = r;
582 }
583 }
584 }
585 }
586 else
587 {
588 for (unsigned int y = 0; y < height; y++)
589 {
590 unsigned char *ptr2 = lines[y];
591 for (unsigned int x = 0; x < width; x++)
592 {
593 unsigned char r = *ptr2++;
594 unsigned char g = *ptr2++;
595 unsigned char b = *ptr2++;
596 unsigned char a = *ptr2++;
597 if (a < 128)
598 {
599 *ptr++ = 255;
600 *ptr++ = 0;
601 *ptr++ = 255;
602 transp = 1;
603 }
604 else
605 {
606 if ((r == 255) && (g == 0) && (b == 255)) r = 254;
607 *ptr++ = r;
608 *ptr++ = g;
609 *ptr++ = b;
610 }
611 }
612 }
613 }
614
615 for ( unsigned int j = 0; j < height; j++ )
616 free( lines[j] );
617 free( lines );
618
619 if (transp)
620 {
621 image->SetMaskColour( 255, 0, 255 );
622 }
623 else
624 {
625 image->SetMask( FALSE );
626 }
627 }
628
629 return TRUE;
630
631 error:
632 wxLogError(_("Couldn't load a PNG image - probably file is corrupted."));
633
634 if ( image->Ok() )
635 {
636 image->Destroy();
637 }
638
639 if ( lines )
640 {
641 free( lines );
642 }
643
644 if ( png_ptr )
645 {
646 if ( info_ptr )
647 {
648 png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
649 free(info_ptr);
650 }
651 else
652 png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
653 }
654 return FALSE;
655 }
656
657
658 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream )
659 {
660 {
661 png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
662 if (!png_ptr)
663 {
664 return FALSE;
665 }
666
667 png_infop info_ptr = png_create_info_struct(png_ptr);
668 if (info_ptr == NULL)
669 {
670 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
671 return FALSE;
672 }
673
674 if (setjmp(png_ptr->jmpbuf))
675 {
676 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
677 return FALSE;
678 }
679
680 png_set_write_fn( png_ptr, &stream, _PNG_stream_writer, NULL);
681
682 png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
683 PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
684 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
685
686 png_color_8 sig_bit;
687 sig_bit.red = 8;
688 sig_bit.green = 8;
689 sig_bit.blue = 8;
690 sig_bit.alpha = 8;
691 png_set_sBIT( png_ptr, info_ptr, &sig_bit );
692 png_write_info( png_ptr, info_ptr );
693 png_set_shift( png_ptr, &sig_bit );
694 png_set_packing( png_ptr );
695
696 unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
697 if (!data)
698 {
699 png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
700 return FALSE;
701 }
702
703 for (int y = 0; y < image->GetHeight(); y++)
704 {
705 unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
706 for (int x = 0; x < image->GetWidth(); x++)
707 {
708 data[(x << 2) + 0] = *ptr++;
709 data[(x << 2) + 1] = *ptr++;
710 data[(x << 2) + 2] = *ptr++;
711 if ((data[(x << 2) + 0] == image->GetMaskRed()) &&
712 (data[(x << 2) + 1] == image->GetMaskGreen()) &&
713 (data[(x << 2) + 2] == image->GetMaskBlue()))
714 {
715 data[(x << 2) + 3] = 0;
716 }
717 else
718 {
719 data[(x << 2) + 3] = 255;
720 }
721 }
722 png_bytep row_ptr = data;
723 png_write_rows( png_ptr, &row_ptr, 1 );
724 }
725
726 free(data);
727 png_write_end( png_ptr, info_ptr );
728 png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
729 }
730 return TRUE;
731 }
732
733 #endif
734
735 // wxUSE_LIBPNG
736
737 //-----------------------------------------------------------------------------
738 // wxBMPHandler
739 //-----------------------------------------------------------------------------
740
741 #if !USE_SHARED_LIBRARIES
742 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
743 #endif
744
745 bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
746 {
747 unsigned char *data, *ptr;
748 int done, i, bpp, planes, comp, ncolors, line, column,
749 linesize, linepos, rshift = 0, gshift = 0, bshift = 0;
750 unsigned char aByte;
751 short int word;
752 long int dbuf[4], dword, rmask = 0, gmask = 0, bmask = 0, offset,
753 size;
754 off_t start_offset = stream.TellI();
755 signed char bbuf[4];
756 struct _cmap
757 {
758 unsigned char r, g, b;
759 }
760 *cmap = NULL;
761 #ifndef BI_RGB
762 #define BI_RGB 0
763 #define BI_RLE8 1
764 #define BI_RLE4 2
765 #endif
766
767 #ifndef BI_BITFIELDS
768 #define BI_BITFIELDS 3
769 #endif
770
771 image->Destroy();
772
773 done = 0;
774 /*
775 * Reading the bmp header
776 */
777
778 stream.Read(&bbuf, 2);
779
780 stream.Read(dbuf, 4 * 4);
781
782 size = dbuf[0];
783 offset = dbuf[2];
784
785 stream.Read(dbuf, 4 * 2);
786 int width = (int)dbuf[0];
787 int height = (int)dbuf[1];
788 if (width > 32767)
789 {
790 wxLogError( "Image width > 32767 pixels for file\n" );
791 return FALSE;
792 }
793 if (height > 32767)
794 {
795 wxLogError( "Image height > 32767 pixels for file\n" );
796 return FALSE;
797 }
798 stream.Read(&word, 2);
799 planes = (int)word;
800 stream.Read(&word, 2);
801 bpp = (int)word;
802 if (bpp != 1 && bpp != 4 && bpp != 8 && bpp && 16 && bpp != 24 && bpp != 32)
803 {
804 wxLogError( "unknown bitdepth in file\n" );
805 return FALSE;
806 }
807 stream.Read(dbuf, 4 * 4);
808 comp = (int)dbuf[0];
809 if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
810 {
811 wxLogError( "unknown encoding in Windows BMP file\n" );
812 return FALSE;
813 }
814 stream.Read(dbuf, 4 * 2);
815 ncolors = (int)dbuf[0];
816 if (ncolors == 0)
817 ncolors = 1 << bpp;
818 /* some more sanity checks */
819 if (((comp == BI_RLE4) && (bpp != 4)) || ((comp == BI_RLE8) && (bpp != 8)) || ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
820 {
821 wxLogError( "encoding of BMP doesn't match bitdepth\n" );
822 return FALSE;
823 }
824 if (bpp < 16)
825 {
826 cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
827
828 if (!cmap)
829 {
830 wxLogError( "Cannot allocate RAM for color map in BMP file\n" );
831 return FALSE;
832 }
833 }
834 else
835 cmap = NULL;
836
837 image->Create( width, height );
838 ptr = image->GetData();
839 if (!ptr)
840 {
841 wxLogError( "Cannot allocate RAM for RGB data in file\n" );
842 if (cmap)
843 free(cmap);
844 return FALSE;
845 }
846
847 /*
848 * Reading the palette, if it exists.
849 */
850 if (bpp < 16 && ncolors != 0)
851 {
852 for (i = 0; i < ncolors; i++)
853 {
854 stream.Read(bbuf, 4);
855 cmap[i].b = bbuf[0];
856 cmap[i].g = bbuf[1];
857 cmap[i].r = bbuf[2];
858 }
859 }
860 else if (bpp == 16 || bpp == 32)
861 {
862 if (comp == BI_BITFIELDS)
863 {
864 int bit = 0;
865
866 stream.Read(dbuf, 4 * 3);
867 bmask = dbuf[0];
868 gmask = dbuf[1];
869 rmask = dbuf[2];
870 /* find shift amount.. ugly, but i can't think of a better way */
871 for (bit = 0; bit < bpp; bit++)
872 {
873 if (bmask & (1 << bit))
874 bshift = bit;
875 if (gmask & (1 << bit))
876 gshift = bit;
877 if (rmask & (1 << bit))
878 rshift = bit;
879 }
880 }
881 else if (bpp == 16)
882 {
883 rmask = 0x7C00;
884 gmask = 0x03E0;
885 bmask = 0x001F;
886 rshift = 10;
887 gshift = 5;
888 bshift = 0;
889 }
890 else if (bpp == 32)
891 {
892 rmask = 0x00FF0000;
893 gmask = 0x0000FF00;
894 bmask = 0x000000FF;
895 rshift = 16;
896 gshift = 8;
897 bshift = 0;
898 }
899 }
900
901 /*
902 * Reading the image data
903 */
904 stream.SeekI(start_offset + offset);
905 data = ptr;
906
907 /* set the whole image to the background color */
908 if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8))
909 {
910 for (i = 0; i < width * height; i++)
911 {
912 *ptr++ = cmap[0].r;
913 *ptr++ = cmap[0].g;
914 *ptr++ = cmap[0].b;
915 }
916 ptr = data;
917 }
918 line = 0;
919 column = 0;
920 #define poffset (line * width * 3 + column * 3)
921
922 /*
923 * BMPs are stored upside down... hmmmmmmmmmm....
924 */
925
926 linesize = ((width * bpp + 31) / 32) * 4;
927 for (line = (height - 1); line >= 0; line--)
928 {
929 linepos = 0;
930 for (column = 0; column < width;)
931 {
932 if (bpp < 16)
933 {
934 int index;
935
936 linepos++;
937 aByte = stream.GetC();
938 if (bpp == 1)
939 {
940 int bit = 0;
941
942 for (bit = 0; bit < 8; bit++)
943 {
944 index = ((aByte & (0x80 >> bit)) ? 1 : 0);
945 ptr[poffset] = cmap[index].r;
946 ptr[poffset + 1] = cmap[index].g;
947 ptr[poffset + 2] = cmap[index].b;
948 column++;
949 }
950 }
951 else if (bpp == 4)
952 {
953 if (comp == BI_RLE4)
954 {
955 wxLogError( "can't deal with 4bit encoded yet.\n");
956 image->Destroy();
957 free(cmap);
958 return FALSE;
959 }
960 else
961 {
962 int nibble = 0;
963
964 for (nibble = 0; nibble < 2; nibble++)
965 {
966 index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
967 if (index >= 16)
968 index = 15;
969 ptr[poffset] = cmap[index].r;
970 ptr[poffset + 1] = cmap[index].g;
971 ptr[poffset + 2] = cmap[index].b;
972 column++;
973 }
974 }
975 }
976 else if (bpp == 8)
977 {
978 if (comp == BI_RLE8)
979 {
980 unsigned char first;
981
982 first = aByte;
983 aByte = stream.GetC();
984 if (first == 0)
985 {
986 if (aByte == 0)
987 {
988 /* column = width; */
989 }
990 else if (aByte == 1)
991 {
992 column = width;
993 line = -1;
994 }
995 else if (aByte == 2)
996 {
997 aByte = stream.GetC();
998 column += aByte;
999 linepos = column * bpp / 8;
1000 aByte = stream.GetC();
1001 line += aByte;
1002 }
1003 else
1004 {
1005 int absolute = aByte;
1006
1007 for (i = 0; i < absolute; i++)
1008 {
1009 linepos++;
1010 aByte = stream.GetC();
1011 ptr[poffset] = cmap[aByte].r;
1012 ptr[poffset + 1] = cmap[aByte].g;
1013 ptr[poffset + 2] = cmap[aByte].b;
1014 column++;
1015 }
1016 if (absolute & 0x01)
1017 aByte = stream.GetC();
1018 }
1019 }
1020 else
1021 {
1022 for (i = 0; i < first; i++)
1023 {
1024 ptr[poffset] = cmap[aByte].r;
1025 ptr[poffset + 1] = cmap[aByte].g;
1026 ptr[poffset + 2] = cmap[aByte].b;
1027 column++;
1028 linepos++;
1029 }
1030 }
1031 }
1032 else
1033 {
1034 ptr[poffset] = cmap[aByte].r;
1035 ptr[poffset + 1] = cmap[aByte].g;
1036 ptr[poffset + 2] = cmap[aByte].b;
1037 column++;
1038 linepos += size;
1039 }
1040 }
1041 }
1042 else if (bpp == 24)
1043 {
1044 stream.Read(&bbuf, 3);
1045 linepos += 3;
1046 ptr[poffset] = (unsigned char)bbuf[2];
1047 ptr[poffset + 1] = (unsigned char)bbuf[1];
1048 ptr[poffset + 2] = (unsigned char)bbuf[0];
1049 column++;
1050 }
1051 else if (bpp == 16)
1052 {
1053 unsigned char temp;
1054
1055 stream.Read(&word, 2);
1056 linepos += 2;
1057 temp = (word & rmask) >> rshift;
1058 ptr[poffset] = temp;
1059 temp = (word & gmask) >> gshift;
1060 ptr[poffset + 1] = temp;
1061 temp = (word & bmask) >> gshift;
1062 ptr[poffset + 2] = temp;
1063 column++;
1064 }
1065 else
1066 {
1067 unsigned char temp;
1068
1069 stream.Read(&dword, 4);
1070 linepos += 4;
1071 temp = (dword & rmask) >> rshift;
1072 ptr[poffset] = temp;
1073 temp = (dword & gmask) >> gshift;
1074 ptr[poffset + 1] = temp;
1075 temp = (dword & bmask) >> bshift;
1076 ptr[poffset + 2] = temp;
1077 column++;
1078 }
1079 }
1080 while ((linepos < linesize) && (comp != 1) && (comp != 2))
1081 {
1082 stream.Read(&aByte, 1);
1083 linepos += 1;
1084 if (stream.LastError() != wxStream_NOERROR)
1085 break;
1086 }
1087 }
1088 if (cmap) free(cmap);
1089
1090 image->SetMask( FALSE );
1091
1092 return TRUE;
1093 }
1094
1095 #ifdef __WXMSW__
1096
1097 wxBitmap wxImage::ConvertToBitmap() const
1098 {
1099 // sizeLimit is the MS upper limit for the DIB size
1100 int sizeLimit = 1024*768*3;
1101
1102 // width and height of the device-dependent bitmap
1103 int width = GetWidth();
1104 int bmpHeight = GetHeight();
1105
1106 // calc the number of bytes per scanline and padding
1107 int bytePerLine = width*3;
1108 int sizeDWORD = sizeof( DWORD );
1109 div_t lineBoundary = div( bytePerLine, sizeDWORD );
1110 int padding = 0;
1111 if( lineBoundary.rem > 0 )
1112 {
1113 padding = sizeDWORD - lineBoundary.rem;
1114 bytePerLine += padding;
1115 }
1116 // calc the number of DIBs and heights of DIBs
1117 int numDIB = 1;
1118 int hRemain = 0;
1119 int height = sizeLimit/bytePerLine;
1120 if( height >= bmpHeight )
1121 height = bmpHeight;
1122 else
1123 {
1124 div_t result = div( bmpHeight, height );
1125 numDIB = result.quot;
1126 hRemain = result.rem;
1127 if( hRemain >0 ) numDIB++;
1128 }
1129
1130 // set bitmap parameters
1131 wxBitmap bitmap;
1132 wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1133 bitmap.SetWidth( width );
1134 bitmap.SetHeight( bmpHeight );
1135 bitmap.SetDepth( wxDisplayDepth() );
1136
1137 // create a DIB header
1138 int headersize = sizeof(BITMAPINFOHEADER);
1139 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1140 wxCHECK_MSG( lpDIBh, bitmap, "could not allocate memory for DIB header" );
1141 // Fill in the DIB header
1142 lpDIBh->bmiHeader.biSize = headersize;
1143 lpDIBh->bmiHeader.biWidth = (DWORD)width;
1144 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1145 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1146 // the general formula for biSizeImage:
1147 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
1148 lpDIBh->bmiHeader.biPlanes = 1;
1149 lpDIBh->bmiHeader.biBitCount = 24;
1150 lpDIBh->bmiHeader.biCompression = BI_RGB;
1151 lpDIBh->bmiHeader.biClrUsed = 0;
1152 // These seem not really needed for our purpose here.
1153 lpDIBh->bmiHeader.biClrImportant = 0;
1154 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1155 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1156 // memory for DIB data
1157 unsigned char *lpBits;
1158 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
1159 if( !lpBits )
1160 {
1161 wxFAIL_MSG( "could not allocate memory for DIB" );
1162 free( lpDIBh );
1163 return bitmap;
1164 }
1165
1166 // create and set the device-dependent bitmap
1167 HDC hdc = ::GetDC(NULL);
1168 HDC memdc = ::CreateCompatibleDC( hdc );
1169 HBITMAP hbitmap;
1170 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
1171 ::SelectObject( memdc, hbitmap);
1172
1173 // copy image data into DIB data and then into DDB (in a loop)
1174 unsigned char *data = GetData();
1175 int i, j, n;
1176 int origin = 0;
1177 unsigned char *ptdata = data;
1178 unsigned char *ptbits;
1179
1180 for( n=0; n<numDIB; n++ )
1181 {
1182 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
1183 {
1184 // redefine height and size of the (possibly) last smaller DIB
1185 // memory is not reallocated
1186 height = hRemain;
1187 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1188 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1189 }
1190 ptbits = lpBits;
1191
1192 for( j=0; j<height; j++ )
1193 {
1194 for( i=0; i<width; i++ )
1195 {
1196 *(ptbits++) = *(ptdata+2);
1197 *(ptbits++) = *(ptdata+1);
1198 *(ptbits++) = *(ptdata );
1199 ptdata += 3;
1200 }
1201 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
1202 }
1203 ::StretchDIBits( memdc, 0, origin, width, height,\
1204 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1205 origin += height;
1206 // if numDIB = 1, lines below can also be used
1207 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
1208 // The above line is equivalent to the following two lines.
1209 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1210 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
1211 // or the following lines
1212 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1213 // HDC memdc = ::CreateCompatibleDC( hdc );
1214 // ::SelectObject( memdc, hbitmap);
1215 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
1216 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
1217 // ::SelectObject( memdc, 0 );
1218 // ::DeleteDC( memdc );
1219 }
1220 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
1221
1222 // similarly, created an mono-bitmap for the possible mask
1223 if( HasMask() )
1224 {
1225 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
1226 ::SelectObject( memdc, hbitmap);
1227 if( numDIB == 1 ) height = bmpHeight;
1228 else height = sizeLimit/bytePerLine;
1229 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1230 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1231 origin = 0;
1232 unsigned char r = GetMaskRed();
1233 unsigned char g = GetMaskGreen();
1234 unsigned char b = GetMaskBlue();
1235 unsigned char zero = 0, one = 255;
1236 ptdata = data;
1237 for( n=0; n<numDIB; n++ )
1238 {
1239 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
1240 {
1241 // redefine height and size of the (possibly) last smaller DIB
1242 // memory is not reallocated
1243 height = hRemain;
1244 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1245 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1246 }
1247 ptbits = lpBits;
1248 for( int j=0; j<height; j++ )
1249 {
1250 for( int i=0; i<width; i++ )
1251 {
1252 if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
1253 {
1254 *(ptbits++) = one;
1255 *(ptbits++) = one;
1256 *(ptbits++) = one;
1257 }
1258 else
1259 {
1260 *(ptbits++) = zero;
1261 *(ptbits++) = zero;
1262 *(ptbits++) = zero;
1263 }
1264 }
1265 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
1266 }
1267 ::StretchDIBits( memdc, 0, origin, width, height,\
1268 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1269 origin += height;
1270 }
1271 // create a wxMask object
1272 wxMask *mask = new wxMask();
1273 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
1274 bitmap.SetMask( mask );
1275 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
1276 /* The following can also be used but is slow to run
1277 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1278 wxMask *mask = new wxMask( bitmap, colour );
1279 bitmap.SetMask( mask );
1280 */
1281 }
1282
1283 // free allocated resources
1284 ::SelectObject( memdc, 0 );
1285 ::DeleteDC( memdc );
1286 ::ReleaseDC(NULL, hdc);
1287 free(lpDIBh);
1288 free(lpBits);
1289
1290 // check the wxBitmap object
1291 if( bitmap.GetHBITMAP() )
1292 bitmap.SetOk( TRUE );
1293 else
1294 bitmap.SetOk( FALSE );
1295
1296 return bitmap;
1297 }
1298
1299 wxImage::wxImage( const wxBitmap &bitmap )
1300 {
1301 // check the bitmap
1302 if( !bitmap.Ok() )
1303 {
1304 wxFAIL_MSG( "invalid bitmap" );
1305 return;
1306 }
1307
1308 // create an wxImage object
1309 int width = bitmap.GetWidth();
1310 int height = bitmap.GetHeight();
1311 Create( width, height );
1312 unsigned char *data = GetData();
1313 if( !data )
1314 {
1315 wxFAIL_MSG( "could not allocate data for image" );
1316 return;
1317 }
1318
1319 // calc the number of bytes per scanline and padding in the DIB
1320 int bytePerLine = width*3;
1321 int sizeDWORD = sizeof( DWORD );
1322 div_t lineBoundary = div( bytePerLine, sizeDWORD );
1323 int padding = 0;
1324 if( lineBoundary.rem > 0 )
1325 {
1326 padding = sizeDWORD - lineBoundary.rem;
1327 bytePerLine += padding;
1328 }
1329
1330 // create a DIB header
1331 int headersize = sizeof(BITMAPINFOHEADER);
1332 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
1333 if( !lpDIBh )
1334 {
1335 wxFAIL_MSG( "could not allocate data for DIB header" );
1336 free( data );
1337 return;
1338 }
1339 // Fill in the DIB header
1340 lpDIBh->bmiHeader.biSize = headersize;
1341 lpDIBh->bmiHeader.biWidth = width;
1342 lpDIBh->bmiHeader.biHeight = -height;
1343 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
1344 lpDIBh->bmiHeader.biPlanes = 1;
1345 lpDIBh->bmiHeader.biBitCount = 24;
1346 lpDIBh->bmiHeader.biCompression = BI_RGB;
1347 lpDIBh->bmiHeader.biClrUsed = 0;
1348 // These seem not really needed for our purpose here.
1349 lpDIBh->bmiHeader.biClrImportant = 0;
1350 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1351 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1352 // memory for DIB data
1353 unsigned char *lpBits;
1354 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
1355 if( !lpBits )
1356 {
1357 wxFAIL_MSG( "could not allocate data for DIB" );
1358 free( data );
1359 free( lpDIBh );
1360 return;
1361 }
1362
1363 // copy data from the device-dependent bitmap to the DIB
1364 HDC hdc = ::GetDC(NULL);
1365 HBITMAP hbitmap;
1366 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1367 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1368
1369 // copy DIB data into the wxImage object
1370 int i, j;
1371 unsigned char *ptdata = data;
1372 unsigned char *ptbits = lpBits;
1373 for( i=0; i<height; i++ )
1374 {
1375 for( j=0; j<width; j++ )
1376 {
1377 *(ptdata++) = *(ptbits+2);
1378 *(ptdata++) = *(ptbits+1);
1379 *(ptdata++) = *(ptbits );
1380 ptbits += 3;
1381 }
1382 ptbits += padding;
1383 }
1384
1385 // similarly, set data according to the possible mask bitmap
1386 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1387 {
1388 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1389 // memory DC created, color set, data copied, and memory DC deleted
1390 HDC memdc = ::CreateCompatibleDC( hdc );
1391 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1392 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1393 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1394 ::DeleteDC( memdc );
1395 // background color set to RGB(16,16,16) in consistent with wxGTK
1396 unsigned char r=16, g=16, b=16;
1397 ptdata = data;
1398 ptbits = lpBits;
1399 for( i=0; i<height; i++ )
1400 {
1401 for( j=0; j<width; j++ )
1402 {
1403 if( *ptbits != 0 )
1404 ptdata += 3;
1405 else
1406 {
1407 *(ptdata++) = r;
1408 *(ptdata++) = g;
1409 *(ptdata++) = b;
1410 }
1411 ptbits += 3;
1412 }
1413 ptbits += padding;
1414 }
1415 SetMaskColour( r, g, b );
1416 SetMask( TRUE );
1417 }
1418 else
1419 {
1420 SetMask( FALSE );
1421 }
1422 // free allocated resources
1423 ::ReleaseDC(NULL, hdc);
1424 free(lpDIBh);
1425 free(lpBits);
1426 }
1427
1428 #endif
1429
1430 #ifdef __WXGTK__
1431
1432 #include "gtk/gtk.h"
1433 #include "gdk/gdk.h"
1434 #include "gdk/gdkx.h"
1435
1436 wxBitmap wxImage::ConvertToBitmap() const
1437 {
1438 wxBitmap bitmap;
1439
1440 wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1441
1442 int width = GetWidth();
1443 int height = GetHeight();
1444
1445 bitmap.SetHeight( height );
1446 bitmap.SetWidth( width );
1447
1448 // Create picture
1449
1450 GdkImage *data_image =
1451 gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
1452
1453 bitmap.SetPixmap( gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 ) );
1454
1455 // Create mask
1456
1457 GdkImage *mask_image = (GdkImage*) NULL;
1458
1459 if (HasMask())
1460 {
1461 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1462
1463 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1464
1465 wxMask *mask = new wxMask();
1466 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1467
1468 bitmap.SetMask( mask );
1469 }
1470
1471 // Retrieve depth
1472
1473 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1474 if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1475 int bpp = visual->depth;
1476
1477 bitmap.SetDepth( bpp );
1478
1479 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1480 if (bpp < 8) bpp = 8;
1481
1482 // Render
1483
1484 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1485 byte_order b_o = RGB;
1486
1487 if (bpp >= 24)
1488 {
1489 GdkVisual *visual = gdk_visual_get_system();
1490 if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask)) b_o = RGB;
1491 else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask)) b_o = RGB;
1492 else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask)) b_o = BRG;
1493 else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1494 else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask)) b_o = GRB;
1495 else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask)) b_o = GBR;
1496 }
1497
1498 int r_mask = GetMaskRed();
1499 int g_mask = GetMaskGreen();
1500 int b_mask = GetMaskBlue();
1501
1502 unsigned char* data = GetData();
1503
1504 int index = 0;
1505 for (int y = 0; y < height; y++)
1506 {
1507 for (int x = 0; x < width; x++)
1508 {
1509 int r = data[index];
1510 index++;
1511 int g = data[index];
1512 index++;
1513 int b = data[index];
1514 index++;
1515
1516 if (HasMask())
1517 {
1518 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1519 gdk_image_put_pixel( mask_image, x, y, 1 );
1520 else
1521 gdk_image_put_pixel( mask_image, x, y, 0 );
1522 }
1523
1524 if (HasMask())
1525 {
1526 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1527 gdk_image_put_pixel( mask_image, x, y, 1 );
1528 else
1529 gdk_image_put_pixel( mask_image, x, y, 0 );
1530 }
1531
1532 switch (bpp)
1533 {
1534 case 8:
1535 {
1536 int pixel = -1;
1537 if (wxTheApp->m_colorCube)
1538 {
1539 pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1540 }
1541 else
1542 {
1543 GdkColormap *cmap = gtk_widget_get_default_colormap();
1544 GdkColor *colors = cmap->colors;
1545 int max = 3 * (65536);
1546
1547 for (int i = 0; i < cmap->size; i++)
1548 {
1549 int rdiff = (r << 8) - colors[i].red;
1550 int gdiff = (g << 8) - colors[i].green;
1551 int bdiff = (b << 8) - colors[i].blue;
1552 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1553 if (sum < max) { pixel = i; max = sum; }
1554 }
1555 }
1556
1557 gdk_image_put_pixel( data_image, x, y, pixel );
1558
1559 break;
1560 }
1561 case 15:
1562 {
1563 guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1564 gdk_image_put_pixel( data_image, x, y, pixel );
1565 break;
1566 }
1567 case 16:
1568 {
1569 guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1570 gdk_image_put_pixel( data_image, x, y, pixel );
1571 break;
1572 }
1573 case 32:
1574 case 24:
1575 {
1576 guint32 pixel = 0;
1577 switch (b_o)
1578 {
1579 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1580 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1581 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1582 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1583 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1584 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1585 }
1586 gdk_image_put_pixel( data_image, x, y, pixel );
1587 }
1588 default: break;
1589 }
1590 } // for
1591 } // for
1592
1593 // Blit picture
1594
1595 GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1596
1597 gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1598
1599 gdk_image_destroy( data_image );
1600 gdk_gc_unref( data_gc );
1601
1602 // Blit mask
1603
1604 if (HasMask())
1605 {
1606 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1607
1608 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1609
1610 gdk_image_destroy( mask_image );
1611 gdk_gc_unref( mask_gc );
1612 }
1613
1614 return bitmap;
1615 }
1616
1617 wxImage::wxImage( const wxBitmap &bitmap )
1618 {
1619 wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
1620
1621 GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
1622 0, 0,
1623 bitmap.GetWidth(), bitmap.GetHeight() );
1624
1625 wxCHECK_RET( gdk_image, "couldn't create image" );
1626
1627 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1628 char unsigned *data = GetData();
1629
1630 if (!data)
1631 {
1632 gdk_image_destroy( gdk_image );
1633 wxFAIL_MSG( "couldn't create image" );
1634 return;
1635 }
1636
1637 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1638 if (bitmap.GetMask())
1639 {
1640 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1641 0, 0,
1642 bitmap.GetWidth(), bitmap.GetHeight() );
1643
1644 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1645 }
1646
1647 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1648 if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1649 int bpp = visual->depth;
1650 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1651
1652 GdkColormap *cmap = gtk_widget_get_default_colormap();
1653
1654 long pos = 0;
1655 for (int j = 0; j < bitmap.GetHeight(); j++)
1656 {
1657 for (int i = 0; i < bitmap.GetWidth(); i++)
1658 {
1659 int pixel = gdk_image_get_pixel( gdk_image, i, j );
1660 if (bpp <= 8)
1661 {
1662 data[pos] = cmap->colors[pixel].red >> 8;
1663 data[pos+1] = cmap->colors[pixel].green >> 8;
1664 data[pos+2] = cmap->colors[pixel].blue >> 8;
1665 } else if (bpp == 15)
1666 {
1667 data[pos] = (pixel >> 7) & 0xf8;
1668 data[pos+1] = (pixel >> 2) & 0xf8;
1669 data[pos+2] = (pixel << 3) & 0xf8;
1670 } else if (bpp == 16)
1671 {
1672 data[pos] = (pixel >> 8) & 0xf8;
1673 data[pos+1] = (pixel >> 3) & 0xfc;
1674 data[pos+2] = (pixel << 3) & 0xf8;
1675 } else
1676 {
1677 data[pos] = (pixel >> 16) & 0xff;
1678 data[pos+1] = (pixel >> 8) & 0xff;
1679 data[pos+2] = pixel & 0xff;
1680 }
1681
1682 if (gdk_image_mask)
1683 {
1684 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1685 if (mask_pixel == 0)
1686 {
1687 data[pos] = 16;
1688 data[pos+1] = 16;
1689 data[pos+2] = 16;
1690 }
1691 }
1692
1693 pos += 3;
1694 }
1695 }
1696
1697 gdk_image_destroy( gdk_image );
1698 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1699 }
1700
1701 #endif
1702
1703 // TODO
1704
1705 #ifdef __WXMOTIF__
1706
1707 #include <Xm/Xm.h>
1708 #include "wx/utils.h"
1709 #include <math.h>
1710
1711 wxBitmap wxImage::ConvertToBitmap() const
1712 {
1713 wxBitmap bitmap;
1714
1715 wxCHECK_MSG( Ok(), bitmap, "invalid image" );
1716
1717 int width = GetWidth();
1718 int height = GetHeight();
1719
1720 bitmap.SetHeight( height );
1721 bitmap.SetWidth( width );
1722
1723 Display *dpy = (Display*) wxGetDisplay();
1724 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1725 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1726
1727 // Create image
1728
1729 XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
1730 data_image->data = new char[ data_image->bytes_per_line * data_image->height ];
1731
1732 bitmap.Create( width, height, bpp );
1733
1734 /*
1735 // Create mask
1736
1737 GdkImage *mask_image = (GdkImage*) NULL;
1738
1739 if (HasMask())
1740 {
1741 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1742
1743 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1744
1745 wxMask *mask = new wxMask();
1746 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1747
1748 bitmap.SetMask( mask );
1749 }
1750 */
1751
1752 // Retrieve depth info
1753
1754 XVisualInfo vinfo_template;
1755 XVisualInfo *vi;
1756
1757 vinfo_template.visual = vis;
1758 vinfo_template.visualid = XVisualIDFromVisual( vis );
1759 vinfo_template.depth = bpp;
1760 int nitem = 0;
1761
1762 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1763
1764 if (!vi)
1765 {
1766 printf("no visual.\n" );
1767 return wxNullBitmap;
1768 }
1769
1770 XFree( vi );
1771
1772 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1773 if (bpp < 8) bpp = 8;
1774
1775 // Render
1776
1777 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1778 byte_order b_o = RGB;
1779
1780 if (bpp >= 24)
1781 {
1782 if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB;
1783 else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB;
1784 else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG;
1785 else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
1786 else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB;
1787 else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR;
1788 }
1789
1790 /*
1791 int r_mask = GetMaskRed();
1792 int g_mask = GetMaskGreen();
1793 int b_mask = GetMaskBlue();
1794 */
1795
1796 XColor colors[256];
1797 if (bpp == 8)
1798 {
1799 Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
1800
1801 for (int i = 0; i < 256; i++) colors[i].pixel = i;
1802 XQueryColors( dpy, cmap, colors, 256 );
1803 }
1804
1805 unsigned char* data = GetData();
1806
1807 int index = 0;
1808 for (int y = 0; y < height; y++)
1809 {
1810 for (int x = 0; x < width; x++)
1811 {
1812 int r = data[index];
1813 index++;
1814 int g = data[index];
1815 index++;
1816 int b = data[index];
1817 index++;
1818
1819 /*
1820 if (HasMask())
1821 {
1822 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1823 gdk_image_put_pixel( mask_image, x, y, 1 );
1824 else
1825 gdk_image_put_pixel( mask_image, x, y, 0 );
1826 }
1827 */
1828
1829 switch (bpp)
1830 {
1831 case 8:
1832 {
1833 int pixel = -1;
1834 /*
1835 if (wxTheApp->m_colorCube)
1836 {
1837 pixel = wxTheApp->m_colorCube
1838 [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1839 }
1840 else
1841 {
1842 */
1843 int max = 3 * (65536);
1844 for (int i = 0; i < 256; i++)
1845 {
1846 int rdiff = (r << 8) - colors[i].red;
1847 int gdiff = (g << 8) - colors[i].green;
1848 int bdiff = (b << 8) - colors[i].blue;
1849 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1850 if (sum < max) { pixel = i; max = sum; }
1851 }
1852 /*
1853 }
1854 */
1855 XPutPixel( data_image, x, y, pixel );
1856 break;
1857 }
1858 case 15:
1859 {
1860 int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1861 XPutPixel( data_image, x, y, pixel );
1862 break;
1863 }
1864 case 16:
1865 {
1866 int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1867 XPutPixel( data_image, x, y, pixel );
1868 break;
1869 }
1870 case 32:
1871 case 24:
1872 {
1873 int pixel = 0;
1874 switch (b_o)
1875 {
1876 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1877 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1878 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1879 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1880 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1881 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1882 }
1883 XPutPixel( data_image, x, y, pixel );
1884 }
1885 default: break;
1886 }
1887 } // for
1888 } // for
1889
1890 // Blit picture
1891
1892 XGCValues gcvalues;
1893 gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
1894 GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
1895 XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
1896
1897 XDestroyImage( data_image );
1898 XFreeGC( dpy, gc );
1899
1900 /*
1901 // Blit mask
1902
1903 if (HasMask())
1904 {
1905 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1906
1907 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1908
1909 gdk_image_destroy( mask_image );
1910 gdk_gc_unref( mask_gc );
1911 }
1912 */
1913
1914 return bitmap;
1915 }
1916
1917 wxImage::wxImage( const wxBitmap &bitmap )
1918 {
1919 wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
1920
1921 Display *dpy = (Display*) wxGetDisplay();
1922 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1923 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1924
1925 XImage *ximage = XGetImage( dpy,
1926 (Drawable)bitmap.GetPixmap(),
1927 0, 0,
1928 bitmap.GetWidth(), bitmap.GetHeight(),
1929 AllPlanes, ZPixmap );
1930
1931 wxCHECK_RET( ximage, "couldn't create image" );
1932
1933 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1934 char unsigned *data = GetData();
1935
1936 if (!data)
1937 {
1938 XDestroyImage( ximage );
1939 wxFAIL_MSG( "couldn't create image" );
1940 return;
1941 }
1942
1943 /*
1944 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1945 if (bitmap.GetMask())
1946 {
1947 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1948 0, 0,
1949 bitmap.GetWidth(), bitmap.GetHeight() );
1950
1951 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1952 }
1953 */
1954
1955 // Retrieve depth info
1956
1957 XVisualInfo vinfo_template;
1958 XVisualInfo *vi;
1959
1960 vinfo_template.visual = vis;
1961 vinfo_template.visualid = XVisualIDFromVisual( vis );
1962 vinfo_template.depth = bpp;
1963 int nitem = 0;
1964
1965 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1966
1967 if (!vi)
1968 {
1969 printf("no visual.\n" );
1970 return;
1971 }
1972
1973 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1974
1975 XFree( vi );
1976
1977 XColor colors[256];
1978 if (bpp == 8)
1979 {
1980 Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
1981
1982 for (int i = 0; i < 256; i++) colors[i].pixel = i;
1983 XQueryColors( dpy, cmap, colors, 256 );
1984 }
1985
1986 long pos = 0;
1987 for (int j = 0; j < bitmap.GetHeight(); j++)
1988 {
1989 for (int i = 0; i < bitmap.GetWidth(); i++)
1990 {
1991 int pixel = XGetPixel( ximage, i, j );
1992 if (bpp <= 8)
1993 {
1994 data[pos] = colors[pixel].red >> 8;
1995 data[pos+1] = colors[pixel].green >> 8;
1996 data[pos+2] = colors[pixel].blue >> 8;
1997 } else if (bpp == 15)
1998 {
1999 data[pos] = (pixel >> 7) & 0xf8;
2000 data[pos+1] = (pixel >> 2) & 0xf8;
2001 data[pos+2] = (pixel << 3) & 0xf8;
2002 } else if (bpp == 16)
2003 {
2004 data[pos] = (pixel >> 8) & 0xf8;
2005 data[pos+1] = (pixel >> 3) & 0xfc;
2006 data[pos+2] = (pixel << 3) & 0xf8;
2007 } else
2008 {
2009 data[pos] = (pixel >> 16) & 0xff;
2010 data[pos+1] = (pixel >> 8) & 0xff;
2011 data[pos+2] = pixel & 0xff;
2012 }
2013
2014 /*
2015 if (gdk_image_mask)
2016 {
2017 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
2018 if (mask_pixel == 0)
2019 {
2020 data[pos] = 16;
2021 data[pos+1] = 16;
2022 data[pos+2] = 16;
2023 }
2024 }
2025 */
2026
2027 pos += 3;
2028 }
2029 }
2030
2031 XDestroyImage( ximage );
2032 /*
2033 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
2034 */
2035 }
2036 #endif
wxWidgets (Impactor)