]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/image.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
backed out improper casts and corrected prototypes for Mac OS X
[wxWidgets.git] / src / common / image.cpp
... / ...
CommitLineData
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#include "wx/filefn.h"
27#include "wx/wfstream.h"
28#include "wx/intl.h"
29#include "wx/module.h"
30
31// For memcpy
32#include <string.h>
33#include <math.h>
34
35#ifdef __SALFORDC__
36 #undef FAR
37#endif
38
39#ifdef __WXMSW__
40 #include "wx/msw/private.h"
41#endif
42
43//-----------------------------------------------------------------------------
44// wxImage
45//-----------------------------------------------------------------------------
46
47class wxImageRefData: public wxObjectRefData
48{
49public:
50 wxImageRefData();
51 ~wxImageRefData();
52
53 int m_width;
54 int m_height;
55 unsigned char *m_data;
56 bool m_hasMask;
57 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
58 bool m_ok;
59 bool m_static;
60 wxPalette m_palette;
61 wxArrayString m_optionNames;
62 wxArrayString m_optionValues;
63};
64
65wxImageRefData::wxImageRefData()
66{
67 m_width = 0;
68 m_height = 0;
69 m_data = (unsigned char*) NULL;
70 m_ok = FALSE;
71 m_maskRed = 0;
72 m_maskGreen = 0;
73 m_maskBlue = 0;
74 m_hasMask = FALSE;
75 m_static = FALSE;
76}
77
78wxImageRefData::~wxImageRefData()
79{
80 if (m_data && !m_static)
81 free( m_data );
82}
83
84wxList wxImage::sm_handlers;
85
86//-----------------------------------------------------------------------------
87
88#define M_IMGDATA ((wxImageRefData *)m_refData)
89
90IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
91
92wxImage::wxImage()
93{
94}
95
96wxImage::wxImage( int width, int height )
97{
98 Create( width, height );
99}
100
101wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
102{
103 Create( width, height, data, static_data );
104}
105
106wxImage::wxImage( const wxString& name, long type )
107{
108 LoadFile( name, type );
109}
110
111wxImage::wxImage( const wxString& name, const wxString& mimetype )
112{
113 LoadFile( name, mimetype );
114}
115
116#if wxUSE_STREAMS
117wxImage::wxImage( wxInputStream& stream, long type )
118{
119 LoadFile( stream, type );
120}
121
122wxImage::wxImage( wxInputStream& stream, const wxString& mimetype )
123{
124 LoadFile( stream, mimetype );
125}
126#endif // wxUSE_STREAMS
127
128wxImage::wxImage( const wxImage& image )
129{
130 Ref(image);
131}
132
133wxImage::wxImage( const wxImage* image )
134{
135 if (image) Ref(*image);
136}
137
138void wxImage::Create( int width, int height )
139{
140 UnRef();
141
142 m_refData = new wxImageRefData();
143
144 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
145 if (M_IMGDATA->m_data)
146 {
147 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
148
149 M_IMGDATA->m_width = width;
150 M_IMGDATA->m_height = height;
151 M_IMGDATA->m_ok = TRUE;
152 }
153 else
154 {
155 UnRef();
156 }
157}
158
159void wxImage::Create( int width, int height, unsigned char* data, bool static_data )
160{
161 UnRef();
162
163 m_refData = new wxImageRefData();
164
165 M_IMGDATA->m_data = data;
166 if (M_IMGDATA->m_data)
167 {
168 M_IMGDATA->m_width = width;
169 M_IMGDATA->m_height = height;
170 M_IMGDATA->m_ok = TRUE;
171 M_IMGDATA->m_static = static_data;
172 }
173 else
174 {
175 UnRef();
176 }
177}
178
179void wxImage::Destroy()
180{
181 UnRef();
182}
183
184wxImage wxImage::Copy() const
185{
186 wxImage image;
187
188 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
189
190 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
191
192 char unsigned *data = image.GetData();
193
194 wxCHECK_MSG( data, image, wxT("unable to create image") );
195
196 if (M_IMGDATA->m_hasMask)
197 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
198
199 memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
200
201 return image;
202}
203
204wxImage wxImage::Scale( int width, int height ) const
205{
206 wxImage image;
207
208 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
209
210 wxCHECK_MSG( (width > 0) && (height > 0), image, wxT("invalid image size") );
211
212 image.Create( width, height );
213
214 char unsigned *data = image.GetData();
215
216 wxCHECK_MSG( data, image, wxT("unable to create image") );
217
218 if (M_IMGDATA->m_hasMask)
219 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
220
221 long old_height = M_IMGDATA->m_height;
222 long old_width = M_IMGDATA->m_width;
223
224 char unsigned *source_data = M_IMGDATA->m_data;
225 char unsigned *target_data = data;
226
227 for (long j = 0; j < height; j++)
228 {
229 long y_offset = (j * old_height / height) * old_width;
230
231 for (long i = 0; i < width; i++)
232 {
233 memcpy( target_data,
234 source_data + 3*(y_offset + ((i * old_width )/ width)),
235 3 );
236 target_data += 3;
237 }
238 }
239
240 return image;
241}
242
243wxImage wxImage::Rotate90( bool clockwise ) const
244{
245 wxImage image;
246
247 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
248
249 image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width );
250
251 char unsigned *data = image.GetData();
252
253 wxCHECK_MSG( data, image, wxT("unable to create image") );
254
255 if (M_IMGDATA->m_hasMask)
256 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
257
258 long height = M_IMGDATA->m_height;
259 long width = M_IMGDATA->m_width;
260
261 char unsigned *source_data = M_IMGDATA->m_data;
262 char unsigned *target_data;
263
264 for (long j = 0; j < height; j++)
265 {
266 for (long i = 0; i < width; i++)
267 {
268 if (clockwise)
269 target_data = data + (((i+1)*height) - j - 1)*3;
270 else
271 target_data = data + ((height*(width-1)) + j - (i*height))*3;
272 memcpy( target_data, source_data, 3 );
273 source_data += 3;
274 }
275 }
276
277 return image;
278}
279
280wxImage wxImage::Mirror( bool horizontally ) const
281{
282 wxImage image;
283
284 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
285
286 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
287
288 char unsigned *data = image.GetData();
289
290 wxCHECK_MSG( data, image, wxT("unable to create image") );
291
292 if (M_IMGDATA->m_hasMask)
293 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
294
295 long height = M_IMGDATA->m_height;
296 long width = M_IMGDATA->m_width;
297
298 char unsigned *source_data = M_IMGDATA->m_data;
299 char unsigned *target_data;
300
301 if (horizontally)
302 {
303 for (long j = 0; j < height; j++)
304 {
305 data += width*3;
306 target_data = data-3;
307 for (long i = 0; i < width; i++)
308 {
309 memcpy( target_data, source_data, 3 );
310 source_data += 3;
311 target_data -= 3;
312 }
313 }
314 }
315 else
316 {
317 for (long i = 0; i < height; i++)
318 {
319 target_data = data + 3*width*(height-1-i);
320 memcpy( target_data, source_data, (size_t)3*width );
321 source_data += 3*width;
322 }
323 }
324
325 return image;
326}
327
328wxImage wxImage::GetSubImage( const wxRect &rect ) const
329{
330 wxImage image;
331
332 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
333
334 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
335 image, wxT("invalid subimage size") );
336
337 int subwidth=rect.GetWidth();
338 const int subheight=rect.GetHeight();
339
340 image.Create( subwidth, subheight );
341
342 char unsigned *subdata = image.GetData(), *data=GetData();
343
344 wxCHECK_MSG( subdata, image, wxT("unable to create image") );
345
346 if (M_IMGDATA->m_hasMask)
347 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
348
349 const int subleft=3*rect.GetLeft();
350 const int width=3*GetWidth();
351 subwidth*=3;
352
353 data+=rect.GetTop()*width+subleft;
354
355 for (long j = 0; j < subheight; ++j)
356 {
357 memcpy( subdata, data, subwidth);
358 subdata+=subwidth;
359 data+=width;
360 }
361
362 return image;
363}
364
365void wxImage::Paste( const wxImage &image, int x, int y )
366{
367 wxCHECK_RET( Ok(), wxT("invalid image") );
368 wxCHECK_RET( image.Ok(), wxT("invalid image") );
369
370 int xx = 0;
371 int yy = 0;
372 int width = image.GetWidth();
373 int height = image.GetHeight();
374
375 if (x < 0)
376 {
377 xx = -x;
378 width += x;
379 }
380 if (y < 0)
381 {
382 yy = -y;
383 height += y;
384 }
385
386 if ((x+xx)+width > M_IMGDATA->m_width)
387 width = M_IMGDATA->m_width - (x+xx);
388 if ((y+yy)+height > M_IMGDATA->m_height)
389 height = M_IMGDATA->m_height - (y+yy);
390
391 if (width < 1) return;
392 if (height < 1) return;
393
394 if ((!HasMask() && !image.HasMask()) ||
395 ((HasMask() && image.HasMask() &&
396 (GetMaskRed()==image.GetMaskRed()) &&
397 (GetMaskGreen()==image.GetMaskGreen()) &&
398 (GetMaskBlue()==image.GetMaskBlue()))))
399 {
400 width *= 3;
401 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
402 int source_step = image.GetWidth()*3;
403
404 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
405 int target_step = M_IMGDATA->m_width*3;
406 for (int j = 0; j < height; j++)
407 {
408 memcpy( target_data, source_data, width );
409 source_data += source_step;
410 target_data += target_step;
411 }
412 return;
413 }
414
415 if (!HasMask() && image.HasMask())
416 {
417 unsigned char r = image.GetMaskRed();
418 unsigned char g = image.GetMaskGreen();
419 unsigned char b = image.GetMaskBlue();
420
421 width *= 3;
422 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
423 int source_step = image.GetWidth()*3;
424
425 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
426 int target_step = M_IMGDATA->m_width*3;
427
428 for (int j = 0; j < height; j++)
429 {
430 for (int i = 0; i < width; i+=3)
431 {
432 if ((source_data[i] != r) &&
433 (source_data[i+1] != g) &&
434 (source_data[i+2] != b))
435 {
436 memcpy( target_data+i, source_data+i, 3 );
437 }
438 }
439 source_data += source_step;
440 target_data += target_step;
441 }
442 }
443}
444
445void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
446 unsigned char r2, unsigned char g2, unsigned char b2 )
447{
448 wxCHECK_RET( Ok(), wxT("invalid image") );
449
450 char unsigned *data = GetData();
451
452 const int w = GetWidth();
453 const int h = GetHeight();
454
455 for (int j = 0; j < h; j++)
456 for (int i = 0; i < w; i++)
457 {
458 if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
459 {
460 data[0] = r2;
461 data[1] = g2;
462 data[2] = b2;
463 }
464 data += 3;
465 }
466}
467
468void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
469{
470 wxCHECK_RET( Ok(), wxT("invalid image") );
471
472 int w = M_IMGDATA->m_width;
473 int h = M_IMGDATA->m_height;
474
475 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );
476
477 long pos = (y * w + x) * 3;
478
479 M_IMGDATA->m_data[ pos ] = r;
480 M_IMGDATA->m_data[ pos+1 ] = g;
481 M_IMGDATA->m_data[ pos+2 ] = b;
482}
483
484unsigned char wxImage::GetRed( int x, int y ) const
485{
486 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
487
488 int w = M_IMGDATA->m_width;
489 int h = M_IMGDATA->m_height;
490
491 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
492
493 long pos = (y * w + x) * 3;
494
495 return M_IMGDATA->m_data[pos];
496}
497
498unsigned char wxImage::GetGreen( int x, int y ) const
499{
500 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
501
502 int w = M_IMGDATA->m_width;
503 int h = M_IMGDATA->m_height;
504
505 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
506
507 long pos = (y * w + x) * 3;
508
509 return M_IMGDATA->m_data[pos+1];
510}
511
512unsigned char wxImage::GetBlue( int x, int y ) const
513{
514 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
515
516 int w = M_IMGDATA->m_width;
517 int h = M_IMGDATA->m_height;
518
519 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
520
521 long pos = (y * w + x) * 3;
522
523 return M_IMGDATA->m_data[pos+2];
524}
525
526bool wxImage::Ok() const
527{
528 // image of 0 width or height can't be considered ok - at least because it
529 // causes crashes in ConvertToBitmap() if we don't catch it in time
530 wxImageRefData *data = M_IMGDATA;
531 return data && data->m_ok && data->m_width && data->m_height;
532}
533
534char unsigned *wxImage::GetData() const
535{
536 wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );
537
538 return M_IMGDATA->m_data;
539}
540
541void wxImage::SetData( char unsigned *data )
542{
543 wxCHECK_RET( Ok(), wxT("invalid image") );
544
545 wxImageRefData *newRefData = new wxImageRefData();
546
547 newRefData->m_width = M_IMGDATA->m_width;
548 newRefData->m_height = M_IMGDATA->m_height;
549 newRefData->m_data = data;
550 newRefData->m_ok = TRUE;
551 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
552 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
553 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
554 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
555
556 UnRef();
557
558 m_refData = newRefData;
559}
560
561void wxImage::SetData( char unsigned *data, int new_width, int new_height )
562{
563 wxImageRefData *newRefData = new wxImageRefData();
564
565 if (m_refData)
566 {
567 newRefData->m_width = new_width;
568 newRefData->m_height = new_height;
569 newRefData->m_data = data;
570 newRefData->m_ok = TRUE;
571 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
572 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
573 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
574 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
575 }
576 else
577 {
578 newRefData->m_width = new_width;
579 newRefData->m_height = new_height;
580 newRefData->m_data = data;
581 newRefData->m_ok = TRUE;
582 }
583
584 UnRef();
585
586 m_refData = newRefData;
587}
588
589void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
590{
591 wxCHECK_RET( Ok(), wxT("invalid image") );
592
593 M_IMGDATA->m_maskRed = r;
594 M_IMGDATA->m_maskGreen = g;
595 M_IMGDATA->m_maskBlue = b;
596 M_IMGDATA->m_hasMask = TRUE;
597}
598
599unsigned char wxImage::GetMaskRed() const
600{
601 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
602
603 return M_IMGDATA->m_maskRed;
604}
605
606unsigned char wxImage::GetMaskGreen() const
607{
608 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
609
610 return M_IMGDATA->m_maskGreen;
611}
612
613unsigned char wxImage::GetMaskBlue() const
614{
615 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
616
617 return M_IMGDATA->m_maskBlue;
618}
619
620void wxImage::SetMask( bool mask )
621{
622 wxCHECK_RET( Ok(), wxT("invalid image") );
623
624 M_IMGDATA->m_hasMask = mask;
625}
626
627bool wxImage::HasMask() const
628{
629 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
630
631 return M_IMGDATA->m_hasMask;
632}
633
634int wxImage::GetWidth() const
635{
636 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
637
638 return M_IMGDATA->m_width;
639}
640
641int wxImage::GetHeight() const
642{
643 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
644
645 return M_IMGDATA->m_height;
646}
647
648// Palette functions
649
650bool wxImage::HasPalette() const
651{
652 if (!Ok())
653 return FALSE;
654
655 return M_IMGDATA->m_palette.Ok();
656}
657
658const wxPalette& wxImage::GetPalette() const
659{
660 wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
661
662 return M_IMGDATA->m_palette;
663}
664
665void wxImage::SetPalette(const wxPalette& palette)
666{
667 wxCHECK_RET( Ok(), wxT("invalid image") );
668
669 M_IMGDATA->m_palette = palette;
670}
671
672// Option functions (arbitrary name/value mapping)
673void wxImage::SetOption(const wxString& name, const wxString& value)
674{
675 wxCHECK_RET( Ok(), wxT("invalid image") );
676
677 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
678 if (idx == wxNOT_FOUND)
679 {
680 M_IMGDATA->m_optionNames.Add(name);
681 M_IMGDATA->m_optionValues.Add(value);
682 }
683 else
684 {
685 M_IMGDATA->m_optionNames[idx] = name;
686 M_IMGDATA->m_optionValues[idx] = value;
687 }
688}
689
690void wxImage::SetOption(const wxString& name, int value)
691{
692 wxString valStr;
693 valStr.Printf(wxT("%d"), value);
694 SetOption(name, valStr);
695}
696
697wxString wxImage::GetOption(const wxString& name) const
698{
699 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
700
701 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
702 if (idx == wxNOT_FOUND)
703 return wxEmptyString;
704 else
705 return M_IMGDATA->m_optionValues[idx];
706}
707
708int wxImage::GetOptionInt(const wxString& name) const
709{
710 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
711
712 return wxAtoi(GetOption(name));
713}
714
715bool wxImage::HasOption(const wxString& name) const
716{
717 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
718
719 return (M_IMGDATA->m_optionNames.Index(name, FALSE) != wxNOT_FOUND);
720}
721
722bool wxImage::LoadFile( const wxString& filename, long type )
723{
724#if wxUSE_STREAMS
725 if (wxFileExists(filename))
726 {
727 wxFileInputStream stream(filename);
728 wxBufferedInputStream bstream( stream );
729 return LoadFile(bstream, type);
730 }
731 else
732 {
733 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
734
735 return FALSE;
736 }
737#else // !wxUSE_STREAMS
738 return FALSE;
739#endif // wxUSE_STREAMS
740}
741
742bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
743{
744#if wxUSE_STREAMS
745 if (wxFileExists(filename))
746 {
747 wxFileInputStream stream(filename);
748 wxBufferedInputStream bstream( stream );
749 return LoadFile(bstream, mimetype);
750 }
751 else
752 {
753 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
754
755 return FALSE;
756 }
757#else // !wxUSE_STREAMS
758 return FALSE;
759#endif // wxUSE_STREAMS
760}
761
762bool wxImage::SaveFile( const wxString& filename, int type )
763{
764#if wxUSE_STREAMS
765 wxFileOutputStream stream(filename);
766
767 if ( stream.LastError() == wxStream_NOERROR )
768 {
769 wxBufferedOutputStream bstream( stream );
770 return SaveFile(bstream, type);
771 }
772#endif // wxUSE_STREAMS
773
774 return FALSE;
775}
776
777bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
778{
779#if wxUSE_STREAMS
780 wxFileOutputStream stream(filename);
781
782 if ( stream.LastError() == wxStream_NOERROR )
783 {
784 wxBufferedOutputStream bstream( stream );
785 return SaveFile(bstream, mimetype);
786 }
787#endif // wxUSE_STREAMS
788
789 return FALSE;
790}
791
792bool wxImage::CanRead( const wxString &name )
793{
794#if wxUSE_STREAMS
795 wxFileInputStream stream(name);
796 return CanRead(stream);
797#else
798 return FALSE;
799#endif
800}
801
802#if wxUSE_STREAMS
803
804bool wxImage::CanRead( wxInputStream &stream )
805{
806 wxList &list=GetHandlers();
807
808 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
809 {
810 wxImageHandler *handler=(wxImageHandler*)node->GetData();
811 if (handler->CanRead( stream ))
812 return TRUE;
813 }
814
815 return FALSE;
816}
817
818bool wxImage::LoadFile( wxInputStream& stream, long type )
819{
820 UnRef();
821
822 m_refData = new wxImageRefData;
823
824 wxImageHandler *handler;
825
826 if (type==wxBITMAP_TYPE_ANY)
827 {
828 wxList &list=GetHandlers();
829
830 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
831 {
832 handler=(wxImageHandler*)node->GetData();
833 if (handler->CanRead( stream ))
834 return handler->LoadFile( this, stream );
835
836 }
837
838 wxLogWarning( _("No handler found for image type.") );
839 return FALSE;
840 }
841
842 handler = FindHandler(type);
843
844 if (handler == NULL)
845 {
846 wxLogWarning( _("No image handler for type %d defined."), type );
847
848 return FALSE;
849 }
850
851 return handler->LoadFile( this, stream );
852}
853
854bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
855{
856 UnRef();
857
858 m_refData = new wxImageRefData;
859
860 wxImageHandler *handler = FindHandlerMime(mimetype);
861
862 if (handler == NULL)
863 {
864 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
865
866 return FALSE;
867 }
868
869 return handler->LoadFile( this, stream );
870}
871
872bool wxImage::SaveFile( wxOutputStream& stream, int type )
873{
874 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
875
876 wxImageHandler *handler = FindHandler(type);
877
878 if (handler == NULL)
879 {
880 wxLogWarning( _("No image handler for type %d defined."), type );
881
882 return FALSE;
883 }
884
885 return handler->SaveFile( this, stream );
886}
887
888bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
889{
890 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
891
892 wxImageHandler *handler = FindHandlerMime(mimetype);
893
894 if (handler == NULL)
895 {
896 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
897
898 return FALSE;
899 }
900
901 return handler->SaveFile( this, stream );
902}
903#endif // wxUSE_STREAMS
904
905void wxImage::AddHandler( wxImageHandler *handler )
906{
907 // make sure that the memory will be freed at the program end
908 sm_handlers.DeleteContents(TRUE);
909
910 sm_handlers.Append( handler );
911}
912
913void wxImage::InsertHandler( wxImageHandler *handler )
914{
915 // make sure that the memory will be freed at the program end
916 sm_handlers.DeleteContents(TRUE);
917
918 sm_handlers.Insert( handler );
919}
920
921bool wxImage::RemoveHandler( const wxString& name )
922{
923 wxImageHandler *handler = FindHandler(name);
924 if (handler)
925 {
926 sm_handlers.DeleteObject(handler);
927 return TRUE;
928 }
929 else
930 return FALSE;
931}
932
933wxImageHandler *wxImage::FindHandler( const wxString& name )
934{
935 wxNode *node = sm_handlers.First();
936 while (node)
937 {
938 wxImageHandler *handler = (wxImageHandler*)node->Data();
939 if (handler->GetName().Cmp(name) == 0) return handler;
940
941 node = node->Next();
942 }
943 return (wxImageHandler *)NULL;
944}
945
946wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
947{
948 wxNode *node = sm_handlers.First();
949 while (node)
950 {
951 wxImageHandler *handler = (wxImageHandler*)node->Data();
952 if ( (handler->GetExtension().Cmp(extension) == 0) &&
953 (bitmapType == -1 || handler->GetType() == bitmapType) )
954 return handler;
955 node = node->Next();
956 }
957 return (wxImageHandler*)NULL;
958}
959
960wxImageHandler *wxImage::FindHandler( long bitmapType )
961{
962 wxNode *node = sm_handlers.First();
963 while (node)
964 {
965 wxImageHandler *handler = (wxImageHandler *)node->Data();
966 if (handler->GetType() == bitmapType) return handler;
967 node = node->Next();
968 }
969 return NULL;
970}
971
972wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
973{
974 wxNode *node = sm_handlers.First();
975 while (node)
976 {
977 wxImageHandler *handler = (wxImageHandler *)node->Data();
978 if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
979 node = node->Next();
980 }
981 return NULL;
982}
983
984void wxImage::InitStandardHandlers()
985{
986 AddHandler( new wxBMPHandler );
987}
988
989void wxImage::CleanUpHandlers()
990{
991 wxNode *node = sm_handlers.First();
992 while (node)
993 {
994 wxImageHandler *handler = (wxImageHandler *)node->Data();
995 wxNode *next = node->Next();
996 delete handler;
997 delete node;
998 node = next;
999 }
1000}
1001
1002//-----------------------------------------------------------------------------
1003// wxImageHandler
1004//-----------------------------------------------------------------------------
1005
1006IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
1007
1008#if wxUSE_STREAMS
1009bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
1010{
1011 return FALSE;
1012}
1013
1014bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
1015{
1016 return FALSE;
1017}
1018
1019int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
1020{
1021 return 1;
1022}
1023
1024bool wxImageHandler::CanRead( const wxString& name )
1025{
1026 if (wxFileExists(name))
1027 {
1028 wxFileInputStream stream(name);
1029 return CanRead(stream);
1030 }
1031
1032 else {
1033 wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
1034
1035 return FALSE;
1036 }
1037// return FALSE;
1038}
1039
1040#endif // wxUSE_STREAMS
1041
1042//-----------------------------------------------------------------------------
1043// MSW conversion routines
1044//-----------------------------------------------------------------------------
1045
1046#ifdef __WXMSW__
1047
1048wxBitmap wxImage::ConvertToBitmap() const
1049{
1050 if ( !Ok() )
1051 return wxNullBitmap;
1052
1053 // sizeLimit is the MS upper limit for the DIB size
1054#ifdef WIN32
1055 int sizeLimit = 1024*768*3;
1056#else
1057 int sizeLimit = 0x7fff ;
1058#endif
1059
1060 // width and height of the device-dependent bitmap
1061 int width = GetWidth();
1062 int bmpHeight = GetHeight();
1063
1064 // calc the number of bytes per scanline and padding
1065 int bytePerLine = width*3;
1066 int sizeDWORD = sizeof( DWORD );
1067 int lineBoundary = bytePerLine % sizeDWORD;
1068 int padding = 0;
1069 if( lineBoundary > 0 )
1070 {
1071 padding = sizeDWORD - lineBoundary;
1072 bytePerLine += padding;
1073 }
1074 // calc the number of DIBs and heights of DIBs
1075 int numDIB = 1;
1076 int hRemain = 0;
1077 int height = sizeLimit/bytePerLine;
1078 if( height >= bmpHeight )
1079 height = bmpHeight;
1080 else
1081 {
1082 numDIB = bmpHeight / height;
1083 hRemain = bmpHeight % height;
1084 if( hRemain >0 ) numDIB++;
1085 }
1086
1087 // set bitmap parameters
1088 wxBitmap bitmap;
1089 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1090 bitmap.SetWidth( width );
1091 bitmap.SetHeight( bmpHeight );
1092 bitmap.SetDepth( wxDisplayDepth() );
1093
1094 // create a DIB header
1095 int headersize = sizeof(BITMAPINFOHEADER);
1096 BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
1097 wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
1098 // Fill in the DIB header
1099 lpDIBh->bmiHeader.biSize = headersize;
1100 lpDIBh->bmiHeader.biWidth = (DWORD)width;
1101 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1102 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1103 // the general formula for biSizeImage:
1104 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
1105 lpDIBh->bmiHeader.biPlanes = 1;
1106 lpDIBh->bmiHeader.biBitCount = 24;
1107 lpDIBh->bmiHeader.biCompression = BI_RGB;
1108 lpDIBh->bmiHeader.biClrUsed = 0;
1109 // These seem not really needed for our purpose here.
1110 lpDIBh->bmiHeader.biClrImportant = 0;
1111 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1112 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1113 // memory for DIB data
1114 unsigned char *lpBits;
1115 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
1116 if( !lpBits )
1117 {
1118 wxFAIL_MSG( wxT("could not allocate memory for DIB") );
1119 free( lpDIBh );
1120 return bitmap;
1121 }
1122
1123 // create and set the device-dependent bitmap
1124 HDC hdc = ::GetDC(NULL);
1125 HDC memdc = ::CreateCompatibleDC( hdc );
1126 HBITMAP hbitmap;
1127 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
1128 ::SelectObject( memdc, hbitmap);
1129
1130 HPALETTE hOldPalette = 0;
1131 if (GetPalette().Ok())
1132 {
1133 hOldPalette = ::SelectPalette(memdc, (HPALETTE) GetPalette().GetHPALETTE(), FALSE);
1134 ::RealizePalette(memdc);
1135 }
1136
1137 // copy image data into DIB data and then into DDB (in a loop)
1138 unsigned char *data = GetData();
1139 int i, j, n;
1140 int origin = 0;
1141 unsigned char *ptdata = data;
1142 unsigned char *ptbits;
1143
1144 for( n=0; n<numDIB; n++ )
1145 {
1146 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
1147 {
1148 // redefine height and size of the (possibly) last smaller DIB
1149 // memory is not reallocated
1150 height = hRemain;
1151 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1152 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1153 }
1154 ptbits = lpBits;
1155
1156 for( j=0; j<height; j++ )
1157 {
1158 for( i=0; i<width; i++ )
1159 {
1160 *(ptbits++) = *(ptdata+2);
1161 *(ptbits++) = *(ptdata+1);
1162 *(ptbits++) = *(ptdata );
1163 ptdata += 3;
1164 }
1165 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
1166 }
1167 ::StretchDIBits( memdc, 0, origin, width, height,\
1168 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1169 origin += height;
1170 // if numDIB = 1, lines below can also be used
1171 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
1172 // The above line is equivalent to the following two lines.
1173 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1174 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
1175 // or the following lines
1176 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
1177 // HDC memdc = ::CreateCompatibleDC( hdc );
1178 // ::SelectObject( memdc, hbitmap);
1179 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
1180 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
1181 // ::SelectObject( memdc, 0 );
1182 // ::DeleteDC( memdc );
1183 }
1184 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
1185
1186 if (hOldPalette)
1187 SelectPalette(memdc, hOldPalette, FALSE);
1188
1189 // similarly, created an mono-bitmap for the possible mask
1190 if( HasMask() )
1191 {
1192 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
1193 HGDIOBJ hbmpOld = ::SelectObject( memdc, hbitmap);
1194 if( numDIB == 1 ) height = bmpHeight;
1195 else height = sizeLimit/bytePerLine;
1196 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1197 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1198 origin = 0;
1199 unsigned char r = GetMaskRed();
1200 unsigned char g = GetMaskGreen();
1201 unsigned char b = GetMaskBlue();
1202 unsigned char zero = 0, one = 255;
1203 ptdata = data;
1204 for( n=0; n<numDIB; n++ )
1205 {
1206 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
1207 {
1208 // redefine height and size of the (possibly) last smaller DIB
1209 // memory is not reallocated
1210 height = hRemain;
1211 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
1212 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
1213 }
1214 ptbits = lpBits;
1215 for( int j=0; j<height; j++ )
1216 {
1217 for(i=0; i<width; i++ )
1218 {
1219 // was causing a code gen bug in cw : if( ( cr !=r) || (cg!=g) || (cb!=b) )
1220 unsigned char cr = (*(ptdata++)) ;
1221 unsigned char cg = (*(ptdata++)) ;
1222 unsigned char cb = (*(ptdata++)) ;
1223
1224 if( ( cr !=r) || (cg!=g) || (cb!=b) )
1225 {
1226 *(ptbits++) = one;
1227 *(ptbits++) = one;
1228 *(ptbits++) = one;
1229 }
1230 else
1231 {
1232 *(ptbits++) = zero;
1233 *(ptbits++) = zero;
1234 *(ptbits++) = zero;
1235 }
1236 }
1237 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
1238 }
1239 ::StretchDIBits( memdc, 0, origin, width, height,\
1240 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
1241 origin += height;
1242 }
1243 // create a wxMask object
1244 wxMask *mask = new wxMask();
1245 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
1246 bitmap.SetMask( mask );
1247 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
1248 /* The following can also be used but is slow to run
1249 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1250 wxMask *mask = new wxMask( bitmap, colour );
1251 bitmap.SetMask( mask );
1252 */
1253
1254 ::SelectObject( memdc, hbmpOld );
1255 }
1256
1257 // free allocated resources
1258 ::DeleteDC( memdc );
1259 ::ReleaseDC(NULL, hdc);
1260 free(lpDIBh);
1261 free(lpBits);
1262
1263#if WXWIN_COMPATIBILITY_2
1264 // check the wxBitmap object
1265 bitmap.GetBitmapData()->SetOk();
1266#endif // WXWIN_COMPATIBILITY_2
1267
1268 return bitmap;
1269}
1270
1271wxImage::wxImage( const wxBitmap &bitmap )
1272{
1273 // check the bitmap
1274 if( !bitmap.Ok() )
1275 {
1276 wxFAIL_MSG( wxT("invalid bitmap") );
1277 return;
1278 }
1279
1280 // create an wxImage object
1281 int width = bitmap.GetWidth();
1282 int height = bitmap.GetHeight();
1283 Create( width, height );
1284 unsigned char *data = GetData();
1285 if( !data )
1286 {
1287 wxFAIL_MSG( wxT("could not allocate data for image") );
1288 return;
1289 }
1290
1291 // calc the number of bytes per scanline and padding in the DIB
1292 int bytePerLine = width*3;
1293 int sizeDWORD = sizeof( DWORD );
1294 int lineBoundary = bytePerLine % sizeDWORD;
1295 int padding = 0;
1296 if( lineBoundary > 0 )
1297 {
1298 padding = sizeDWORD - lineBoundary;
1299 bytePerLine += padding;
1300 }
1301
1302 // create a DIB header
1303 int headersize = sizeof(BITMAPINFOHEADER);
1304 BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
1305 if( !lpDIBh )
1306 {
1307 wxFAIL_MSG( wxT("could not allocate data for DIB header") );
1308 free( data );
1309 return;
1310 }
1311 // Fill in the DIB header
1312 lpDIBh->bmiHeader.biSize = headersize;
1313 lpDIBh->bmiHeader.biWidth = width;
1314 lpDIBh->bmiHeader.biHeight = -height;
1315 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
1316 lpDIBh->bmiHeader.biPlanes = 1;
1317 lpDIBh->bmiHeader.biBitCount = 24;
1318 lpDIBh->bmiHeader.biCompression = BI_RGB;
1319 lpDIBh->bmiHeader.biClrUsed = 0;
1320 // These seem not really needed for our purpose here.
1321 lpDIBh->bmiHeader.biClrImportant = 0;
1322 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
1323 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
1324 // memory for DIB data
1325 unsigned char *lpBits;
1326 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
1327 if( !lpBits )
1328 {
1329 wxFAIL_MSG( wxT("could not allocate data for DIB") );
1330 free( data );
1331 free( lpDIBh );
1332 return;
1333 }
1334
1335 // copy data from the device-dependent bitmap to the DIB
1336 HDC hdc = ::GetDC(NULL);
1337 HBITMAP hbitmap;
1338 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
1339 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1340
1341 // copy DIB data into the wxImage object
1342 int i, j;
1343 unsigned char *ptdata = data;
1344 unsigned char *ptbits = lpBits;
1345 for( i=0; i<height; i++ )
1346 {
1347 for( j=0; j<width; j++ )
1348 {
1349 *(ptdata++) = *(ptbits+2);
1350 *(ptdata++) = *(ptbits+1);
1351 *(ptdata++) = *(ptbits );
1352 ptbits += 3;
1353 }
1354 ptbits += padding;
1355 }
1356
1357 // similarly, set data according to the possible mask bitmap
1358 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
1359 {
1360 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
1361 // memory DC created, color set, data copied, and memory DC deleted
1362 HDC memdc = ::CreateCompatibleDC( hdc );
1363 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
1364 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1365 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1366 ::DeleteDC( memdc );
1367 // background color set to RGB(16,16,16) in consistent with wxGTK
1368 unsigned char r=16, g=16, b=16;
1369 ptdata = data;
1370 ptbits = lpBits;
1371 for( i=0; i<height; i++ )
1372 {
1373 for( j=0; j<width; j++ )
1374 {
1375 if( *ptbits != 0 )
1376 ptdata += 3;
1377 else
1378 {
1379 *(ptdata++) = r;
1380 *(ptdata++) = g;
1381 *(ptdata++) = b;
1382 }
1383 ptbits += 3;
1384 }
1385 ptbits += padding;
1386 }
1387 SetMaskColour( r, g, b );
1388 SetMask( TRUE );
1389 }
1390 else
1391 {
1392 SetMask( FALSE );
1393 }
1394 // free allocated resources
1395 ::ReleaseDC(NULL, hdc);
1396 free(lpDIBh);
1397 free(lpBits);
1398}
1399
1400#endif
1401
1402#ifdef __WXMAC__
1403
1404#ifdef __UNIX__
1405 #include <ApplicationServices/ApplicationServices.h>
1406#else
1407 #include <PictUtils.h>
1408#endif
1409
1410wxBitmap wxImage::ConvertToBitmap() const
1411{
1412 // width and height of the device-dependent bitmap
1413 int width = GetWidth();
1414 int height = GetHeight();
1415
1416 // Create picture
1417
1418 wxBitmap bitmap;
1419
1420 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1421
1422 bitmap.Create( width , height , wxDisplayDepth() ) ;
1423 wxBitmap maskBitmap( width, height, 1);
1424
1425 CGrafPtr origPort ;
1426 GDHandle origDevice ;
1427
1428 LockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) );
1429 LockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) );
1430
1431 GetGWorld( &origPort , &origDevice ) ;
1432 SetGWorld( bitmap.GetHBITMAP() , NULL ) ;
1433
1434 // Render image
1435 wxColour rgb, maskcolor(GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1436 RGBColor color;
1437 RGBColor white = { 0xffff, 0xffff, 0xffff };
1438 RGBColor black = { 0 , 0 , 0 };
1439
1440 register unsigned char* data = GetData();
1441
1442 int index = 0;
1443 for (int y = 0; y < height; y++)
1444 {
1445 for (int x = 0; x < width; x++)
1446 {
1447 rgb.Set(data[index++], data[index++], data[index++]);
1448 color = rgb.GetPixel();
1449 SetCPixel( x , y , &color ) ;
1450 if (HasMask())
1451 {
1452 SetGWorld(maskBitmap.GetHBITMAP(), NULL);
1453 if (rgb == maskcolor) {
1454 SetCPixel(x,y, &white);
1455 }
1456 else {
1457 SetCPixel(x,y, &black);
1458 }
1459 SetGWorld(bitmap.GetHBITMAP(), NULL);
1460 }
1461 }
1462 } // for height
1463
1464 // Create mask
1465 if ( HasMask() ) {
1466 wxMask *mask = new wxMask( maskBitmap );
1467 }
1468
1469 UnlockPixels( GetGWorldPixMap(bitmap.GetHBITMAP()) );
1470 UnlockPixels( GetGWorldPixMap(maskBitmap.GetHBITMAP()) );
1471 SetGWorld( origPort, origDevice );
1472
1473 return bitmap;
1474}
1475
1476wxImage::wxImage( const wxBitmap &bitmap )
1477{
1478 // check the bitmap
1479 wxCHECK_RET( bitmap.Ok(), wxT("Invalid bitmap") );
1480
1481 // create an wxImage object
1482 int width = bitmap.GetWidth();
1483 int height = bitmap.GetHeight();
1484 Create( width, height );
1485
1486 unsigned char *data = GetData();
1487
1488 wxCHECK_RET( data, wxT("Could not allocate data for image") );
1489
1490 WXHBITMAP origPort;
1491 GDHandle origDevice;
1492 int index;
1493 RGBColor color;
1494 // background color set to RGB(16,16,16) in consistent with wxGTK
1495 unsigned char mask_r=16, mask_g=16, mask_b=16;
1496 SInt16 r,g,b;
1497 wxMask *mask = bitmap.GetMask();
1498
1499 GetGWorld( &origPort, &origDevice );
1500 LockPixels(GetGWorldPixMap(bitmap.GetHBITMAP()));
1501 SetGWorld( bitmap.GetHBITMAP(), NULL);
1502
1503 // Copy data into image
1504 index = 0;
1505 for (int yy = 0; yy < height; yy++)
1506 {
1507 for (int xx = 0; xx < width; xx++)
1508 {
1509 GetCPixel(xx,yy, &color);
1510 r = ((color.red ) >> 8);
1511 g = ((color.green ) >> 8);
1512 b = ((color.blue ) >> 8);
1513 data[index ] = r;
1514 data[index + 1] = g;
1515 data[index + 2] = b;
1516 if (mask)
1517 {
1518 if (mask->PointMasked(xx,yy))
1519 {
1520 data[index ] = mask_r;
1521 data[index + 1] = mask_g;
1522 data[index + 2] = mask_b;
1523 }
1524 }
1525 index += 3;
1526 }
1527 }
1528 if (mask)
1529 {
1530 SetMaskColour( mask_r, mask_g, mask_b );
1531 SetMask( true );
1532 }
1533
1534 // Free resources
1535 UnlockPixels(GetGWorldPixMap(bitmap.GetHBITMAP()));
1536 SetGWorld(origPort, origDevice);
1537}
1538
1539#endif
1540
1541//-----------------------------------------------------------------------------
1542// GTK conversion routines
1543//-----------------------------------------------------------------------------
1544
1545#ifdef __WXGTK__
1546
1547#include <gtk/gtk.h>
1548#include <gdk/gdk.h>
1549#include <gdk/gdkx.h>
1550
1551#if (GTK_MINOR_VERSION > 0)
1552#include <gdk/gdkrgb.h>
1553#endif
1554
1555extern GtkWidget *wxRootWindow;
1556
1557wxBitmap wxImage::ConvertToMonoBitmap( unsigned char red, unsigned char green, unsigned char blue )
1558{
1559 wxBitmap bitmap;
1560
1561 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1562
1563 int width = GetWidth();
1564 int height = GetHeight();
1565
1566 bitmap.SetHeight( height );
1567 bitmap.SetWidth( width );
1568
1569 bitmap.SetBitmap( gdk_pixmap_new( wxRootWindow->window, width, height, 1 ) );
1570
1571 bitmap.SetDepth( 1 );
1572
1573 GdkVisual *visual = gdk_window_get_visual( wxRootWindow->window );
1574 wxASSERT( visual );
1575
1576 // Create picture image
1577
1578 unsigned char *data_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1579
1580 GdkImage *data_image =
1581 gdk_image_new_bitmap( visual, data_data, width, height );
1582
1583 // Create mask image
1584
1585 GdkImage *mask_image = (GdkImage*) NULL;
1586
1587 if (HasMask())
1588 {
1589 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1590
1591 mask_image = gdk_image_new_bitmap( visual, mask_data, width, height );
1592
1593 wxMask *mask = new wxMask();
1594 mask->m_bitmap = gdk_pixmap_new( wxRootWindow->window, width, height, 1 );
1595
1596 bitmap.SetMask( mask );
1597 }
1598
1599 int r_mask = GetMaskRed();
1600 int g_mask = GetMaskGreen();
1601 int b_mask = GetMaskBlue();
1602
1603 unsigned char* data = GetData();
1604
1605 int index = 0;
1606 for (int y = 0; y < height; y++)
1607 {
1608 for (int x = 0; x < width; x++)
1609 {
1610 int r = data[index];
1611 index++;
1612 int g = data[index];
1613 index++;
1614 int b = data[index];
1615 index++;
1616
1617 if (HasMask())
1618 {
1619 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1620 gdk_image_put_pixel( mask_image, x, y, 1 );
1621 else
1622 gdk_image_put_pixel( mask_image, x, y, 0 );
1623 }
1624
1625 if ((r == red) && (b == blue) && (g == green))
1626 gdk_image_put_pixel( data_image, x, y, 1 );
1627 else
1628 gdk_image_put_pixel( data_image, x, y, 0 );
1629
1630 } // for
1631 } // for
1632
1633 // Blit picture
1634
1635 GdkGC *data_gc = gdk_gc_new( bitmap.GetBitmap() );
1636
1637 gdk_draw_image( bitmap.GetBitmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1638
1639 gdk_image_destroy( data_image );
1640 gdk_gc_unref( data_gc );
1641
1642 // Blit mask
1643
1644 if (HasMask())
1645 {
1646 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1647
1648 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1649
1650 gdk_image_destroy( mask_image );
1651 gdk_gc_unref( mask_gc );
1652 }
1653
1654 return bitmap;
1655}
1656
1657
1658wxBitmap wxImage::ConvertToBitmap() const
1659{
1660 wxBitmap bitmap;
1661
1662 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
1663
1664 int width = GetWidth();
1665 int height = GetHeight();
1666
1667 bitmap.SetHeight( height );
1668 bitmap.SetWidth( width );
1669
1670 bitmap.SetPixmap( gdk_pixmap_new( wxRootWindow->window, width, height, -1 ) );
1671
1672 // Retrieve depth
1673
1674 GdkVisual *visual = gdk_window_get_visual( wxRootWindow->window );
1675 wxASSERT( visual );
1676
1677 int bpp = visual->depth;
1678
1679 bitmap.SetDepth( bpp );
1680
1681 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1682 if (bpp < 8) bpp = 8;
1683
1684#if (GTK_MINOR_VERSION > 0)
1685
1686 if (!HasMask() && (bpp > 8))
1687 {
1688 static bool s_hasInitialized = FALSE;
1689
1690 if (!s_hasInitialized)
1691 {
1692 gdk_rgb_init();
1693 s_hasInitialized = TRUE;
1694 }
1695
1696 GdkGC *gc = gdk_gc_new( bitmap.GetPixmap() );
1697
1698 gdk_draw_rgb_image( bitmap.GetPixmap(),
1699 gc,
1700 0, 0,
1701 width, height,
1702 GDK_RGB_DITHER_NONE,
1703 GetData(),
1704 width*3 );
1705
1706 gdk_gc_unref( gc );
1707
1708 return bitmap;
1709 }
1710
1711#endif
1712
1713 // Create picture image
1714
1715 GdkImage *data_image =
1716 gdk_image_new( GDK_IMAGE_FASTEST, visual, width, height );
1717
1718 // Create mask image
1719
1720 GdkImage *mask_image = (GdkImage*) NULL;
1721
1722 if (HasMask())
1723 {
1724 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1725
1726 mask_image = gdk_image_new_bitmap( visual, mask_data, width, height );
1727
1728 wxMask *mask = new wxMask();
1729 mask->m_bitmap = gdk_pixmap_new( wxRootWindow->window, width, height, 1 );
1730
1731 bitmap.SetMask( mask );
1732 }
1733
1734 // Render
1735
1736 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1737 byte_order b_o = RGB;
1738
1739 if (bpp >= 24)
1740 {
1741 if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask)) b_o = RGB;
1742 else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask)) b_o = RGB;
1743 else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask)) b_o = BRG;
1744 else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1745 else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask)) b_o = GRB;
1746 else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask)) b_o = GBR;
1747 }
1748
1749 int r_mask = GetMaskRed();
1750 int g_mask = GetMaskGreen();
1751 int b_mask = GetMaskBlue();
1752
1753 unsigned char* data = GetData();
1754
1755 int index = 0;
1756 for (int y = 0; y < height; y++)
1757 {
1758 for (int x = 0; x < width; x++)
1759 {
1760 int r = data[index];
1761 index++;
1762 int g = data[index];
1763 index++;
1764 int b = data[index];
1765 index++;
1766
1767 if (HasMask())
1768 {
1769 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1770 gdk_image_put_pixel( mask_image, x, y, 1 );
1771 else
1772 gdk_image_put_pixel( mask_image, x, y, 0 );
1773 }
1774
1775 switch (bpp)
1776 {
1777 case 8:
1778 {
1779 int pixel = -1;
1780 if (wxTheApp->m_colorCube)
1781 {
1782 pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1783 }
1784 else
1785 {
1786 GdkColormap *cmap = gtk_widget_get_default_colormap();
1787 GdkColor *colors = cmap->colors;
1788 int max = 3 * (65536);
1789
1790 for (int i = 0; i < cmap->size; i++)
1791 {
1792 int rdiff = (r << 8) - colors[i].red;
1793 int gdiff = (g << 8) - colors[i].green;
1794 int bdiff = (b << 8) - colors[i].blue;
1795 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1796 if (sum < max) { pixel = i; max = sum; }
1797 }
1798 }
1799
1800 gdk_image_put_pixel( data_image, x, y, pixel );
1801
1802 break;
1803 }
1804 case 15:
1805 {
1806 guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1807 gdk_image_put_pixel( data_image, x, y, pixel );
1808 break;
1809 }
1810 case 16:
1811 {
1812 guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1813 gdk_image_put_pixel( data_image, x, y, pixel );
1814 break;
1815 }
1816 case 32:
1817 case 24:
1818 {
1819 guint32 pixel = 0;
1820 switch (b_o)
1821 {
1822 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1823 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1824 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1825 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1826 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1827 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1828 }
1829 gdk_image_put_pixel( data_image, x, y, pixel );
1830 }
1831 default: break;
1832 }
1833 } // for
1834 } // for
1835
1836 // Blit picture
1837
1838 GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1839
1840 gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1841
1842 gdk_image_destroy( data_image );
1843 gdk_gc_unref( data_gc );
1844
1845 // Blit mask
1846
1847 if (HasMask())
1848 {
1849 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1850
1851 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1852
1853 gdk_image_destroy( mask_image );
1854 gdk_gc_unref( mask_gc );
1855 }
1856
1857 return bitmap;
1858}
1859
1860wxImage::wxImage( const wxBitmap &bitmap )
1861{
1862 wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
1863
1864 GdkImage *gdk_image = (GdkImage*) NULL;
1865 if (bitmap.GetPixmap())
1866 {
1867 gdk_image = gdk_image_get( bitmap.GetPixmap(),
1868 0, 0,
1869 bitmap.GetWidth(), bitmap.GetHeight() );
1870 } else
1871 if (bitmap.GetBitmap())
1872 {
1873 gdk_image = gdk_image_get( bitmap.GetBitmap(),
1874 0, 0,
1875 bitmap.GetWidth(), bitmap.GetHeight() );
1876 } else
1877 {
1878 wxFAIL_MSG( wxT("Ill-formed bitmap") );
1879 }
1880
1881 wxCHECK_RET( gdk_image, wxT("couldn't create image") );
1882
1883 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1884 char unsigned *data = GetData();
1885
1886 if (!data)
1887 {
1888 gdk_image_destroy( gdk_image );
1889 wxFAIL_MSG( wxT("couldn't create image") );
1890 return;
1891 }
1892
1893 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1894 if (bitmap.GetMask())
1895 {
1896 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1897 0, 0,
1898 bitmap.GetWidth(), bitmap.GetHeight() );
1899
1900 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1901 }
1902
1903 int bpp = -1;
1904 int red_shift_right = 0;
1905 int green_shift_right = 0;
1906 int blue_shift_right = 0;
1907 int red_shift_left = 0;
1908 int green_shift_left = 0;
1909 int blue_shift_left = 0;
1910 bool use_shift = FALSE;
1911
1912 if (bitmap.GetPixmap())
1913 {
1914 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1915
1916 if (visual == NULL) visual = gdk_window_get_visual( wxRootWindow->window );
1917 bpp = visual->depth;
1918 if (bpp == 16) bpp = visual->red_prec + visual->green_prec + visual->blue_prec;
1919 red_shift_right = visual->red_shift;
1920 red_shift_left = 8-visual->red_prec;
1921 green_shift_right = visual->green_shift;
1922 green_shift_left = 8-visual->green_prec;
1923 blue_shift_right = visual->blue_shift;
1924 blue_shift_left = 8-visual->blue_prec;
1925
1926 use_shift = (visual->type == GDK_VISUAL_TRUE_COLOR) || (visual->type == GDK_VISUAL_DIRECT_COLOR);
1927 }
1928 if (bitmap.GetBitmap())
1929 {
1930 bpp = 1;
1931 }
1932
1933
1934 GdkColormap *cmap = gtk_widget_get_default_colormap();
1935
1936 long pos = 0;
1937 for (int j = 0; j < bitmap.GetHeight(); j++)
1938 {
1939 for (int i = 0; i < bitmap.GetWidth(); i++)
1940 {
1941 wxUint32 pixel = gdk_image_get_pixel( gdk_image, i, j );
1942 if (bpp == 1)
1943 {
1944 if (pixel == 0)
1945 {
1946 data[pos] = 0;
1947 data[pos+1] = 0;
1948 data[pos+2] = 0;
1949 }
1950 else
1951 {
1952 data[pos] = 255;
1953 data[pos+1] = 255;
1954 data[pos+2] = 255;
1955 }
1956 }
1957 else if (use_shift)
1958 {
1959 data[pos] = (pixel >> red_shift_right) << red_shift_left;
1960 data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
1961 data[pos+2] = (pixel >> blue_shift_right) << blue_shift_left;
1962 }
1963 else if (cmap->colors)
1964 {
1965 data[pos] = cmap->colors[pixel].red >> 8;
1966 data[pos+1] = cmap->colors[pixel].green >> 8;
1967 data[pos+2] = cmap->colors[pixel].blue >> 8;
1968 }
1969 else
1970 {
1971 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
1972 }
1973
1974 if (gdk_image_mask)
1975 {
1976 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1977 if (mask_pixel == 0)
1978 {
1979 data[pos] = 16;
1980 data[pos+1] = 16;
1981 data[pos+2] = 16;
1982 }
1983 }
1984
1985 pos += 3;
1986 }
1987 }
1988
1989 gdk_image_destroy( gdk_image );
1990 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1991}
1992
1993#endif
1994
1995//-----------------------------------------------------------------------------
1996// Motif conversion routines
1997//-----------------------------------------------------------------------------
1998
1999#ifdef __WXMOTIF__
2000#ifdef __VMS__
2001#pragma message disable nosimpint
2002#endif
2003#include <Xm/Xm.h>
2004#ifdef __VMS__
2005#pragma message enable nosimpint
2006#endif
2007#include "wx/utils.h"
2008#include <math.h>
2009
2010/*
2011
2012Date: Wed, 05 Jan 2000 11:45:40 +0100
2013From: Frits Boel <boel@niob.knaw.nl>
2014To: julian.smart@ukonline.co.uk
2015Subject: Patch for Motif ConvertToBitmap
2016
2017Hi Julian,
2018
2019I've been working on a wxWin application for image processing. From the
2020beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
2021till I looked in the source code of image.cpp. I saw that converting a
2022wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
2023to the 256 colors of the palet. A very time-consuming piece of code!
2024
2025Because I wanted a faster application, I've made a 'patch' for this. In
2026short: every pixel of the image is compared to a sorted list with
2027colors. If the color is found in the list, the palette entry is
2028returned; if the color is not found, the color palette is searched and
2029then the palette entry is returned and the color added to the sorted
2030list.
2031
2032Maybe there is another method for this, namely changing the palette
2033itself (if the colors are known, as is the case with tiffs with a
2034colormap). I did not look at this, maybe someone else did?
2035
2036The code of the patch is attached, have a look on it, and maybe you will
2037ship it with the next release of wxMotif?
2038
2039Regards,
2040
2041Frits Boel
2042Software engineer at Hubrecht Laboratory, The Netherlands.
2043
2044*/
2045
2046class wxSearchColor
2047{
2048public:
2049 wxSearchColor( void );
2050 wxSearchColor( int size, XColor *colors );
2051 ~wxSearchColor( void );
2052
2053 int SearchColor( int r, int g, int b );
2054private:
2055 int AddColor( unsigned int value, int pos );
2056
2057 int size;
2058 XColor *colors;
2059 unsigned int *color;
2060 int *entry;
2061
2062 int bottom;
2063 int top;
2064};
2065
2066wxSearchColor::wxSearchColor( void )
2067{
2068 size = 0;
2069 colors = (XColor*) NULL;
2070 color = (unsigned int *) NULL;
2071 entry = (int*) NULL;
2072
2073 bottom = 0;
2074 top = 0;
2075}
2076
2077wxSearchColor::wxSearchColor( int size_, XColor *colors_ )
2078{
2079 int i;
2080 size = size_;
2081 colors = colors_;
2082 color = new unsigned int[size];
2083 entry = new int [size];
2084
2085 for (i = 0; i < size; i++ ) {
2086 entry[i] = -1;
2087 }
2088
2089 bottom = top = ( size >> 1 );
2090}
2091
2092wxSearchColor::~wxSearchColor( void )
2093{
2094 if ( color ) delete color;
2095 if ( entry ) delete entry;
2096}
2097
2098int wxSearchColor::SearchColor( int r, int g, int b )
2099{
2100 unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
2101 int begin = bottom;
2102 int end = top;
2103 int middle;
2104
2105 while ( begin <= end ) {
2106
2107 middle = ( begin + end ) >> 1;
2108
2109 if ( value == color[middle] ) {
2110 return( entry[middle] );
2111 } else if ( value < color[middle] ) {
2112 end = middle - 1;
2113 } else {
2114 begin = middle + 1;
2115 }
2116
2117 }
2118
2119 return AddColor( value, middle );
2120}
2121
2122int wxSearchColor::AddColor( unsigned int value, int pos )
2123{
2124 int i;
2125 int pixel = -1;
2126 int max = 3 * (65536);
2127 for ( i = 0; i < 256; i++ ) {
2128 int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
2129 int gdiff = ((value ) & 0xFF00 ) - colors[i].green;
2130 int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
2131 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
2132 if (sum < max) { pixel = i; max = sum; }
2133 }
2134
2135 if ( entry[pos] < 0 ) {
2136 color[pos] = value;
2137 entry[pos] = pixel;
2138 } else if ( value < color[pos] ) {
2139
2140 if ( bottom > 0 ) {
2141 for ( i = bottom; i < pos; i++ ) {
2142 color[i-1] = color[i];
2143 entry[i-1] = entry[i];
2144 }
2145 bottom--;
2146 color[pos-1] = value;
2147 entry[pos-1] = pixel;
2148 } else if ( top < size-1 ) {
2149 for ( i = top; i >= pos; i-- ) {
2150 color[i+1] = color[i];
2151 entry[i+1] = entry[i];
2152 }
2153 top++;
2154 color[pos] = value;
2155 entry[pos] = pixel;
2156 }
2157
2158 } else {
2159
2160 if ( top < size-1 ) {
2161 for ( i = top; i > pos; i-- ) {
2162 color[i+1] = color[i];
2163 entry[i+1] = entry[i];
2164 }
2165 top++;
2166 color[pos+1] = value;
2167 entry[pos+1] = pixel;
2168 } else if ( bottom > 0 ) {
2169 for ( i = bottom; i < pos; i++ ) {
2170 color[i-1] = color[i];
2171 entry[i-1] = entry[i];
2172 }
2173 bottom--;
2174 color[pos] = value;
2175 entry[pos] = pixel;
2176 }
2177
2178 }
2179
2180 return( pixel );
2181}
2182
2183wxBitmap wxImage::ConvertToBitmap() const
2184{
2185 wxBitmap bitmap;
2186
2187 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
2188
2189 int width = GetWidth();
2190 int height = GetHeight();
2191
2192 bitmap.SetHeight( height );
2193 bitmap.SetWidth( width );
2194
2195 Display *dpy = (Display*) wxGetDisplay();
2196 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
2197 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
2198
2199 // Create image
2200
2201 XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
2202 data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
2203
2204 bitmap.Create( width, height, bpp );
2205
2206 // Create mask
2207
2208 XImage *mask_image = (XImage*) NULL;
2209 if (HasMask())
2210 {
2211 mask_image = XCreateImage( dpy, vis, 1, ZPixmap, 0, 0, width, height, 32, 0 );
2212 mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
2213 }
2214
2215 // Retrieve depth info
2216
2217 XVisualInfo vinfo_template;
2218 XVisualInfo *vi;
2219
2220 vinfo_template.visual = vis;
2221 vinfo_template.visualid = XVisualIDFromVisual( vis );
2222 vinfo_template.depth = bpp;
2223 int nitem = 0;
2224
2225 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
2226
2227 wxCHECK_MSG( vi, wxNullBitmap, wxT("no visual") );
2228
2229 XFree( vi );
2230
2231 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
2232 if (bpp < 8) bpp = 8;
2233
2234 // Render
2235
2236 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
2237 byte_order b_o = RGB;
2238
2239 if (bpp >= 24)
2240 {
2241 if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB;
2242 else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB;
2243 else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG;
2244 else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
2245 else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB;
2246 else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR;
2247 }
2248
2249 int r_mask = GetMaskRed();
2250 int g_mask = GetMaskGreen();
2251 int b_mask = GetMaskBlue();
2252
2253 XColor colors[256];
2254 if (bpp == 8)
2255 {
2256 Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
2257
2258 for (int i = 0; i < 256; i++) colors[i].pixel = i;
2259 XQueryColors( dpy, cmap, colors, 256 );
2260 }
2261
2262 wxSearchColor scolor( 256, colors );
2263 unsigned char* data = GetData();
2264
2265 bool hasMask = HasMask();
2266
2267 int index = 0;
2268 for (int y = 0; y < height; y++)
2269 {
2270 for (int x = 0; x < width; x++)
2271 {
2272 int r = data[index];
2273 index++;
2274 int g = data[index];
2275 index++;
2276 int b = data[index];
2277 index++;
2278
2279 if (hasMask)
2280 {
2281 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
2282 XPutPixel( mask_image, x, y, 0 );
2283 else
2284 XPutPixel( mask_image, x, y, 1 );
2285 }
2286
2287 switch (bpp)
2288 {
2289 case 8:
2290 {
2291#if 0 // Old, slower code
2292 int pixel = -1;
2293 /*
2294 if (wxTheApp->m_colorCube)
2295 {
2296 pixel = wxTheApp->m_colorCube
2297 [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
2298 }
2299 else
2300 {
2301 */
2302 int max = 3 * (65536);
2303 for (int i = 0; i < 256; i++)
2304 {
2305 int rdiff = (r << 8) - colors[i].red;
2306 int gdiff = (g << 8) - colors[i].green;
2307 int bdiff = (b << 8) - colors[i].blue;
2308 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
2309 if (sum < max) { pixel = i; max = sum; }
2310 }
2311 /*
2312 }
2313 */
2314#endif
2315
2316 // And this is all to get the 'right' color...
2317 int pixel = scolor.SearchColor( r, g, b );
2318 XPutPixel( data_image, x, y, pixel );
2319 break;
2320 }
2321 case 15:
2322 {
2323 int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
2324 XPutPixel( data_image, x, y, pixel );
2325 break;
2326 }
2327 case 16:
2328 {
2329 int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
2330 XPutPixel( data_image, x, y, pixel );
2331 break;
2332 }
2333 case 32:
2334 case 24:
2335 {
2336 int pixel = 0;
2337 switch (b_o)
2338 {
2339 case RGB: pixel = (r << 16) | (g << 8) | b; break;
2340 case RBG: pixel = (r << 16) | (b << 8) | g; break;
2341 case BRG: pixel = (b << 16) | (r << 8) | g; break;
2342 case BGR: pixel = (b << 16) | (g << 8) | r; break;
2343 case GRB: pixel = (g << 16) | (r << 8) | b; break;
2344 case GBR: pixel = (g << 16) | (b << 8) | r; break;
2345 }
2346 XPutPixel( data_image, x, y, pixel );
2347 }
2348 default: break;
2349 }
2350 } // for
2351 } // for
2352
2353 // Blit picture
2354
2355 XGCValues gcvalues;
2356 gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
2357 GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
2358 XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
2359
2360 XDestroyImage( data_image );
2361 XFreeGC( dpy, gc );
2362
2363 // Blit mask
2364 if (HasMask())
2365 {
2366 wxBitmap maskBitmap(width, height, 1);
2367
2368 GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), (XtGCMask) 0, (XGCValues*)NULL );
2369 XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height );
2370
2371 XDestroyImage( mask_image );
2372 XFreeGC( dpy, gcMask );
2373
2374 wxMask* mask = new wxMask;
2375 mask->SetPixmap(maskBitmap.GetPixmap());
2376
2377 bitmap.SetMask(mask);
2378
2379 maskBitmap.SetPixmapNull();
2380 }
2381
2382 return bitmap;
2383}
2384
2385wxImage::wxImage( const wxBitmap &bitmap )
2386{
2387 wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
2388
2389 Display *dpy = (Display*) wxGetDisplay();
2390 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
2391 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
2392
2393 XImage *ximage = XGetImage( dpy,
2394 (Drawable)bitmap.GetPixmap(),
2395 0, 0,
2396 bitmap.GetWidth(), bitmap.GetHeight(),
2397 AllPlanes, ZPixmap );
2398
2399 wxCHECK_RET( ximage, wxT("couldn't create image") );
2400
2401 Create( bitmap.GetWidth(), bitmap.GetHeight() );
2402 char unsigned *data = GetData();
2403
2404 if (!data)
2405 {
2406 XDestroyImage( ximage );
2407 wxFAIL_MSG( wxT("couldn't create image") );
2408 return;
2409 }
2410
2411 /*
2412 GdkImage *gdk_image_mask = (GdkImage*) NULL;
2413 if (bitmap.GetMask())
2414 {
2415 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
2416 0, 0,
2417 bitmap.GetWidth(), bitmap.GetHeight() );
2418
2419 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
2420 }
2421 */
2422
2423 // Retrieve depth info
2424
2425 XVisualInfo vinfo_template;
2426 XVisualInfo *vi;
2427
2428 vinfo_template.visual = vis;
2429 vinfo_template.visualid = XVisualIDFromVisual( vis );
2430 vinfo_template.depth = bpp;
2431 int nitem = 0;
2432
2433 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
2434
2435 wxCHECK_RET( vi, wxT("no visual") );
2436
2437 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
2438
2439 XFree( vi );
2440
2441 XColor colors[256];
2442 if (bpp == 8)
2443 {
2444 Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
2445
2446 for (int i = 0; i < 256; i++) colors[i].pixel = i;
2447 XQueryColors( dpy, cmap, colors, 256 );
2448 }
2449
2450 long pos = 0;
2451 for (int j = 0; j < bitmap.GetHeight(); j++)
2452 {
2453 for (int i = 0; i < bitmap.GetWidth(); i++)
2454 {
2455 int pixel = XGetPixel( ximage, i, j );
2456 if (bpp <= 8)
2457 {
2458 data[pos] = colors[pixel].red >> 8;
2459 data[pos+1] = colors[pixel].green >> 8;
2460 data[pos+2] = colors[pixel].blue >> 8;
2461 } else if (bpp == 15)
2462 {
2463 data[pos] = (pixel >> 7) & 0xf8;
2464 data[pos+1] = (pixel >> 2) & 0xf8;
2465 data[pos+2] = (pixel << 3) & 0xf8;
2466 } else if (bpp == 16)
2467 {
2468 data[pos] = (pixel >> 8) & 0xf8;
2469 data[pos+1] = (pixel >> 3) & 0xfc;
2470 data[pos+2] = (pixel << 3) & 0xf8;
2471 } else
2472 {
2473 data[pos] = (pixel >> 16) & 0xff;
2474 data[pos+1] = (pixel >> 8) & 0xff;
2475 data[pos+2] = pixel & 0xff;
2476 }
2477
2478 /*
2479 if (gdk_image_mask)
2480 {
2481 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
2482 if (mask_pixel == 0)
2483 {
2484 data[pos] = 16;
2485 data[pos+1] = 16;
2486 data[pos+2] = 16;
2487 }
2488 }
2489 */
2490
2491 pos += 3;
2492 }
2493 }
2494
2495 XDestroyImage( ximage );
2496 /*
2497 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
2498 */
2499}
2500#endif
2501
2502#ifdef __WXPM__
2503// OS/2 Presentation manager conversion routings
2504
2505wxBitmap wxImage::ConvertToBitmap() const
2506{
2507 if ( !Ok() )
2508 return wxNullBitmap;
2509 wxBitmap bitmap; // remove
2510// TODO:
2511/*
2512 int sizeLimit = 1024*768*3;
2513
2514 // width and height of the device-dependent bitmap
2515 int width = GetWidth();
2516 int bmpHeight = GetHeight();
2517
2518 // calc the number of bytes per scanline and padding
2519 int bytePerLine = width*3;
2520 int sizeDWORD = sizeof( DWORD );
2521 int lineBoundary = bytePerLine % sizeDWORD;
2522 int padding = 0;
2523 if( lineBoundary > 0 )
2524 {
2525 padding = sizeDWORD - lineBoundary;
2526 bytePerLine += padding;
2527 }
2528 // calc the number of DIBs and heights of DIBs
2529 int numDIB = 1;
2530 int hRemain = 0;
2531 int height = sizeLimit/bytePerLine;
2532 if( height >= bmpHeight )
2533 height = bmpHeight;
2534 else
2535 {
2536 numDIB = bmpHeight / height;
2537 hRemain = bmpHeight % height;
2538 if( hRemain >0 ) numDIB++;
2539 }
2540
2541 // set bitmap parameters
2542 wxBitmap bitmap;
2543 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
2544 bitmap.SetWidth( width );
2545 bitmap.SetHeight( bmpHeight );
2546 bitmap.SetDepth( wxDisplayDepth() );
2547
2548 // create a DIB header
2549 int headersize = sizeof(BITMAPINFOHEADER);
2550 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
2551 wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
2552 // Fill in the DIB header
2553 lpDIBh->bmiHeader.biSize = headersize;
2554 lpDIBh->bmiHeader.biWidth = (DWORD)width;
2555 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2556 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2557 // the general formula for biSizeImage:
2558 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
2559 lpDIBh->bmiHeader.biPlanes = 1;
2560 lpDIBh->bmiHeader.biBitCount = 24;
2561 lpDIBh->bmiHeader.biCompression = BI_RGB;
2562 lpDIBh->bmiHeader.biClrUsed = 0;
2563 // These seem not really needed for our purpose here.
2564 lpDIBh->bmiHeader.biClrImportant = 0;
2565 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
2566 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
2567 // memory for DIB data
2568 unsigned char *lpBits;
2569 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
2570 if( !lpBits )
2571 {
2572 wxFAIL_MSG( wxT("could not allocate memory for DIB") );
2573 free( lpDIBh );
2574 return bitmap;
2575 }
2576
2577 // create and set the device-dependent bitmap
2578 HDC hdc = ::GetDC(NULL);
2579 HDC memdc = ::CreateCompatibleDC( hdc );
2580 HBITMAP hbitmap;
2581 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
2582 ::SelectObject( memdc, hbitmap);
2583
2584 // copy image data into DIB data and then into DDB (in a loop)
2585 unsigned char *data = GetData();
2586 int i, j, n;
2587 int origin = 0;
2588 unsigned char *ptdata = data;
2589 unsigned char *ptbits;
2590
2591 for( n=0; n<numDIB; n++ )
2592 {
2593 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
2594 {
2595 // redefine height and size of the (possibly) last smaller DIB
2596 // memory is not reallocated
2597 height = hRemain;
2598 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2599 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2600 }
2601 ptbits = lpBits;
2602
2603 for( j=0; j<height; j++ )
2604 {
2605 for( i=0; i<width; i++ )
2606 {
2607 *(ptbits++) = *(ptdata+2);
2608 *(ptbits++) = *(ptdata+1);
2609 *(ptbits++) = *(ptdata );
2610 ptdata += 3;
2611 }
2612 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
2613 }
2614 ::StretchDIBits( memdc, 0, origin, width, height,\
2615 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
2616 origin += height;
2617 // if numDIB = 1, lines below can also be used
2618 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
2619 // The above line is equivalent to the following two lines.
2620 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
2621 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
2622 // or the following lines
2623 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
2624 // HDC memdc = ::CreateCompatibleDC( hdc );
2625 // ::SelectObject( memdc, hbitmap);
2626 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
2627 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
2628 // ::SelectObject( memdc, 0 );
2629 // ::DeleteDC( memdc );
2630 }
2631 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
2632
2633 // similarly, created an mono-bitmap for the possible mask
2634 if( HasMask() )
2635 {
2636 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
2637 ::SelectObject( memdc, hbitmap);
2638 if( numDIB == 1 ) height = bmpHeight;
2639 else height = sizeLimit/bytePerLine;
2640 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2641 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2642 origin = 0;
2643 unsigned char r = GetMaskRed();
2644 unsigned char g = GetMaskGreen();
2645 unsigned char b = GetMaskBlue();
2646 unsigned char zero = 0, one = 255;
2647 ptdata = data;
2648 for( n=0; n<numDIB; n++ )
2649 {
2650 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
2651 {
2652 // redefine height and size of the (possibly) last smaller DIB
2653 // memory is not reallocated
2654 height = hRemain;
2655 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
2656 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
2657 }
2658 ptbits = lpBits;
2659 for( int j=0; j<height; j++ )
2660 {
2661 for(i=0; i<width; i++ )
2662 {
2663 if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
2664 {
2665 *(ptbits++) = one;
2666 *(ptbits++) = one;
2667 *(ptbits++) = one;
2668 }
2669 else
2670 {
2671 *(ptbits++) = zero;
2672 *(ptbits++) = zero;
2673 *(ptbits++) = zero;
2674 }
2675 }
2676 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
2677 }
2678 ::StretchDIBits( memdc, 0, origin, width, height,\
2679 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
2680 origin += height;
2681 }
2682 // create a wxMask object
2683 wxMask *mask = new wxMask();
2684 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
2685 bitmap.SetMask( mask );
2686 }
2687
2688 // free allocated resources
2689 ::SelectObject( memdc, 0 );
2690 ::DeleteDC( memdc );
2691 ::ReleaseDC(NULL, hdc);
2692 free(lpDIBh);
2693 free(lpBits);
2694
2695 // check the wxBitmap object
2696 if( bitmap.GetHBITMAP() )
2697 bitmap.SetOk( TRUE );
2698 else
2699 bitmap.SetOk( FALSE );
2700*/
2701 return bitmap;
2702}
2703
2704wxImage::wxImage( const wxBitmap &bitmap )
2705{
2706 // check the bitmap
2707 if( !bitmap.Ok() )
2708 {
2709 wxFAIL_MSG( wxT("invalid bitmap") );
2710 return;
2711 }
2712
2713 // create an wxImage object
2714 int width = bitmap.GetWidth();
2715 int height = bitmap.GetHeight();
2716 Create( width, height );
2717 unsigned char *data = GetData();
2718 if( !data )
2719 {
2720 wxFAIL_MSG( wxT("could not allocate data for image") );
2721 return;
2722 }
2723
2724 // calc the number of bytes per scanline and padding in the DIB
2725 int bytePerLine = width*3;
2726 int sizeDWORD = sizeof( DWORD );
2727 int lineBoundary = bytePerLine % sizeDWORD;
2728 int padding = 0;
2729 if( lineBoundary > 0 )
2730 {
2731 padding = sizeDWORD - lineBoundary;
2732 bytePerLine += padding;
2733 }
2734// TODO:
2735/*
2736 // create a DIB header
2737 int headersize = sizeof(BITMAPINFOHEADER);
2738 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
2739 if( !lpDIBh )
2740 {
2741 wxFAIL_MSG( wxT("could not allocate data for DIB header") );
2742 free( data );
2743 return;
2744 }
2745 // Fill in the DIB header
2746 lpDIBh->bmiHeader.biSize = headersize;
2747 lpDIBh->bmiHeader.biWidth = width;
2748 lpDIBh->bmiHeader.biHeight = -height;
2749 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
2750 lpDIBh->bmiHeader.biPlanes = 1;
2751 lpDIBh->bmiHeader.biBitCount = 24;
2752 lpDIBh->bmiHeader.biCompression = BI_RGB;
2753 lpDIBh->bmiHeader.biClrUsed = 0;
2754 // These seem not really needed for our purpose here.
2755 lpDIBh->bmiHeader.biClrImportant = 0;
2756 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
2757 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
2758 // memory for DIB data
2759 unsigned char *lpBits;
2760 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
2761 if( !lpBits )
2762 {
2763 wxFAIL_MSG( wxT("could not allocate data for DIB") );
2764 free( data );
2765 free( lpDIBh );
2766 return;
2767 }
2768
2769 // copy data from the device-dependent bitmap to the DIB
2770 HDC hdc = ::GetDC(NULL);
2771 HBITMAP hbitmap;
2772 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
2773 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
2774
2775 // copy DIB data into the wxImage object
2776 int i, j;
2777 unsigned char *ptdata = data;
2778 unsigned char *ptbits = lpBits;
2779 for( i=0; i<height; i++ )
2780 {
2781 for( j=0; j<width; j++ )
2782 {
2783 *(ptdata++) = *(ptbits+2);
2784 *(ptdata++) = *(ptbits+1);
2785 *(ptdata++) = *(ptbits );
2786 ptbits += 3;
2787 }
2788 ptbits += padding;
2789 }
2790
2791 // similarly, set data according to the possible mask bitmap
2792 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
2793 {
2794 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
2795 // memory DC created, color set, data copied, and memory DC deleted
2796 HDC memdc = ::CreateCompatibleDC( hdc );
2797 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
2798 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
2799 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
2800 ::DeleteDC( memdc );
2801 // background color set to RGB(16,16,16) in consistent with wxGTK
2802 unsigned char r=16, g=16, b=16;
2803 ptdata = data;
2804 ptbits = lpBits;
2805 for( i=0; i<height; i++ )
2806 {
2807 for( j=0; j<width; j++ )
2808 {
2809 if( *ptbits != 0 )
2810 ptdata += 3;
2811 else
2812 {
2813 *(ptdata++) = r;
2814 *(ptdata++) = g;
2815 *(ptdata++) = b;
2816 }
2817 ptbits += 3;
2818 }
2819 ptbits += padding;
2820 }
2821 SetMaskColour( r, g, b );
2822 SetMask( TRUE );
2823 }
2824 else
2825 {
2826 SetMask( FALSE );
2827 }
2828 // free allocated resources
2829 ::ReleaseDC(NULL, hdc);
2830 free(lpDIBh);
2831 free(lpBits);
2832*/
2833}
2834
2835#endif
2836
2837// A module to allow wxImage initialization/cleanup
2838// without calling these functions from app.cpp or from
2839// the user's application.
2840
2841class wxImageModule: public wxModule
2842{
2843DECLARE_DYNAMIC_CLASS(wxImageModule)
2844public:
2845 wxImageModule() {}
2846 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE; };
2847 void OnExit() { wxImage::CleanUpHandlers(); };
2848};
2849
2850IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
2851
2852
2853//-----------------------------------------------------------------------------
2854
2855// GRG, Dic/99
2856// Counts and returns the number of different colours. Optionally stops
2857// when it exceeds 'stopafter' different colours. This is useful, for
2858// example, to see if the image can be saved as 8-bit (256 colour or
2859// less, in this case it would be invoked as CountColours(256)). Default
2860// value for stopafter is -1 (don't care).
2861//
2862unsigned long wxImage::CountColours( unsigned long stopafter )
2863{
2864 wxHashTable h;
2865 wxObject dummy;
2866 unsigned char r, g, b, *p;
2867 unsigned long size, nentries, key;
2868
2869 p = GetData();
2870 size = GetWidth() * GetHeight();
2871 nentries = 0;
2872
2873 for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
2874 {
2875 r = *(p++);
2876 g = *(p++);
2877 b = *(p++);
2878 key = (r << 16) | (g << 8) | b;
2879
2880 if (h.Get(key) == NULL)
2881 {
2882 h.Put(key, &dummy);
2883 nentries++;
2884 }
2885 }
2886
2887 return nentries;
2888}
2889
2890
2891// GRG, Dic/99
2892// Computes the histogram of the image and fills a hash table, indexed
2893// with integer keys built as 0xRRGGBB, containing wxHNode objects. Each
2894// wxHNode contains an 'index' (useful to build a palette with the image
2895// colours) and a 'value', which is the number of pixels in the image with
2896// that colour.
2897//
2898unsigned long wxImage::ComputeHistogram( wxHashTable &h )
2899{
2900 unsigned char r, g, b, *p;
2901 unsigned long size, nentries, key;
2902 wxHNode *hnode;
2903
2904 p = GetData();
2905 size = GetWidth() * GetHeight();
2906 nentries = 0;
2907
2908 for (unsigned long j = 0; j < size; j++)
2909 {
2910 r = *(p++);
2911 g = *(p++);
2912 b = *(p++);
2913 key = (r << 16) | (g << 8) | b;
2914
2915 hnode = (wxHNode *) h.Get(key);
2916
2917 if (hnode)
2918 hnode->value++;
2919 else
2920 {
2921 hnode = new wxHNode();
2922 hnode->index = nentries++;
2923 hnode->value = 1;
2924
2925 h.Put(key, (wxObject *)hnode);
2926 }
2927 }
2928
2929 return nentries;
2930}
2931
2932/*
2933 * Rotation code by Carlos Moreno
2934 */
2935
2936// GRG: I've removed wxRotationPoint - we already have wxRealPoint which
2937// does exactly the same thing. And I also got rid of wxRotationPixel
2938// bacause of potential problems in architectures where alignment
2939// is an issue, so I had to rewrite parts of the code.
2940
2941static const double gs_Epsilon = 1e-10;
2942
2943static inline int wxCint (double x)
2944{
2945 return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
2946}
2947
2948
2949// Auxiliary function to rotate a point (x,y) with respect to point p0
2950// make it inline and use a straight return to facilitate optimization
2951// also, the function receives the sine and cosine of the angle to avoid
2952// repeating the time-consuming calls to these functions -- sin/cos can
2953// be computed and stored in the calling function.
2954
2955inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
2956{
2957 return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
2958 p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
2959}
2960
2961inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
2962{
2963 return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
2964}
2965
2966wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
2967{
2968 int i;
2969 angle = -angle; // screen coordinates are a mirror image of "real" coordinates
2970
2971 // Create pointer-based array to accelerate access to wxImage's data
2972 unsigned char ** data = new unsigned char * [GetHeight()];
2973
2974 data[0] = GetData();
2975
2976 for (i = 1; i < GetHeight(); i++)
2977 data[i] = data[i - 1] + (3 * GetWidth());
2978
2979 // precompute coefficients for rotation formula
2980 // (sine and cosine of the angle)
2981 const double cos_angle = cos(angle);
2982 const double sin_angle = sin(angle);
2983
2984 // Create new Image to store the result
2985 // First, find rectangle that covers the rotated image; to do that,
2986 // rotate the four corners
2987
2988 const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
2989
2990 wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
2991 wxRealPoint p2 = rotated_point (0, GetHeight(), cos_angle, sin_angle, p0);
2992 wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
2993 wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
2994
2995 int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
2996 int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
2997 int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
2998 int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
2999
3000 wxImage rotated (x2 - x1 + 1, y2 - y1 + 1);
3001
3002 if (offset_after_rotation != NULL)
3003 {
3004 *offset_after_rotation = wxPoint (x1, y1);
3005 }
3006
3007 // GRG: The rotated (destination) image is always accessed
3008 // sequentially, so there is no need for a pointer-based
3009 // array here (and in fact it would be slower).
3010 //
3011 unsigned char * dst = rotated.GetData();
3012
3013 // GRG: if the original image has a mask, use its RGB values
3014 // as the blank pixel, else, fall back to default (black).
3015 //
3016 unsigned char blank_r = 0;
3017 unsigned char blank_g = 0;
3018 unsigned char blank_b = 0;
3019
3020 if (HasMask())
3021 {
3022 blank_r = GetMaskRed();
3023 blank_g = GetMaskGreen();
3024 blank_b = GetMaskBlue();
3025 rotated.SetMaskColour( blank_r, blank_g, blank_b );
3026 }
3027
3028 // Now, for each point of the rotated image, find where it came from, by
3029 // performing an inverse rotation (a rotation of -angle) and getting the
3030 // pixel at those coordinates
3031
3032 // GRG: I've taken the (interpolating) test out of the loops, so that
3033 // it is done only once, instead of repeating it for each pixel.
3034
3035 int x;
3036 if (interpolating)
3037 {
3038 for (int y = 0; y < rotated.GetHeight(); y++)
3039 {
3040 for (x = 0; x < rotated.GetWidth(); x++)
3041 {
3042 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
3043
3044 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
3045 -0.25 < src.y && src.y < GetHeight() - 0.75)
3046 {
3047 // interpolate using the 4 enclosing grid-points. Those
3048 // points can be obtained using floor and ceiling of the
3049 // exact coordinates of the point
3050 // C.M. 2000-02-17: when the point is near the border, special care is required.
3051
3052 int x1, y1, x2, y2;
3053
3054 if (0 < src.x && src.x < GetWidth() - 1)
3055 {
3056 x1 = wxCint(floor(src.x));
3057 x2 = wxCint(ceil(src.x));
3058 }
3059 else // else means that x is near one of the borders (0 or width-1)
3060 {
3061 x1 = x2 = wxCint (src.x);
3062 }
3063
3064 if (0 < src.y && src.y < GetHeight() - 1)
3065 {
3066 y1 = wxCint(floor(src.y));
3067 y2 = wxCint(ceil(src.y));
3068 }
3069 else
3070 {
3071 y1 = y2 = wxCint (src.y);
3072 }
3073
3074 // get four points and the distances (square of the distance,
3075 // for efficiency reasons) for the interpolation formula
3076
3077 // GRG: Do not calculate the points until they are
3078 // really needed -- this way we can calculate
3079 // just one, instead of four, if d1, d2, d3
3080 // or d4 are < gs_Epsilon
3081
3082 const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
3083 const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
3084 const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
3085 const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
3086
3087 // Now interpolate as a weighted average of the four surrounding
3088 // points, where the weights are the distances to each of those points
3089
3090 // If the point is exactly at one point of the grid of the source
3091 // image, then don't interpolate -- just assign the pixel
3092
3093 if (d1 < gs_Epsilon) // d1,d2,d3,d4 are positive -- no need for abs()
3094 {
3095 unsigned char *p = data[y1] + (3 * x1);
3096 *(dst++) = *(p++);
3097 *(dst++) = *(p++);
3098 *(dst++) = *(p++);
3099 }
3100 else if (d2 < gs_Epsilon)
3101 {
3102 unsigned char *p = data[y1] + (3 * x2);
3103 *(dst++) = *(p++);
3104 *(dst++) = *(p++);
3105 *(dst++) = *(p++);
3106 }
3107 else if (d3 < gs_Epsilon)
3108 {
3109 unsigned char *p = data[y2] + (3 * x2);
3110 *(dst++) = *(p++);
3111 *(dst++) = *(p++);
3112 *(dst++) = *(p++);
3113 }
3114 else if (d4 < gs_Epsilon)
3115 {
3116 unsigned char *p = data[y2] + (3 * x1);
3117 *(dst++) = *(p++);
3118 *(dst++) = *(p++);
3119 *(dst++) = *(p++);
3120 }
3121 else
3122 {
3123 // weights for the weighted average are proportional to the inverse of the distance
3124 unsigned char *v1 = data[y1] + (3 * x1);
3125 unsigned char *v2 = data[y1] + (3 * x2);
3126 unsigned char *v3 = data[y2] + (3 * x2);
3127 unsigned char *v4 = data[y2] + (3 * x1);
3128
3129 const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
3130
3131 // GRG: Unrolled.
3132
3133 *(dst++) = (unsigned char)
3134 ( (w1 * *(v1++) + w2 * *(v2++) +
3135 w3 * *(v3++) + w4 * *(v4++)) /
3136 (w1 + w2 + w3 + w4) );
3137 *(dst++) = (unsigned char)
3138 ( (w1 * *(v1++) + w2 * *(v2++) +
3139 w3 * *(v3++) + w4 * *(v4++)) /
3140 (w1 + w2 + w3 + w4) );
3141 *(dst++) = (unsigned char)
3142 ( (w1 * *(v1++) + w2 * *(v2++) +
3143 w3 * *(v3++) + w4 * *(v4++)) /
3144 (w1 + w2 + w3 + w4) );
3145 }
3146 }
3147 else
3148 {
3149 *(dst++) = blank_r;
3150 *(dst++) = blank_g;
3151 *(dst++) = blank_b;
3152 }
3153 }
3154 }
3155 }
3156 else // not interpolating
3157 {
3158 for (int y = 0; y < rotated.GetHeight(); y++)
3159 {
3160 for (x = 0; x < rotated.GetWidth(); x++)
3161 {
3162 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
3163
3164 const int xs = wxCint (src.x); // wxCint rounds to the
3165 const int ys = wxCint (src.y); // closest integer
3166
3167 if (0 <= xs && xs < GetWidth() &&
3168 0 <= ys && ys < GetHeight())
3169 {
3170 unsigned char *p = data[ys] + (3 * xs);
3171 *(dst++) = *(p++);
3172 *(dst++) = *(p++);
3173 *(dst++) = *(p++);
3174 }
3175 else
3176 {
3177 *(dst++) = blank_r;
3178 *(dst++) = blank_g;
3179 *(dst++) = blank_b;
3180 }
3181 }
3182 }
3183 }
3184
3185 delete [] data;
3186
3187 return rotated;
3188}
3189
wxWidgets (Impactor)