]> 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
reSWIGged
[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#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
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/defs.h"
22
23#if wxUSE_IMAGE
24
25#include "wx/image.h"
26#include "wx/bitmap.h"
27#include "wx/debug.h"
28#include "wx/log.h"
29#include "wx/app.h"
30#include "wx/filefn.h"
31#include "wx/wfstream.h"
32#include "wx/intl.h"
33#include "wx/module.h"
34#include "wx/hash.h"
35#include "wx/utils.h"
36#include "wx/math.h"
37
38#if wxUSE_XPM
39#include "wx/xpmdecod.h"
40#endif
41
42// For memcpy
43#include <string.h>
44
45#ifdef __SALFORDC__
46 #undef FAR
47#endif
48
49
50//-----------------------------------------------------------------------------
51// wxImage
52//-----------------------------------------------------------------------------
53
54class wxImageRefData: public wxObjectRefData
55{
56public:
57 wxImageRefData();
58 virtual ~wxImageRefData();
59
60 int m_width;
61 int m_height;
62 unsigned char *m_data;
63
64 bool m_hasMask;
65 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
66
67 // alpha channel data, may be NULL for the formats without alpha support
68 unsigned char *m_alpha;
69
70 bool m_ok;
71 bool m_static;
72
73#if wxUSE_PALETTE
74 wxPalette m_palette;
75#endif // wxUSE_PALETTE
76
77 wxArrayString m_optionNames;
78 wxArrayString m_optionValues;
79
80 DECLARE_NO_COPY_CLASS(wxImageRefData)
81};
82
83wxImageRefData::wxImageRefData()
84{
85 m_width = 0;
86 m_height = 0;
87 m_data =
88 m_alpha = (unsigned char *) NULL;
89
90 m_maskRed = 0;
91 m_maskGreen = 0;
92 m_maskBlue = 0;
93 m_hasMask = false;
94
95 m_ok = false;
96 m_static = false;
97}
98
99wxImageRefData::~wxImageRefData()
100{
101 if (!m_static)
102 {
103 free( m_data );
104 free( m_alpha );
105 }
106}
107
108wxList wxImage::sm_handlers;
109
110wxImage wxNullImage;
111
112//-----------------------------------------------------------------------------
113
114#define M_IMGDATA ((wxImageRefData *)m_refData)
115
116IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
117
118wxImage::wxImage( int width, int height, bool clear )
119{
120 Create( width, height, clear );
121}
122
123wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
124{
125 Create( width, height, data, static_data );
126}
127
128wxImage::wxImage( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data )
129{
130 Create( width, height, data, alpha, static_data );
131}
132
133wxImage::wxImage( const wxString& name, long type, int index )
134{
135 LoadFile( name, type, index );
136}
137
138wxImage::wxImage( const wxString& name, const wxString& mimetype, int index )
139{
140 LoadFile( name, mimetype, index );
141}
142
143#if wxUSE_STREAMS
144wxImage::wxImage( wxInputStream& stream, long type, int index )
145{
146 LoadFile( stream, type, index );
147}
148
149wxImage::wxImage( wxInputStream& stream, const wxString& mimetype, int index )
150{
151 LoadFile( stream, mimetype, index );
152}
153#endif // wxUSE_STREAMS
154
155wxImage::wxImage( const wxImage& image )
156 : wxObject()
157{
158 Ref(image);
159}
160
161wxImage::wxImage( const wxImage* image )
162{
163 if (image) Ref(*image);
164}
165
166wxImage::wxImage( const char** xpmData )
167{
168 Create(xpmData);
169}
170
171wxImage::wxImage( char** xpmData )
172{
173 Create((const char**) xpmData);
174}
175
176bool wxImage::Create( const char** xpmData )
177{
178#if wxUSE_XPM
179 UnRef();
180
181 wxXPMDecoder decoder;
182 (*this) = decoder.ReadData(xpmData);
183 return Ok();
184#else
185 return false;
186#endif
187}
188
189bool wxImage::Create( int width, int height, bool clear )
190{
191 UnRef();
192
193 m_refData = new wxImageRefData();
194
195 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
196 if (!M_IMGDATA->m_data)
197 {
198 UnRef();
199 return false;
200 }
201
202 if (clear)
203 memset(M_IMGDATA->m_data, 0, width*height*3);
204
205 M_IMGDATA->m_width = width;
206 M_IMGDATA->m_height = height;
207 M_IMGDATA->m_ok = true;
208
209 return true;
210}
211
212bool wxImage::Create( int width, int height, unsigned char* data, bool static_data )
213{
214 UnRef();
215
216 wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") );
217
218 m_refData = new wxImageRefData();
219
220 M_IMGDATA->m_data = data;
221 M_IMGDATA->m_width = width;
222 M_IMGDATA->m_height = height;
223 M_IMGDATA->m_ok = true;
224 M_IMGDATA->m_static = static_data;
225
226 return true;
227}
228
229bool wxImage::Create( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data )
230{
231 UnRef();
232
233 wxCHECK_MSG( data, false, _T("NULL data in wxImage::Create") );
234
235 m_refData = new wxImageRefData();
236
237 M_IMGDATA->m_data = data;
238 M_IMGDATA->m_alpha = alpha;
239 M_IMGDATA->m_width = width;
240 M_IMGDATA->m_height = height;
241 M_IMGDATA->m_ok = true;
242 M_IMGDATA->m_static = static_data;
243
244 return true;
245}
246
247void wxImage::Destroy()
248{
249 UnRef();
250}
251
252wxImage wxImage::Copy() const
253{
254 wxImage image;
255
256 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
257
258 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
259
260 unsigned char *data = image.GetData();
261
262 wxCHECK_MSG( data, image, wxT("unable to create image") );
263
264 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
265 image.SetMask( M_IMGDATA->m_hasMask );
266
267 memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
268
269 // also copy the image options
270 wxImageRefData *imgData = (wxImageRefData *)image.m_refData;
271 imgData->m_optionNames = M_IMGDATA->m_optionNames;
272 imgData->m_optionValues = M_IMGDATA->m_optionValues;
273
274 return image;
275}
276
277wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
278{
279 if( xFactor == 1 && yFactor == 1 )
280 return Copy() ;
281
282 wxImage image;
283
284 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
285
286 // can't scale to/from 0 size
287 wxCHECK_MSG( (xFactor > 0) && (yFactor > 0), image,
288 wxT("invalid new image size") );
289
290 long old_height = M_IMGDATA->m_height,
291 old_width = M_IMGDATA->m_width;
292
293 wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
294 wxT("invalid old image size") );
295
296 long width = old_width / xFactor ;
297 long height = old_height / yFactor ;
298
299 image.Create( width, height, false );
300
301 char unsigned *data = image.GetData();
302
303 wxCHECK_MSG( data, image, wxT("unable to create image") );
304
305 bool hasMask = false ;
306 unsigned char maskRed = 0;
307 unsigned char maskGreen = 0;
308 unsigned char maskBlue =0 ;
309
310 unsigned char *source_data = M_IMGDATA->m_data;
311 unsigned char *target_data = data;
312 unsigned char *source_alpha = 0 ;
313 unsigned char *target_alpha = 0 ;
314 if (M_IMGDATA->m_hasMask)
315 {
316 hasMask = true ;
317 maskRed = M_IMGDATA->m_maskRed;
318 maskGreen = M_IMGDATA->m_maskGreen;
319 maskBlue =M_IMGDATA->m_maskBlue ;
320
321 image.SetMaskColour( M_IMGDATA->m_maskRed,
322 M_IMGDATA->m_maskGreen,
323 M_IMGDATA->m_maskBlue );
324 }
325 else
326 {
327 source_alpha = M_IMGDATA->m_alpha ;
328 if ( source_alpha )
329 {
330 image.SetAlpha() ;
331 target_alpha = image.GetAlpha() ;
332 }
333 }
334
335 for (long y = 0; y < height; y++)
336 {
337 for (long x = 0; x < width; x++)
338 {
339 unsigned long avgRed = 0 ;
340 unsigned long avgGreen = 0;
341 unsigned long avgBlue = 0;
342 unsigned long avgAlpha = 0 ;
343 unsigned long counter = 0 ;
344 // determine average
345 for ( int y1 = 0 ; y1 < yFactor ; ++y1 )
346 {
347 long y_offset = (y * yFactor + y1) * old_width;
348 for ( int x1 = 0 ; x1 < xFactor ; ++x1 )
349 {
350 unsigned char *pixel = source_data + 3 * ( y_offset + x * xFactor + x1 ) ;
351 unsigned char red = pixel[0] ;
352 unsigned char green = pixel[1] ;
353 unsigned char blue = pixel[2] ;
354 unsigned char alpha = 255 ;
355 if ( source_alpha )
356 alpha = *(source_alpha + y_offset + x * xFactor + x1) ;
357 if ( !hasMask || red != maskRed || green != maskGreen || blue != maskBlue )
358 {
359 if ( alpha > 0 )
360 {
361 avgRed += red ;
362 avgGreen += green ;
363 avgBlue += blue ;
364 }
365 avgAlpha += alpha ;
366 counter++ ;
367 }
368 }
369 }
370 if ( counter == 0 )
371 {
372 *(target_data++) = M_IMGDATA->m_maskRed ;
373 *(target_data++) = M_IMGDATA->m_maskGreen ;
374 *(target_data++) = M_IMGDATA->m_maskBlue ;
375 }
376 else
377 {
378 if ( source_alpha )
379 *(target_alpha++) = (unsigned char)(avgAlpha / counter ) ;
380 *(target_data++) = (unsigned char)(avgRed / counter);
381 *(target_data++) = (unsigned char)(avgGreen / counter);
382 *(target_data++) = (unsigned char)(avgBlue / counter);
383 }
384 }
385 }
386
387 // In case this is a cursor, make sure the hotspot is scalled accordingly:
388 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
389 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
390 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);
391 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
392 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
393 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y))/yFactor);
394
395 return image;
396}
397
398wxImage wxImage::Scale( int width, int height ) const
399{
400 wxImage image;
401
402 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
403
404 // can't scale to/from 0 size
405 wxCHECK_MSG( (width > 0) && (height > 0), image,
406 wxT("invalid new image size") );
407
408 long old_height = M_IMGDATA->m_height,
409 old_width = M_IMGDATA->m_width;
410 wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
411 wxT("invalid old image size") );
412
413 if ( old_width % width == 0 && old_width >= width &&
414 old_height % height == 0 && old_height >= height )
415 {
416 return ShrinkBy( old_width / width , old_height / height ) ;
417 }
418 image.Create( width, height, false );
419
420 unsigned char *data = image.GetData();
421
422 wxCHECK_MSG( data, image, wxT("unable to create image") );
423
424 unsigned char *source_data = M_IMGDATA->m_data;
425 unsigned char *target_data = data;
426 unsigned char *source_alpha = 0 ;
427 unsigned char *target_alpha = 0 ;
428
429 if (M_IMGDATA->m_hasMask)
430 {
431 image.SetMaskColour( M_IMGDATA->m_maskRed,
432 M_IMGDATA->m_maskGreen,
433 M_IMGDATA->m_maskBlue );
434 }
435 else
436 {
437 source_alpha = M_IMGDATA->m_alpha ;
438 if ( source_alpha )
439 {
440 image.SetAlpha() ;
441 target_alpha = image.GetAlpha() ;
442 }
443 }
444
445 long x_delta = (old_width<<16) / width;
446 long y_delta = (old_height<<16) / height;
447
448 unsigned char* dest_pixel = target_data;
449
450 long y = 0;
451 for ( long j = 0; j < height; j++ )
452 {
453 unsigned char* src_line = &source_data[(y>>16)*old_width*3];
454 unsigned char* src_alpha_line = source_alpha ? &source_alpha[(y>>16)*old_width] : 0 ;
455
456 long x = 0;
457 for ( long i = 0; i < width; i++ )
458 {
459 unsigned char* src_pixel = &src_line[(x>>16)*3];
460 unsigned char* src_alpha_pixel = source_alpha ? &src_alpha_line[(x>>16)] : 0 ;
461 dest_pixel[0] = src_pixel[0];
462 dest_pixel[1] = src_pixel[1];
463 dest_pixel[2] = src_pixel[2];
464 dest_pixel += 3;
465 if ( source_alpha )
466 *(target_alpha++) = *src_alpha_pixel ;
467 x += x_delta;
468 }
469
470 y += y_delta;
471 }
472
473 // In case this is a cursor, make sure the hotspot is scalled accordingly:
474 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
475 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
476 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);
477 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
478 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
479 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y)*height)/old_height);
480
481 return image;
482}
483
484wxImage wxImage::Rotate90( bool clockwise ) const
485{
486 wxImage image;
487
488 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
489
490 image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width, false );
491
492 unsigned char *data = image.GetData();
493
494 wxCHECK_MSG( data, image, wxT("unable to create image") );
495
496 if (M_IMGDATA->m_hasMask)
497 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
498
499 long height = M_IMGDATA->m_height;
500 long width = M_IMGDATA->m_width;
501
502 unsigned char *source_data = M_IMGDATA->m_data;
503 unsigned char *target_data;
504
505 for (long j = 0; j < height; j++)
506 {
507 for (long i = 0; i < width; i++)
508 {
509 if (clockwise)
510 target_data = data + (((i+1)*height) - j - 1)*3;
511 else
512 target_data = data + ((height*(width-1)) + j - (i*height))*3;
513 memcpy( target_data, source_data, 3 );
514 source_data += 3;
515 }
516 }
517
518 return image;
519}
520
521wxImage wxImage::Mirror( bool horizontally ) const
522{
523 wxImage image;
524
525 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
526
527 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
528
529 unsigned char *data = image.GetData();
530
531 wxCHECK_MSG( data, image, wxT("unable to create image") );
532
533 if (M_IMGDATA->m_hasMask)
534 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
535
536 long height = M_IMGDATA->m_height;
537 long width = M_IMGDATA->m_width;
538
539 unsigned char *source_data = M_IMGDATA->m_data;
540 unsigned char *target_data;
541
542 if (horizontally)
543 {
544 for (long j = 0; j < height; j++)
545 {
546 data += width*3;
547 target_data = data-3;
548 for (long i = 0; i < width; i++)
549 {
550 memcpy( target_data, source_data, 3 );
551 source_data += 3;
552 target_data -= 3;
553 }
554 }
555 }
556 else
557 {
558 for (long i = 0; i < height; i++)
559 {
560 target_data = data + 3*width*(height-1-i);
561 memcpy( target_data, source_data, (size_t)3*width );
562 source_data += 3*width;
563 }
564 }
565
566 return image;
567}
568
569wxImage wxImage::GetSubImage( const wxRect &rect ) const
570{
571 wxImage image;
572
573 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
574
575 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
576 image, wxT("invalid subimage size") );
577
578 int subwidth=rect.GetWidth();
579 const int subheight=rect.GetHeight();
580
581 image.Create( subwidth, subheight, false );
582
583 unsigned char *subdata = image.GetData(), *data=GetData();
584
585 wxCHECK_MSG( subdata, image, wxT("unable to create image") );
586
587 if (M_IMGDATA->m_hasMask)
588 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
589
590 const int subleft=3*rect.GetLeft();
591 const int width=3*GetWidth();
592 subwidth*=3;
593
594 data+=rect.GetTop()*width+subleft;
595
596 for (long j = 0; j < subheight; ++j)
597 {
598 memcpy( subdata, data, subwidth);
599 subdata+=subwidth;
600 data+=width;
601 }
602
603 return image;
604}
605
606wxImage wxImage::Size( const wxSize& size, const wxPoint& pos,
607 int r_, int g_, int b_ ) const
608{
609 wxImage image;
610
611 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
612 wxCHECK_MSG( (size.GetWidth() > 0) && (size.GetHeight() > 0), image, wxT("invalid size") );
613
614 int width = GetWidth(), height = GetHeight();
615 image.Create(size.GetWidth(), size.GetHeight(), false);
616
617 unsigned char r = (unsigned char)r_;
618 unsigned char g = (unsigned char)g_;
619 unsigned char b = (unsigned char)b_;
620 if ((r_ == -1) && (g_ == -1) && (b_ == -1))
621 {
622 GetOrFindMaskColour( &r, &g, &b );
623 image.SetMaskColour(r, g, b);
624 }
625
626 image.SetRGB(wxRect(), r, g, b);
627
628 wxRect subRect(pos.x, pos.y, width, height);
629 wxRect finalRect(0, 0, size.GetWidth(), size.GetHeight());
630
631 subRect.Intersect(finalRect);
632
633 if (!subRect.IsEmpty())
634 {
635 if ((subRect.GetWidth() == width) && (subRect.GetHeight() == height))
636 image.Paste(*this, pos.x, pos.y);
637 else
638 image.Paste(GetSubImage(subRect), pos.x, pos.y);
639 }
640
641 return image;
642}
643
644void wxImage::Paste( const wxImage &image, int x, int y )
645{
646 wxCHECK_RET( Ok(), wxT("invalid image") );
647 wxCHECK_RET( image.Ok(), wxT("invalid image") );
648
649 int xx = 0;
650 int yy = 0;
651 int width = image.GetWidth();
652 int height = image.GetHeight();
653
654 if (x < 0)
655 {
656 xx = -x;
657 width += x;
658 }
659 if (y < 0)
660 {
661 yy = -y;
662 height += y;
663 }
664
665 if ((x+xx)+width > M_IMGDATA->m_width)
666 width = M_IMGDATA->m_width - (x+xx);
667 if ((y+yy)+height > M_IMGDATA->m_height)
668 height = M_IMGDATA->m_height - (y+yy);
669
670 if (width < 1) return;
671 if (height < 1) return;
672
673 if ((!HasMask() && !image.HasMask()) ||
674 (HasMask() && !image.HasMask()) ||
675 ((HasMask() && image.HasMask() &&
676 (GetMaskRed()==image.GetMaskRed()) &&
677 (GetMaskGreen()==image.GetMaskGreen()) &&
678 (GetMaskBlue()==image.GetMaskBlue()))))
679 {
680 width *= 3;
681 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
682 int source_step = image.GetWidth()*3;
683
684 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
685 int target_step = M_IMGDATA->m_width*3;
686 for (int j = 0; j < height; j++)
687 {
688 memcpy( target_data, source_data, width );
689 source_data += source_step;
690 target_data += target_step;
691 }
692 return;
693 }
694
695 if (!HasMask() && image.HasMask())
696 {
697 unsigned char r = image.GetMaskRed();
698 unsigned char g = image.GetMaskGreen();
699 unsigned char b = image.GetMaskBlue();
700
701 width *= 3;
702 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
703 int source_step = image.GetWidth()*3;
704
705 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
706 int target_step = M_IMGDATA->m_width*3;
707
708 for (int j = 0; j < height; j++)
709 {
710 for (int i = 0; i < width; i+=3)
711 {
712 if ((source_data[i] != r) &&
713 (source_data[i+1] != g) &&
714 (source_data[i+2] != b))
715 {
716 memcpy( target_data+i, source_data+i, 3 );
717 }
718 }
719 source_data += source_step;
720 target_data += target_step;
721 }
722 }
723}
724
725void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
726 unsigned char r2, unsigned char g2, unsigned char b2 )
727{
728 wxCHECK_RET( Ok(), wxT("invalid image") );
729
730 unsigned char *data = GetData();
731
732 const int w = GetWidth();
733 const int h = GetHeight();
734
735 for (int j = 0; j < h; j++)
736 for (int i = 0; i < w; i++)
737 {
738 if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
739 {
740 data[0] = r2;
741 data[1] = g2;
742 data[2] = b2;
743 }
744 data += 3;
745 }
746}
747
748wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
749{
750 wxImage image;
751
752 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
753
754 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
755
756 unsigned char *data = image.GetData();
757
758 wxCHECK_MSG( data, image, wxT("unable to create image") );
759
760 if (M_IMGDATA->m_hasMask)
761 {
762 if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
763 M_IMGDATA->m_maskBlue == b)
764 image.SetMaskColour( 255, 255, 255 );
765 else
766 image.SetMaskColour( 0, 0, 0 );
767 }
768
769 long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
770
771 unsigned char *srcd = M_IMGDATA->m_data;
772 unsigned char *tard = image.GetData();
773
774 for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
775 {
776 if (srcd[0] == r && srcd[1] == g && srcd[2] == b)
777 tard[0] = tard[1] = tard[2] = 255;
778 else
779 tard[0] = tard[1] = tard[2] = 0;
780 }
781
782 return image;
783}
784
785void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
786{
787 wxCHECK_RET( Ok(), wxT("invalid image") );
788
789 int w = M_IMGDATA->m_width;
790 int h = M_IMGDATA->m_height;
791
792 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );
793
794 long pos = (y * w + x) * 3;
795
796 M_IMGDATA->m_data[ pos ] = r;
797 M_IMGDATA->m_data[ pos+1 ] = g;
798 M_IMGDATA->m_data[ pos+2 ] = b;
799}
800
801void wxImage::SetRGB( const wxRect& rect_, unsigned char r, unsigned char g, unsigned char b )
802{
803 wxCHECK_RET( Ok(), wxT("invalid image") );
804
805 wxRect rect(rect_);
806 wxRect imageRect(0, 0, GetWidth(), GetHeight());
807 if ( rect == wxRect() )
808 {
809 rect = imageRect;
810 }
811 else
812 {
813 wxCHECK_RET( imageRect.Inside(rect.GetTopLeft()) &&
814 imageRect.Inside(rect.GetBottomRight()),
815 wxT("invalid bounding rectangle") );
816 }
817
818 int x1 = rect.GetLeft(),
819 y1 = rect.GetTop(),
820 x2 = rect.GetRight() + 1,
821 y2 = rect.GetBottom() + 1;
822
823 unsigned char *data wxDUMMY_INITIALIZE(NULL);
824 int x, y, width = GetWidth();
825 for (y = y1; y < y2; y++)
826 {
827 data = M_IMGDATA->m_data + (y*width + x1)*3;
828 for (x = x1; x < x2; x++)
829 {
830 *data++ = r;
831 *data++ = g;
832 *data++ = b;
833 }
834 }
835}
836
837unsigned char wxImage::GetRed( int x, int y ) const
838{
839 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
840
841 int w = M_IMGDATA->m_width;
842 int h = M_IMGDATA->m_height;
843
844 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
845
846 long pos = (y * w + x) * 3;
847
848 return M_IMGDATA->m_data[pos];
849}
850
851unsigned char wxImage::GetGreen( int x, int y ) const
852{
853 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
854
855 int w = M_IMGDATA->m_width;
856 int h = M_IMGDATA->m_height;
857
858 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
859
860 long pos = (y * w + x) * 3;
861
862 return M_IMGDATA->m_data[pos+1];
863}
864
865unsigned char wxImage::GetBlue( int x, int y ) const
866{
867 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
868
869 int w = M_IMGDATA->m_width;
870 int h = M_IMGDATA->m_height;
871
872 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
873
874 long pos = (y * w + x) * 3;
875
876 return M_IMGDATA->m_data[pos+2];
877}
878
879bool wxImage::Ok() const
880{
881 // image of 0 width or height can't be considered ok - at least because it
882 // causes crashes in ConvertToBitmap() if we don't catch it in time
883 wxImageRefData *data = M_IMGDATA;
884 return data && data->m_ok && data->m_width && data->m_height;
885}
886
887unsigned char *wxImage::GetData() const
888{
889 wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
890
891 return M_IMGDATA->m_data;
892}
893
894void wxImage::SetData( unsigned char *data, bool static_data )
895{
896 wxCHECK_RET( Ok(), wxT("invalid image") );
897
898 wxImageRefData *newRefData = new wxImageRefData();
899
900 newRefData->m_width = M_IMGDATA->m_width;
901 newRefData->m_height = M_IMGDATA->m_height;
902 newRefData->m_data = data;
903 newRefData->m_ok = true;
904 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
905 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
906 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
907 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
908 newRefData->m_static = static_data;
909
910 UnRef();
911
912 m_refData = newRefData;
913}
914
915void wxImage::SetData( unsigned char *data, int new_width, int new_height, bool static_data )
916{
917 wxImageRefData *newRefData = new wxImageRefData();
918
919 if (m_refData)
920 {
921 newRefData->m_width = new_width;
922 newRefData->m_height = new_height;
923 newRefData->m_data = data;
924 newRefData->m_ok = true;
925 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
926 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
927 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
928 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
929 }
930 else
931 {
932 newRefData->m_width = new_width;
933 newRefData->m_height = new_height;
934 newRefData->m_data = data;
935 newRefData->m_ok = true;
936 }
937 newRefData->m_static = static_data;
938
939 UnRef();
940
941 m_refData = newRefData;
942}
943
944// ----------------------------------------------------------------------------
945// alpha channel support
946// ----------------------------------------------------------------------------
947
948void wxImage::SetAlpha(int x, int y, unsigned char alpha)
949{
950 wxCHECK_RET( Ok() && HasAlpha(), wxT("invalid image or no alpha channel") );
951
952 int w = M_IMGDATA->m_width,
953 h = M_IMGDATA->m_height;
954
955 wxCHECK_RET( x >=0 && y >= 0 && x < w && y < h, wxT("invalid image index") );
956
957 M_IMGDATA->m_alpha[y*w + x] = alpha;
958}
959
960unsigned char wxImage::GetAlpha(int x, int y) const
961{
962 wxCHECK_MSG( Ok() && HasAlpha(), 0, wxT("invalid image or no alpha channel") );
963
964 int w = M_IMGDATA->m_width,
965 h = M_IMGDATA->m_height;
966
967 wxCHECK_MSG( x >=0 && y >= 0 && x < w && y < h, 0, wxT("invalid image index") );
968
969 return M_IMGDATA->m_alpha[y*w + x];
970}
971
972bool wxImage::ConvertColourToAlpha( unsigned char r, unsigned char g, unsigned char b )
973{
974 SetAlpha( NULL );
975
976 int w = M_IMGDATA->m_width,
977 h = M_IMGDATA->m_height;
978
979 unsigned char *alpha = GetAlpha();
980 unsigned char *data = GetData();
981
982 int x,y;
983 for (y = 0; y < h; y++)
984 for (x = 0; x < w; x++)
985 {
986 *alpha = *data;
987 alpha++;
988 *data = r;
989 data++;
990 *data = g;
991 data++;
992 *data = b;
993 data++;
994 }
995
996 return true;
997}
998
999void wxImage::SetAlpha( unsigned char *alpha, bool static_data )
1000{
1001 wxCHECK_RET( Ok(), wxT("invalid image") );
1002
1003 if ( !alpha )
1004 {
1005 alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
1006 }
1007
1008 free(M_IMGDATA->m_alpha);
1009 M_IMGDATA->m_alpha = alpha;
1010 M_IMGDATA->m_static = static_data;
1011
1012}
1013
1014unsigned char *wxImage::GetAlpha() const
1015{
1016 wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1017
1018 return M_IMGDATA->m_alpha;
1019}
1020
1021void wxImage::InitAlpha()
1022{
1023 wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1024
1025 // initialize memory for alpha channel
1026 SetAlpha();
1027
1028 unsigned char *alpha = M_IMGDATA->m_alpha;
1029 const size_t lenAlpha = M_IMGDATA->m_width * M_IMGDATA->m_height;
1030
1031 static const unsigned char ALPHA_TRANSPARENT = 0;
1032 static const unsigned char ALPHA_OPAQUE = 0xff;
1033 if ( HasMask() )
1034 {
1035 // use the mask to initialize the alpha channel.
1036 const unsigned char * const alphaEnd = alpha + lenAlpha;
1037
1038 const unsigned char mr = M_IMGDATA->m_maskRed;
1039 const unsigned char mg = M_IMGDATA->m_maskGreen;
1040 const unsigned char mb = M_IMGDATA->m_maskBlue;
1041 for ( unsigned char *src = M_IMGDATA->m_data;
1042 alpha < alphaEnd;
1043 src += 3, alpha++ )
1044 {
1045 *alpha = (src[0] == mr && src[1] == mg && src[2] == mb)
1046 ? ALPHA_TRANSPARENT
1047 : ALPHA_OPAQUE;
1048 }
1049
1050 M_IMGDATA->m_hasMask = false;
1051 }
1052 else // no mask
1053 {
1054 // make the image fully opaque
1055 memset(alpha, ALPHA_OPAQUE, lenAlpha);
1056 }
1057}
1058
1059// ----------------------------------------------------------------------------
1060// mask support
1061// ----------------------------------------------------------------------------
1062
1063void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
1064{
1065 wxCHECK_RET( Ok(), wxT("invalid image") );
1066
1067 M_IMGDATA->m_maskRed = r;
1068 M_IMGDATA->m_maskGreen = g;
1069 M_IMGDATA->m_maskBlue = b;
1070 M_IMGDATA->m_hasMask = true;
1071}
1072
1073bool wxImage::GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const
1074{
1075 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1076
1077 if (M_IMGDATA->m_hasMask)
1078 {
1079 if (r) *r = M_IMGDATA->m_maskRed;
1080 if (g) *g = M_IMGDATA->m_maskGreen;
1081 if (b) *b = M_IMGDATA->m_maskBlue;
1082 return true;
1083 }
1084 else
1085 {
1086 FindFirstUnusedColour(r, g, b);
1087 return false;
1088 }
1089}
1090
1091unsigned char wxImage::GetMaskRed() const
1092{
1093 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1094
1095 return M_IMGDATA->m_maskRed;
1096}
1097
1098unsigned char wxImage::GetMaskGreen() const
1099{
1100 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1101
1102 return M_IMGDATA->m_maskGreen;
1103}
1104
1105unsigned char wxImage::GetMaskBlue() const
1106{
1107 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1108
1109 return M_IMGDATA->m_maskBlue;
1110}
1111
1112void wxImage::SetMask( bool mask )
1113{
1114 wxCHECK_RET( Ok(), wxT("invalid image") );
1115
1116 M_IMGDATA->m_hasMask = mask;
1117}
1118
1119bool wxImage::HasMask() const
1120{
1121 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1122
1123 return M_IMGDATA->m_hasMask;
1124}
1125
1126int wxImage::GetWidth() const
1127{
1128 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1129
1130 return M_IMGDATA->m_width;
1131}
1132
1133int wxImage::GetHeight() const
1134{
1135 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1136
1137 return M_IMGDATA->m_height;
1138}
1139
1140bool wxImage::SetMaskFromImage(const wxImage& mask,
1141 unsigned char mr, unsigned char mg, unsigned char mb)
1142{
1143 // check that the images are the same size
1144 if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
1145 {
1146 wxLogError( _("Image and mask have different sizes.") );
1147 return false;
1148 }
1149
1150 // find unused colour
1151 unsigned char r,g,b ;
1152 if (!FindFirstUnusedColour(&r, &g, &b))
1153 {
1154 wxLogError( _("No unused colour in image being masked.") );
1155 return false ;
1156 }
1157
1158 unsigned char *imgdata = GetData();
1159 unsigned char *maskdata = mask.GetData();
1160
1161 const int w = GetWidth();
1162 const int h = GetHeight();
1163
1164 for (int j = 0; j < h; j++)
1165 {
1166 for (int i = 0; i < w; i++)
1167 {
1168 if ((maskdata[0] == mr) && (maskdata[1] == mg) && (maskdata[2] == mb))
1169 {
1170 imgdata[0] = r;
1171 imgdata[1] = g;
1172 imgdata[2] = b;
1173 }
1174 imgdata += 3;
1175 maskdata += 3;
1176 }
1177 }
1178
1179 SetMaskColour(r, g, b);
1180 SetMask(true);
1181
1182 return true;
1183}
1184
1185bool wxImage::ConvertAlphaToMask(unsigned char threshold)
1186{
1187 if (!HasAlpha())
1188 return true;
1189
1190 unsigned char mr, mg, mb;
1191 if (!FindFirstUnusedColour(&mr, &mg, &mb))
1192 {
1193 wxLogError( _("No unused colour in image being masked.") );
1194 return false;
1195 }
1196
1197 SetMask(true);
1198 SetMaskColour(mr, mg, mb);
1199
1200 unsigned char *imgdata = GetData();
1201 unsigned char *alphadata = GetAlpha();
1202
1203 int w = GetWidth();
1204 int h = GetHeight();
1205
1206 for (int y = 0; y < h; y++)
1207 {
1208 for (int x = 0; x < w; x++, imgdata += 3, alphadata++)
1209 {
1210 if (*alphadata < threshold)
1211 {
1212 imgdata[0] = mr;
1213 imgdata[1] = mg;
1214 imgdata[2] = mb;
1215 }
1216 }
1217 }
1218
1219 free(M_IMGDATA->m_alpha);
1220 M_IMGDATA->m_alpha = NULL;
1221
1222 return true;
1223}
1224
1225#if wxUSE_PALETTE
1226
1227// Palette functions
1228
1229bool wxImage::HasPalette() const
1230{
1231 if (!Ok())
1232 return false;
1233
1234 return M_IMGDATA->m_palette.Ok();
1235}
1236
1237const wxPalette& wxImage::GetPalette() const
1238{
1239 wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
1240
1241 return M_IMGDATA->m_palette;
1242}
1243
1244void wxImage::SetPalette(const wxPalette& palette)
1245{
1246 wxCHECK_RET( Ok(), wxT("invalid image") );
1247
1248 M_IMGDATA->m_palette = palette;
1249}
1250
1251#endif // wxUSE_PALETTE
1252
1253// Option functions (arbitrary name/value mapping)
1254void wxImage::SetOption(const wxString& name, const wxString& value)
1255{
1256 wxCHECK_RET( Ok(), wxT("invalid image") );
1257
1258 int idx = M_IMGDATA->m_optionNames.Index(name, false);
1259 if (idx == wxNOT_FOUND)
1260 {
1261 M_IMGDATA->m_optionNames.Add(name);
1262 M_IMGDATA->m_optionValues.Add(value);
1263 }
1264 else
1265 {
1266 M_IMGDATA->m_optionNames[idx] = name;
1267 M_IMGDATA->m_optionValues[idx] = value;
1268 }
1269}
1270
1271void wxImage::SetOption(const wxString& name, int value)
1272{
1273 wxString valStr;
1274 valStr.Printf(wxT("%d"), value);
1275 SetOption(name, valStr);
1276}
1277
1278wxString wxImage::GetOption(const wxString& name) const
1279{
1280 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
1281
1282 int idx = M_IMGDATA->m_optionNames.Index(name, false);
1283 if (idx == wxNOT_FOUND)
1284 return wxEmptyString;
1285 else
1286 return M_IMGDATA->m_optionValues[idx];
1287}
1288
1289int wxImage::GetOptionInt(const wxString& name) const
1290{
1291 return wxAtoi(GetOption(name));
1292}
1293
1294bool wxImage::HasOption(const wxString& name) const
1295{
1296 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1297
1298 return (M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND);
1299}
1300
1301bool wxImage::LoadFile( const wxString& filename, long type, int index )
1302{
1303#if wxUSE_STREAMS
1304 if (wxFileExists(filename))
1305 {
1306 wxFileInputStream stream(filename);
1307 wxBufferedInputStream bstream( stream );
1308 return LoadFile(bstream, type, index);
1309 }
1310 else
1311 {
1312 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
1313
1314 return false;
1315 }
1316#else // !wxUSE_STREAMS
1317 return false;
1318#endif // wxUSE_STREAMS
1319}
1320
1321bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype, int index )
1322{
1323#if wxUSE_STREAMS
1324 if (wxFileExists(filename))
1325 {
1326 wxFileInputStream stream(filename);
1327 wxBufferedInputStream bstream( stream );
1328 return LoadFile(bstream, mimetype, index);
1329 }
1330 else
1331 {
1332 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
1333
1334 return false;
1335 }
1336#else // !wxUSE_STREAMS
1337 return false;
1338#endif // wxUSE_STREAMS
1339}
1340
1341
1342
1343bool wxImage::SaveFile( const wxString& filename ) const
1344{
1345 wxString ext = filename.AfterLast('.').Lower();
1346
1347 wxImageHandler * pHandler = FindHandler(ext, -1);
1348 if (pHandler)
1349 {
1350 SaveFile(filename, pHandler->GetType());
1351 return true;
1352 }
1353
1354 wxLogError(_("Can't save image to file '%s': unknown extension."), filename.c_str());
1355
1356 return false;
1357}
1358
1359bool wxImage::SaveFile( const wxString& filename, int type ) const
1360{
1361#if wxUSE_STREAMS
1362 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1363
1364 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
1365
1366 wxFileOutputStream stream(filename);
1367
1368 if ( stream.IsOk() )
1369 {
1370 wxBufferedOutputStream bstream( stream );
1371 return SaveFile(bstream, type);
1372 }
1373#endif // wxUSE_STREAMS
1374
1375 return false;
1376}
1377
1378bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype ) const
1379{
1380#if wxUSE_STREAMS
1381 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1382
1383 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
1384
1385 wxFileOutputStream stream(filename);
1386
1387 if ( stream.IsOk() )
1388 {
1389 wxBufferedOutputStream bstream( stream );
1390 return SaveFile(bstream, mimetype);
1391 }
1392#endif // wxUSE_STREAMS
1393
1394 return false;
1395}
1396
1397bool wxImage::CanRead( const wxString &name )
1398{
1399#if wxUSE_STREAMS
1400 wxFileInputStream stream(name);
1401 return CanRead(stream);
1402#else
1403 return false;
1404#endif
1405}
1406
1407int wxImage::GetImageCount( const wxString &name, long type )
1408{
1409#if wxUSE_STREAMS
1410 wxFileInputStream stream(name);
1411 if (stream.Ok())
1412 return GetImageCount(stream, type);
1413#endif
1414
1415 return 0;
1416}
1417
1418#if wxUSE_STREAMS
1419
1420bool wxImage::CanRead( wxInputStream &stream )
1421{
1422 const wxList& list = GetHandlers();
1423
1424 for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
1425 {
1426 wxImageHandler *handler=(wxImageHandler*)node->GetData();
1427 if (handler->CanRead( stream ))
1428 return true;
1429 }
1430
1431 return false;
1432}
1433
1434int wxImage::GetImageCount( wxInputStream &stream, long type )
1435{
1436 wxImageHandler *handler;
1437
1438 if ( type == wxBITMAP_TYPE_ANY )
1439 {
1440 wxList &list=GetHandlers();
1441
1442 for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
1443 {
1444 handler=(wxImageHandler*)node->GetData();
1445 if ( handler->CanRead(stream) )
1446 return handler->GetImageCount(stream);
1447
1448 }
1449
1450 wxLogWarning(_("No handler found for image type."));
1451 return 0;
1452 }
1453
1454 handler = FindHandler(type);
1455
1456 if ( !handler )
1457 {
1458 wxLogWarning(_("No image handler for type %d defined."), type);
1459 return false;
1460 }
1461
1462 if ( handler->CanRead(stream) )
1463 {
1464 return handler->GetImageCount(stream);
1465 }
1466 else
1467 {
1468 wxLogError(_("Image file is not of type %d."), type);
1469 return 0;
1470 }
1471}
1472
1473bool wxImage::LoadFile( wxInputStream& stream, long type, int index )
1474{
1475 UnRef();
1476
1477 m_refData = new wxImageRefData;
1478
1479 wxImageHandler *handler;
1480
1481 if ( type == wxBITMAP_TYPE_ANY )
1482 {
1483 wxList &list=GetHandlers();
1484
1485 for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
1486 {
1487 handler=(wxImageHandler*)node->GetData();
1488 if ( handler->CanRead(stream) )
1489 return handler->LoadFile(this, stream, true/*verbose*/, index);
1490
1491 }
1492
1493 wxLogWarning( _("No handler found for image type.") );
1494 return false;
1495 }
1496
1497 handler = FindHandler(type);
1498
1499 if (handler == 0)
1500 {
1501 wxLogWarning( _("No image handler for type %d defined."), type );
1502
1503 return false;
1504 }
1505
1506 return handler->LoadFile(this, stream, true/*verbose*/, index);
1507}
1508
1509bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
1510{
1511 UnRef();
1512
1513 m_refData = new wxImageRefData;
1514
1515 wxImageHandler *handler = FindHandlerMime(mimetype);
1516
1517 if (handler == 0)
1518 {
1519 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
1520
1521 return false;
1522 }
1523
1524 return handler->LoadFile( this, stream, true/*verbose*/, index );
1525}
1526
1527bool wxImage::SaveFile( wxOutputStream& stream, int type ) const
1528{
1529 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1530
1531 wxImageHandler *handler = FindHandler(type);
1532 if ( !handler )
1533 {
1534 wxLogWarning( _("No image handler for type %d defined."), type );
1535
1536 return false;
1537 }
1538
1539 return handler->SaveFile( (wxImage*)this, stream );
1540}
1541
1542bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
1543{
1544 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1545
1546 wxImageHandler *handler = FindHandlerMime(mimetype);
1547 if ( !handler )
1548 {
1549 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
1550
1551 return false;
1552 }
1553
1554 return handler->SaveFile( (wxImage*)this, stream );
1555}
1556#endif // wxUSE_STREAMS
1557
1558void wxImage::AddHandler( wxImageHandler *handler )
1559{
1560 // Check for an existing handler of the type being added.
1561 if (FindHandler( handler->GetType() ) == 0)
1562 {
1563 sm_handlers.Append( handler );
1564 }
1565 else
1566 {
1567 // This is not documented behaviour, merely the simplest 'fix'
1568 // for preventing duplicate additions. If someone ever has
1569 // a good reason to add and remove duplicate handlers (and they
1570 // may) we should probably refcount the duplicates.
1571 // also an issue in InsertHandler below.
1572
1573 wxLogDebug( _T("Adding duplicate image handler for '%s'"),
1574 handler->GetName().c_str() );
1575 delete handler;
1576 }
1577}
1578
1579void wxImage::InsertHandler( wxImageHandler *handler )
1580{
1581 // Check for an existing handler of the type being added.
1582 if (FindHandler( handler->GetType() ) == 0)
1583 {
1584 sm_handlers.Insert( handler );
1585 }
1586 else
1587 {
1588 // see AddHandler for additional comments.
1589 wxLogDebug( _T("Inserting duplicate image handler for '%s'"),
1590 handler->GetName().c_str() );
1591 delete handler;
1592 }
1593}
1594
1595bool wxImage::RemoveHandler( const wxString& name )
1596{
1597 wxImageHandler *handler = FindHandler(name);
1598 if (handler)
1599 {
1600 sm_handlers.DeleteObject(handler);
1601 delete handler;
1602 return true;
1603 }
1604 else
1605 return false;
1606}
1607
1608wxImageHandler *wxImage::FindHandler( const wxString& name )
1609{
1610 wxList::compatibility_iterator node = sm_handlers.GetFirst();
1611 while (node)
1612 {
1613 wxImageHandler *handler = (wxImageHandler*)node->GetData();
1614 if (handler->GetName().Cmp(name) == 0) return handler;
1615
1616 node = node->GetNext();
1617 }
1618 return 0;
1619}
1620
1621wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
1622{
1623 wxList::compatibility_iterator node = sm_handlers.GetFirst();
1624 while (node)
1625 {
1626 wxImageHandler *handler = (wxImageHandler*)node->GetData();
1627 if ( (handler->GetExtension().Cmp(extension) == 0) &&
1628 (bitmapType == -1 || handler->GetType() == bitmapType) )
1629 return handler;
1630 node = node->GetNext();
1631 }
1632 return 0;
1633}
1634
1635wxImageHandler *wxImage::FindHandler( long bitmapType )
1636{
1637 wxList::compatibility_iterator node = sm_handlers.GetFirst();
1638 while (node)
1639 {
1640 wxImageHandler *handler = (wxImageHandler *)node->GetData();
1641 if (handler->GetType() == bitmapType) return handler;
1642 node = node->GetNext();
1643 }
1644 return 0;
1645}
1646
1647wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
1648{
1649 wxList::compatibility_iterator node = sm_handlers.GetFirst();
1650 while (node)
1651 {
1652 wxImageHandler *handler = (wxImageHandler *)node->GetData();
1653 if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler;
1654 node = node->GetNext();
1655 }
1656 return 0;
1657}
1658
1659void wxImage::InitStandardHandlers()
1660{
1661#if wxUSE_STREAMS
1662 AddHandler(new wxBMPHandler);
1663#endif // wxUSE_STREAMS
1664}
1665
1666void wxImage::CleanUpHandlers()
1667{
1668 wxList::compatibility_iterator node = sm_handlers.GetFirst();
1669 while (node)
1670 {
1671 wxImageHandler *handler = (wxImageHandler *)node->GetData();
1672 wxList::compatibility_iterator next = node->GetNext();
1673 delete handler;
1674 node = next;
1675 }
1676
1677 sm_handlers.Clear();
1678}
1679
1680wxString wxImage::GetImageExtWildcard()
1681{
1682 wxString fmts;
1683
1684 wxList& Handlers = wxImage::GetHandlers();
1685 wxList::compatibility_iterator Node = Handlers.GetFirst();
1686 while ( Node )
1687 {
1688 wxImageHandler* Handler = (wxImageHandler*)Node->GetData();
1689 fmts += wxT("*.") + Handler->GetExtension();
1690 Node = Node->GetNext();
1691 if ( Node ) fmts += wxT(";");
1692 }
1693
1694 return wxT("(") + fmts + wxT(")|") + fmts;
1695}
1696
1697//-----------------------------------------------------------------------------
1698// wxImageHandler
1699//-----------------------------------------------------------------------------
1700
1701IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
1702
1703#if wxUSE_STREAMS
1704bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
1705{
1706 return false;
1707}
1708
1709bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
1710{
1711 return false;
1712}
1713
1714int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
1715{
1716 return 1;
1717}
1718
1719bool wxImageHandler::CanRead( const wxString& name )
1720{
1721 if (wxFileExists(name))
1722 {
1723 wxFileInputStream stream(name);
1724 return CanRead(stream);
1725 }
1726
1727 wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
1728
1729 return false;
1730}
1731
1732bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
1733{
1734 wxFileOffset posOld = stream.TellI();
1735 if ( posOld == wxInvalidOffset )
1736 {
1737 // can't test unseekable stream
1738 return false;
1739 }
1740
1741 bool ok = DoCanRead(stream);
1742
1743 // restore the old position to be able to test other formats and so on
1744 if ( stream.SeekI(posOld) == wxInvalidOffset )
1745 {
1746 wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!"));
1747
1748 // reading would fail anyhow as we're not at the right position
1749 return false;
1750 }
1751
1752 return ok;
1753}
1754
1755#endif // wxUSE_STREAMS
1756
1757// ----------------------------------------------------------------------------
1758// image histogram stuff
1759// ----------------------------------------------------------------------------
1760
1761bool
1762wxImageHistogram::FindFirstUnusedColour(unsigned char *r,
1763 unsigned char *g,
1764 unsigned char *b,
1765 unsigned char r2,
1766 unsigned char b2,
1767 unsigned char g2) const
1768{
1769 unsigned long key = MakeKey(r2, g2, b2);
1770
1771 while ( find(key) != end() )
1772 {
1773 // color already used
1774 r2++;
1775 if ( r2 >= 255 )
1776 {
1777 r2 = 0;
1778 g2++;
1779 if ( g2 >= 255 )
1780 {
1781 g2 = 0;
1782 b2++;
1783 if ( b2 >= 255 )
1784 {
1785 wxLogError(_("No unused colour in image.") );
1786 return false;
1787 }
1788 }
1789 }
1790
1791 key = MakeKey(r2, g2, b2);
1792 }
1793
1794 if ( r )
1795 *r = r2;
1796 if ( g )
1797 *g = g2;
1798 if ( b )
1799 *b = b2;
1800
1801 return true;
1802}
1803
1804bool
1805wxImage::FindFirstUnusedColour(unsigned char *r,
1806 unsigned char *g,
1807 unsigned char *b,
1808 unsigned char r2,
1809 unsigned char b2,
1810 unsigned char g2) const
1811{
1812 wxImageHistogram histogram;
1813
1814 ComputeHistogram(histogram);
1815
1816 return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2);
1817}
1818
1819
1820
1821// GRG, Dic/99
1822// Counts and returns the number of different colours. Optionally stops
1823// when it exceeds 'stopafter' different colours. This is useful, for
1824// example, to see if the image can be saved as 8-bit (256 colour or
1825// less, in this case it would be invoked as CountColours(256)). Default
1826// value for stopafter is -1 (don't care).
1827//
1828unsigned long wxImage::CountColours( unsigned long stopafter ) const
1829{
1830 wxHashTable h;
1831 wxObject dummy;
1832 unsigned char r, g, b;
1833 unsigned char *p;
1834 unsigned long size, nentries, key;
1835
1836 p = GetData();
1837 size = GetWidth() * GetHeight();
1838 nentries = 0;
1839
1840 for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
1841 {
1842 r = *(p++);
1843 g = *(p++);
1844 b = *(p++);
1845 key = wxImageHistogram::MakeKey(r, g, b);
1846
1847 if (h.Get(key) == NULL)
1848 {
1849 h.Put(key, &dummy);
1850 nentries++;
1851 }
1852 }
1853
1854 return nentries;
1855}
1856
1857
1858unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
1859{
1860 unsigned char *p = GetData();
1861 unsigned long nentries = 0;
1862
1863 h.clear();
1864
1865 const unsigned long size = GetWidth() * GetHeight();
1866
1867 unsigned char r, g, b;
1868 for ( unsigned long n = 0; n < size; n++ )
1869 {
1870 r = *p++;
1871 g = *p++;
1872 b = *p++;
1873
1874 wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)];
1875
1876 if ( entry.value++ == 0 )
1877 entry.index = nentries++;
1878 }
1879
1880 return nentries;
1881}
1882
1883/*
1884 * Rotation code by Carlos Moreno
1885 */
1886
1887// GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1888// does exactly the same thing. And I also got rid of wxRotationPixel
1889// bacause of potential problems in architectures where alignment
1890// is an issue, so I had to rewrite parts of the code.
1891
1892static const double gs_Epsilon = 1e-10;
1893
1894static inline int wxCint (double x)
1895{
1896 return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
1897}
1898
1899
1900// Auxiliary function to rotate a point (x,y) with respect to point p0
1901// make it inline and use a straight return to facilitate optimization
1902// also, the function receives the sine and cosine of the angle to avoid
1903// repeating the time-consuming calls to these functions -- sin/cos can
1904// be computed and stored in the calling function.
1905
1906inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
1907{
1908 return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
1909 p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
1910}
1911
1912inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
1913{
1914 return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
1915}
1916
1917wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
1918{
1919 int i;
1920 angle = -angle; // screen coordinates are a mirror image of "real" coordinates
1921
1922 bool has_alpha = HasAlpha();
1923
1924 // Create pointer-based array to accelerate access to wxImage's data
1925 unsigned char ** data = new unsigned char * [GetHeight()];
1926 data[0] = GetData();
1927 for (i = 1; i < GetHeight(); i++)
1928 data[i] = data[i - 1] + (3 * GetWidth());
1929
1930 // Same for alpha channel
1931 unsigned char ** alpha = NULL;
1932 if (has_alpha)
1933 {
1934 alpha = new unsigned char * [GetHeight()];
1935 alpha[0] = GetAlpha();
1936 for (i = 1; i < GetHeight(); i++)
1937 alpha[i] = alpha[i - 1] + GetWidth();
1938 }
1939
1940 // precompute coefficients for rotation formula
1941 // (sine and cosine of the angle)
1942 const double cos_angle = cos(angle);
1943 const double sin_angle = sin(angle);
1944
1945 // Create new Image to store the result
1946 // First, find rectangle that covers the rotated image; to do that,
1947 // rotate the four corners
1948
1949 const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
1950
1951 wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
1952 wxRealPoint p2 = rotated_point (0, GetHeight(), cos_angle, sin_angle, p0);
1953 wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
1954 wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
1955
1956 int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
1957 int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
1958 int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
1959 int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
1960
1961 // Create rotated image
1962 wxImage rotated (x2 - x1 + 1, y2 - y1 + 1, false);
1963 // With alpha channel
1964 if (has_alpha)
1965 rotated.SetAlpha();
1966
1967 if (offset_after_rotation != NULL)
1968 {
1969 *offset_after_rotation = wxPoint (x1, y1);
1970 }
1971
1972 // GRG: The rotated (destination) image is always accessed
1973 // sequentially, so there is no need for a pointer-based
1974 // array here (and in fact it would be slower).
1975 //
1976 unsigned char * dst = rotated.GetData();
1977
1978 unsigned char * alpha_dst = NULL;
1979 if (has_alpha)
1980 alpha_dst = rotated.GetAlpha();
1981
1982 // GRG: if the original image has a mask, use its RGB values
1983 // as the blank pixel, else, fall back to default (black).
1984 //
1985 unsigned char blank_r = 0;
1986 unsigned char blank_g = 0;
1987 unsigned char blank_b = 0;
1988
1989 if (HasMask())
1990 {
1991 blank_r = GetMaskRed();
1992 blank_g = GetMaskGreen();
1993 blank_b = GetMaskBlue();
1994 rotated.SetMaskColour( blank_r, blank_g, blank_b );
1995 }
1996
1997 // Now, for each point of the rotated image, find where it came from, by
1998 // performing an inverse rotation (a rotation of -angle) and getting the
1999 // pixel at those coordinates
2000
2001 // GRG: I've taken the (interpolating) test out of the loops, so that
2002 // it is done only once, instead of repeating it for each pixel.
2003
2004 int x;
2005 if (interpolating)
2006 {
2007 for (int y = 0; y < rotated.GetHeight(); y++)
2008 {
2009 for (x = 0; x < rotated.GetWidth(); x++)
2010 {
2011 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
2012
2013 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
2014 -0.25 < src.y && src.y < GetHeight() - 0.75)
2015 {
2016 // interpolate using the 4 enclosing grid-points. Those
2017 // points can be obtained using floor and ceiling of the
2018 // exact coordinates of the point
2019 // C.M. 2000-02-17: when the point is near the border, special care is required.
2020
2021 int x1, y1, x2, y2;
2022
2023 if (0 < src.x && src.x < GetWidth() - 1)
2024 {
2025 x1 = wxCint(floor(src.x));
2026 x2 = wxCint(ceil(src.x));
2027 }
2028 else // else means that x is near one of the borders (0 or width-1)
2029 {
2030 x1 = x2 = wxCint (src.x);
2031 }
2032
2033 if (0 < src.y && src.y < GetHeight() - 1)
2034 {
2035 y1 = wxCint(floor(src.y));
2036 y2 = wxCint(ceil(src.y));
2037 }
2038 else
2039 {
2040 y1 = y2 = wxCint (src.y);
2041 }
2042
2043 // get four points and the distances (square of the distance,
2044 // for efficiency reasons) for the interpolation formula
2045
2046 // GRG: Do not calculate the points until they are
2047 // really needed -- this way we can calculate
2048 // just one, instead of four, if d1, d2, d3
2049 // or d4 are < gs_Epsilon
2050
2051 const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
2052 const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
2053 const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
2054 const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
2055
2056 // Now interpolate as a weighted average of the four surrounding
2057 // points, where the weights are the distances to each of those points
2058
2059 // If the point is exactly at one point of the grid of the source
2060 // image, then don't interpolate -- just assign the pixel
2061
2062 if (d1 < gs_Epsilon) // d1,d2,d3,d4 are positive -- no need for abs()
2063 {
2064 unsigned char *p = data[y1] + (3 * x1);
2065 *(dst++) = *(p++);
2066 *(dst++) = *(p++);
2067 *(dst++) = *p;
2068
2069 if (has_alpha)
2070 {
2071 unsigned char *p = alpha[y1] + x1;
2072 *(alpha_dst++) = *p;
2073 }
2074 }
2075 else if (d2 < gs_Epsilon)
2076 {
2077 unsigned char *p = data[y1] + (3 * x2);
2078 *(dst++) = *(p++);
2079 *(dst++) = *(p++);
2080 *(dst++) = *p;
2081
2082 if (has_alpha)
2083 {
2084 unsigned char *p = alpha[y1] + x2;
2085 *(alpha_dst++) = *p;
2086 }
2087 }
2088 else if (d3 < gs_Epsilon)
2089 {
2090 unsigned char *p = data[y2] + (3 * x2);
2091 *(dst++) = *(p++);
2092 *(dst++) = *(p++);
2093 *(dst++) = *p;
2094
2095 if (has_alpha)
2096 {
2097 unsigned char *p = alpha[y2] + x2;
2098 *(alpha_dst++) = *p;
2099 }
2100 }
2101 else if (d4 < gs_Epsilon)
2102 {
2103 unsigned char *p = data[y2] + (3 * x1);
2104 *(dst++) = *(p++);
2105 *(dst++) = *(p++);
2106 *(dst++) = *p;
2107
2108 if (has_alpha)
2109 {
2110 unsigned char *p = alpha[y2] + x1;
2111 *(alpha_dst++) = *p;
2112 }
2113 }
2114 else
2115 {
2116 // weights for the weighted average are proportional to the inverse of the distance
2117 unsigned char *v1 = data[y1] + (3 * x1);
2118 unsigned char *v2 = data[y1] + (3 * x2);
2119 unsigned char *v3 = data[y2] + (3 * x2);
2120 unsigned char *v4 = data[y2] + (3 * x1);
2121
2122 const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
2123
2124 // GRG: Unrolled.
2125
2126 *(dst++) = (unsigned char)
2127 ( (w1 * *(v1++) + w2 * *(v2++) +
2128 w3 * *(v3++) + w4 * *(v4++)) /
2129 (w1 + w2 + w3 + w4) );
2130 *(dst++) = (unsigned char)
2131 ( (w1 * *(v1++) + w2 * *(v2++) +
2132 w3 * *(v3++) + w4 * *(v4++)) /
2133 (w1 + w2 + w3 + w4) );
2134 *(dst++) = (unsigned char)
2135 ( (w1 * *v1 + w2 * *v2 +
2136 w3 * *v3 + w4 * *v4) /
2137 (w1 + w2 + w3 + w4) );
2138
2139 if (has_alpha)
2140 {
2141 unsigned char *v1 = alpha[y1] + (x1);
2142 unsigned char *v2 = alpha[y1] + (x2);
2143 unsigned char *v3 = alpha[y2] + (x2);
2144 unsigned char *v4 = alpha[y2] + (x1);
2145
2146 *(alpha_dst++) = (unsigned char)
2147 ( (w1 * *v1 + w2 * *v2 +
2148 w3 * *v3 + w4 * *v4) /
2149 (w1 + w2 + w3 + w4) );
2150 }
2151 }
2152 }
2153 else
2154 {
2155 *(dst++) = blank_r;
2156 *(dst++) = blank_g;
2157 *(dst++) = blank_b;
2158
2159 if (has_alpha)
2160 *(alpha_dst++) = 0;
2161 }
2162 }
2163 }
2164 }
2165 else // not interpolating
2166 {
2167 for (int y = 0; y < rotated.GetHeight(); y++)
2168 {
2169 for (x = 0; x < rotated.GetWidth(); x++)
2170 {
2171 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
2172
2173 const int xs = wxCint (src.x); // wxCint rounds to the
2174 const int ys = wxCint (src.y); // closest integer
2175
2176 if (0 <= xs && xs < GetWidth() &&
2177 0 <= ys && ys < GetHeight())
2178 {
2179 unsigned char *p = data[ys] + (3 * xs);
2180 *(dst++) = *(p++);
2181 *(dst++) = *(p++);
2182 *(dst++) = *p;
2183
2184 if (has_alpha)
2185 {
2186 unsigned char *p = alpha[ys] + (xs);
2187 *(alpha_dst++) = *p;
2188 }
2189 }
2190 else
2191 {
2192 *(dst++) = blank_r;
2193 *(dst++) = blank_g;
2194 *(dst++) = blank_b;
2195
2196 if (has_alpha)
2197 *(alpha_dst++) = 255;
2198 }
2199 }
2200 }
2201 }
2202
2203 delete [] data;
2204
2205 if (has_alpha)
2206 delete [] alpha;
2207
2208 return rotated;
2209}
2210
2211
2212
2213
2214
2215// A module to allow wxImage initialization/cleanup
2216// without calling these functions from app.cpp or from
2217// the user's application.
2218
2219class wxImageModule: public wxModule
2220{
2221DECLARE_DYNAMIC_CLASS(wxImageModule)
2222public:
2223 wxImageModule() {}
2224 bool OnInit() { wxImage::InitStandardHandlers(); return true; };
2225 void OnExit() { wxImage::CleanUpHandlers(); };
2226};
2227
2228IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
2229
2230
2231#endif // wxUSE_IMAGE
wxWidgets (Impactor)