]> git.saurik.com Git - wxWidgets.git/blob - src/common/image.cpp
changed version number
[wxWidgets.git] / src / common / image.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: image.cpp
3 // Purpose: wxImage
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "image.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #include "wx/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
35 // For memcpy
36 #include <string.h>
37 #include <math.h>
38
39 #ifdef __SALFORDC__
40 #undef FAR
41 #endif
42
43
44 //-----------------------------------------------------------------------------
45 // wxImage
46 //-----------------------------------------------------------------------------
47
48 class wxImageRefData: public wxObjectRefData
49 {
50 public:
51 wxImageRefData();
52 ~wxImageRefData();
53
54 int m_width;
55 int m_height;
56 unsigned char *m_data;
57 bool m_hasMask;
58 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
59 bool m_ok;
60 bool m_static;
61 wxPalette m_palette;
62 wxArrayString m_optionNames;
63 wxArrayString m_optionValues;
64 };
65
66 wxImageRefData::wxImageRefData()
67 {
68 m_width = 0;
69 m_height = 0;
70 m_data = (unsigned char*) NULL;
71 m_ok = FALSE;
72 m_maskRed = 0;
73 m_maskGreen = 0;
74 m_maskBlue = 0;
75 m_hasMask = FALSE;
76 m_static = FALSE;
77 }
78
79 wxImageRefData::~wxImageRefData()
80 {
81 if (m_data && !m_static)
82 free( m_data );
83 }
84
85 wxList wxImage::sm_handlers;
86
87 wxImage wxNullImage;
88
89 //-----------------------------------------------------------------------------
90
91 #define M_IMGDATA ((wxImageRefData *)m_refData)
92
93 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
94
95 wxImage::wxImage()
96 {
97 }
98
99 wxImage::wxImage( int width, int height )
100 {
101 Create( width, height );
102 }
103
104 wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
105 {
106 Create( width, height, data, static_data );
107 }
108
109 wxImage::wxImage( const wxString& name, long type )
110 {
111 LoadFile( name, type );
112 }
113
114 wxImage::wxImage( const wxString& name, const wxString& mimetype )
115 {
116 LoadFile( name, mimetype );
117 }
118
119 #if wxUSE_STREAMS
120 wxImage::wxImage( wxInputStream& stream, long type )
121 {
122 LoadFile( stream, type );
123 }
124
125 wxImage::wxImage( wxInputStream& stream, const wxString& mimetype )
126 {
127 LoadFile( stream, mimetype );
128 }
129 #endif // wxUSE_STREAMS
130
131 wxImage::wxImage( const wxImage& image )
132 {
133 Ref(image);
134 }
135
136 wxImage::wxImage( const wxImage* image )
137 {
138 if (image) Ref(*image);
139 }
140
141 void wxImage::Create( int width, int height )
142 {
143 UnRef();
144
145 m_refData = new wxImageRefData();
146
147 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
148 if (M_IMGDATA->m_data)
149 {
150 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
151
152 M_IMGDATA->m_width = width;
153 M_IMGDATA->m_height = height;
154 M_IMGDATA->m_ok = TRUE;
155 }
156 else
157 {
158 UnRef();
159 }
160 }
161
162 void wxImage::Create( int width, int height, unsigned char* data, bool static_data )
163 {
164 UnRef();
165
166 m_refData = new wxImageRefData();
167
168 M_IMGDATA->m_data = data;
169 if (M_IMGDATA->m_data)
170 {
171 M_IMGDATA->m_width = width;
172 M_IMGDATA->m_height = height;
173 M_IMGDATA->m_ok = TRUE;
174 M_IMGDATA->m_static = static_data;
175 }
176 else
177 {
178 UnRef();
179 }
180 }
181
182 void wxImage::Destroy()
183 {
184 UnRef();
185 }
186
187 wxImage wxImage::Copy() const
188 {
189 wxImage image;
190
191 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
192
193 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
194
195 char unsigned *data = image.GetData();
196
197 wxCHECK_MSG( data, image, wxT("unable to create image") );
198
199 if (M_IMGDATA->m_hasMask)
200 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
201
202 memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
203
204 return image;
205 }
206
207 wxImage wxImage::Scale( int width, int height ) const
208 {
209 wxImage image;
210
211 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
212
213 wxCHECK_MSG( (width > 0) && (height > 0), image, wxT("invalid image size") );
214
215 image.Create( width, height );
216
217 char unsigned *data = image.GetData();
218
219 wxCHECK_MSG( data, image, wxT("unable to create image") );
220
221 if (M_IMGDATA->m_hasMask)
222 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
223
224 long old_height = M_IMGDATA->m_height;
225 long old_width = M_IMGDATA->m_width;
226
227 char unsigned *source_data = M_IMGDATA->m_data;
228 char unsigned *target_data = data;
229
230 for (long j = 0; j < height; j++)
231 {
232 long y_offset = (j * old_height / height) * old_width;
233
234 for (long i = 0; i < width; i++)
235 {
236 memcpy( target_data,
237 source_data + 3*(y_offset + ((i * old_width )/ width)),
238 3 );
239 target_data += 3;
240 }
241 }
242
243 return image;
244 }
245
246 wxImage wxImage::Rotate90( bool clockwise ) const
247 {
248 wxImage image;
249
250 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
251
252 image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width );
253
254 char unsigned *data = image.GetData();
255
256 wxCHECK_MSG( data, image, wxT("unable to create image") );
257
258 if (M_IMGDATA->m_hasMask)
259 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
260
261 long height = M_IMGDATA->m_height;
262 long width = M_IMGDATA->m_width;
263
264 char unsigned *source_data = M_IMGDATA->m_data;
265 char unsigned *target_data;
266
267 for (long j = 0; j < height; j++)
268 {
269 for (long i = 0; i < width; i++)
270 {
271 if (clockwise)
272 target_data = data + (((i+1)*height) - j - 1)*3;
273 else
274 target_data = data + ((height*(width-1)) + j - (i*height))*3;
275 memcpy( target_data, source_data, 3 );
276 source_data += 3;
277 }
278 }
279
280 return image;
281 }
282
283 wxImage wxImage::Mirror( bool horizontally ) const
284 {
285 wxImage image;
286
287 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
288
289 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
290
291 char unsigned *data = image.GetData();
292
293 wxCHECK_MSG( data, image, wxT("unable to create image") );
294
295 if (M_IMGDATA->m_hasMask)
296 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
297
298 long height = M_IMGDATA->m_height;
299 long width = M_IMGDATA->m_width;
300
301 char unsigned *source_data = M_IMGDATA->m_data;
302 char unsigned *target_data;
303
304 if (horizontally)
305 {
306 for (long j = 0; j < height; j++)
307 {
308 data += width*3;
309 target_data = data-3;
310 for (long i = 0; i < width; i++)
311 {
312 memcpy( target_data, source_data, 3 );
313 source_data += 3;
314 target_data -= 3;
315 }
316 }
317 }
318 else
319 {
320 for (long i = 0; i < height; i++)
321 {
322 target_data = data + 3*width*(height-1-i);
323 memcpy( target_data, source_data, (size_t)3*width );
324 source_data += 3*width;
325 }
326 }
327
328 return image;
329 }
330
331 wxImage wxImage::GetSubImage( const wxRect &rect ) const
332 {
333 wxImage image;
334
335 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
336
337 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
338 image, wxT("invalid subimage size") );
339
340 int subwidth=rect.GetWidth();
341 const int subheight=rect.GetHeight();
342
343 image.Create( subwidth, subheight );
344
345 char unsigned *subdata = image.GetData(), *data=GetData();
346
347 wxCHECK_MSG( subdata, image, wxT("unable to create image") );
348
349 if (M_IMGDATA->m_hasMask)
350 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
351
352 const int subleft=3*rect.GetLeft();
353 const int width=3*GetWidth();
354 subwidth*=3;
355
356 data+=rect.GetTop()*width+subleft;
357
358 for (long j = 0; j < subheight; ++j)
359 {
360 memcpy( subdata, data, subwidth);
361 subdata+=subwidth;
362 data+=width;
363 }
364
365 return image;
366 }
367
368 void wxImage::Paste( const wxImage &image, int x, int y )
369 {
370 wxCHECK_RET( Ok(), wxT("invalid image") );
371 wxCHECK_RET( image.Ok(), wxT("invalid image") );
372
373 int xx = 0;
374 int yy = 0;
375 int width = image.GetWidth();
376 int height = image.GetHeight();
377
378 if (x < 0)
379 {
380 xx = -x;
381 width += x;
382 }
383 if (y < 0)
384 {
385 yy = -y;
386 height += y;
387 }
388
389 if ((x+xx)+width > M_IMGDATA->m_width)
390 width = M_IMGDATA->m_width - (x+xx);
391 if ((y+yy)+height > M_IMGDATA->m_height)
392 height = M_IMGDATA->m_height - (y+yy);
393
394 if (width < 1) return;
395 if (height < 1) return;
396
397 if ((!HasMask() && !image.HasMask()) ||
398 ((HasMask() && image.HasMask() &&
399 (GetMaskRed()==image.GetMaskRed()) &&
400 (GetMaskGreen()==image.GetMaskGreen()) &&
401 (GetMaskBlue()==image.GetMaskBlue()))))
402 {
403 width *= 3;
404 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
405 int source_step = image.GetWidth()*3;
406
407 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
408 int target_step = M_IMGDATA->m_width*3;
409 for (int j = 0; j < height; j++)
410 {
411 memcpy( target_data, source_data, width );
412 source_data += source_step;
413 target_data += target_step;
414 }
415 return;
416 }
417
418 if (!HasMask() && image.HasMask())
419 {
420 unsigned char r = image.GetMaskRed();
421 unsigned char g = image.GetMaskGreen();
422 unsigned char b = image.GetMaskBlue();
423
424 width *= 3;
425 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
426 int source_step = image.GetWidth()*3;
427
428 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
429 int target_step = M_IMGDATA->m_width*3;
430
431 for (int j = 0; j < height; j++)
432 {
433 for (int i = 0; i < width; i+=3)
434 {
435 if ((source_data[i] != r) &&
436 (source_data[i+1] != g) &&
437 (source_data[i+2] != b))
438 {
439 memcpy( target_data+i, source_data+i, 3 );
440 }
441 }
442 source_data += source_step;
443 target_data += target_step;
444 }
445 }
446 }
447
448 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
449 unsigned char r2, unsigned char g2, unsigned char b2 )
450 {
451 wxCHECK_RET( Ok(), wxT("invalid image") );
452
453 char unsigned *data = GetData();
454
455 const int w = GetWidth();
456 const int h = GetHeight();
457
458 for (int j = 0; j < h; j++)
459 for (int i = 0; i < w; i++)
460 {
461 if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
462 {
463 data[0] = r2;
464 data[1] = g2;
465 data[2] = b2;
466 }
467 data += 3;
468 }
469 }
470
471 wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
472 {
473 wxImage image;
474
475 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
476
477 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
478
479 char unsigned *data = image.GetData();
480
481 wxCHECK_MSG( data, image, wxT("unable to create image") );
482
483 if (M_IMGDATA->m_hasMask)
484 {
485 if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
486 M_IMGDATA->m_maskBlue == b)
487 image.SetMaskColour( 255, 255, 255 );
488 else
489 image.SetMaskColour( 0, 0, 0 );
490 }
491
492 long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
493
494 char unsigned *srcd = M_IMGDATA->m_data;
495 char unsigned *tard = image.GetData();
496
497 for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
498 {
499 if (srcd[0] == r && srcd[1] == g && srcd[2] == b)
500 tard[0] = tard[1] = tard[2] = 255;
501 else
502 tard[0] = tard[1] = tard[2] = 0;
503 }
504
505 return image;
506 }
507
508 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
509 {
510 wxCHECK_RET( Ok(), wxT("invalid image") );
511
512 int w = M_IMGDATA->m_width;
513 int h = M_IMGDATA->m_height;
514
515 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );
516
517 long pos = (y * w + x) * 3;
518
519 M_IMGDATA->m_data[ pos ] = r;
520 M_IMGDATA->m_data[ pos+1 ] = g;
521 M_IMGDATA->m_data[ pos+2 ] = b;
522 }
523
524 unsigned char wxImage::GetRed( int x, int y ) const
525 {
526 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
527
528 int w = M_IMGDATA->m_width;
529 int h = M_IMGDATA->m_height;
530
531 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
532
533 long pos = (y * w + x) * 3;
534
535 return M_IMGDATA->m_data[pos];
536 }
537
538 unsigned char wxImage::GetGreen( int x, int y ) const
539 {
540 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
541
542 int w = M_IMGDATA->m_width;
543 int h = M_IMGDATA->m_height;
544
545 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
546
547 long pos = (y * w + x) * 3;
548
549 return M_IMGDATA->m_data[pos+1];
550 }
551
552 unsigned char wxImage::GetBlue( int x, int y ) const
553 {
554 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
555
556 int w = M_IMGDATA->m_width;
557 int h = M_IMGDATA->m_height;
558
559 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
560
561 long pos = (y * w + x) * 3;
562
563 return M_IMGDATA->m_data[pos+2];
564 }
565
566 bool wxImage::Ok() const
567 {
568 // image of 0 width or height can't be considered ok - at least because it
569 // causes crashes in ConvertToBitmap() if we don't catch it in time
570 wxImageRefData *data = M_IMGDATA;
571 return data && data->m_ok && data->m_width && data->m_height;
572 }
573
574 char unsigned *wxImage::GetData() const
575 {
576 wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );
577
578 return M_IMGDATA->m_data;
579 }
580
581 void wxImage::SetData( char unsigned *data )
582 {
583 wxCHECK_RET( Ok(), wxT("invalid image") );
584
585 wxImageRefData *newRefData = new wxImageRefData();
586
587 newRefData->m_width = M_IMGDATA->m_width;
588 newRefData->m_height = M_IMGDATA->m_height;
589 newRefData->m_data = data;
590 newRefData->m_ok = TRUE;
591 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
592 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
593 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
594 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
595
596 UnRef();
597
598 m_refData = newRefData;
599 }
600
601 void wxImage::SetData( char unsigned *data, int new_width, int new_height )
602 {
603 wxImageRefData *newRefData = new wxImageRefData();
604
605 if (m_refData)
606 {
607 newRefData->m_width = new_width;
608 newRefData->m_height = new_height;
609 newRefData->m_data = data;
610 newRefData->m_ok = TRUE;
611 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
612 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
613 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
614 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
615 }
616 else
617 {
618 newRefData->m_width = new_width;
619 newRefData->m_height = new_height;
620 newRefData->m_data = data;
621 newRefData->m_ok = TRUE;
622 }
623
624 UnRef();
625
626 m_refData = newRefData;
627 }
628
629 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
630 {
631 wxCHECK_RET( Ok(), wxT("invalid image") );
632
633 M_IMGDATA->m_maskRed = r;
634 M_IMGDATA->m_maskGreen = g;
635 M_IMGDATA->m_maskBlue = b;
636 M_IMGDATA->m_hasMask = TRUE;
637 }
638
639 unsigned char wxImage::GetMaskRed() const
640 {
641 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
642
643 return M_IMGDATA->m_maskRed;
644 }
645
646 unsigned char wxImage::GetMaskGreen() const
647 {
648 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
649
650 return M_IMGDATA->m_maskGreen;
651 }
652
653 unsigned char wxImage::GetMaskBlue() const
654 {
655 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
656
657 return M_IMGDATA->m_maskBlue;
658 }
659
660 void wxImage::SetMask( bool mask )
661 {
662 wxCHECK_RET( Ok(), wxT("invalid image") );
663
664 M_IMGDATA->m_hasMask = mask;
665 }
666
667 bool wxImage::HasMask() const
668 {
669 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
670
671 return M_IMGDATA->m_hasMask;
672 }
673
674 int wxImage::GetWidth() const
675 {
676 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
677
678 return M_IMGDATA->m_width;
679 }
680
681 int wxImage::GetHeight() const
682 {
683 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
684
685 return M_IMGDATA->m_height;
686 }
687
688 // Palette functions
689
690 bool wxImage::HasPalette() const
691 {
692 if (!Ok())
693 return FALSE;
694
695 return M_IMGDATA->m_palette.Ok();
696 }
697
698 const wxPalette& wxImage::GetPalette() const
699 {
700 wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
701
702 return M_IMGDATA->m_palette;
703 }
704
705 void wxImage::SetPalette(const wxPalette& palette)
706 {
707 wxCHECK_RET( Ok(), wxT("invalid image") );
708
709 M_IMGDATA->m_palette = palette;
710 }
711
712 // Option functions (arbitrary name/value mapping)
713 void wxImage::SetOption(const wxString& name, const wxString& value)
714 {
715 wxCHECK_RET( Ok(), wxT("invalid image") );
716
717 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
718 if (idx == wxNOT_FOUND)
719 {
720 M_IMGDATA->m_optionNames.Add(name);
721 M_IMGDATA->m_optionValues.Add(value);
722 }
723 else
724 {
725 M_IMGDATA->m_optionNames[idx] = name;
726 M_IMGDATA->m_optionValues[idx] = value;
727 }
728 }
729
730 void wxImage::SetOption(const wxString& name, int value)
731 {
732 wxString valStr;
733 valStr.Printf(wxT("%d"), value);
734 SetOption(name, valStr);
735 }
736
737 wxString wxImage::GetOption(const wxString& name) const
738 {
739 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
740
741 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
742 if (idx == wxNOT_FOUND)
743 return wxEmptyString;
744 else
745 return M_IMGDATA->m_optionValues[idx];
746 }
747
748 int wxImage::GetOptionInt(const wxString& name) const
749 {
750 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
751
752 return wxAtoi(GetOption(name));
753 }
754
755 bool wxImage::HasOption(const wxString& name) const
756 {
757 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
758
759 return (M_IMGDATA->m_optionNames.Index(name, FALSE) != wxNOT_FOUND);
760 }
761
762 bool wxImage::LoadFile( const wxString& filename, long type )
763 {
764 #if wxUSE_STREAMS
765 if (wxFileExists(filename))
766 {
767 wxFileInputStream stream(filename);
768 wxBufferedInputStream bstream( stream );
769 return LoadFile(bstream, type);
770 }
771 else
772 {
773 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
774
775 return FALSE;
776 }
777 #else // !wxUSE_STREAMS
778 return FALSE;
779 #endif // wxUSE_STREAMS
780 }
781
782 bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
783 {
784 #if wxUSE_STREAMS
785 if (wxFileExists(filename))
786 {
787 wxFileInputStream stream(filename);
788 wxBufferedInputStream bstream( stream );
789 return LoadFile(bstream, mimetype);
790 }
791 else
792 {
793 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
794
795 return FALSE;
796 }
797 #else // !wxUSE_STREAMS
798 return FALSE;
799 #endif // wxUSE_STREAMS
800 }
801
802 bool wxImage::SaveFile( const wxString& filename, int type )
803 {
804 #if wxUSE_STREAMS
805 wxFileOutputStream stream(filename);
806
807 if ( stream.LastError() == wxStream_NOERROR )
808 {
809 wxBufferedOutputStream bstream( stream );
810 return SaveFile(bstream, type);
811 }
812 #endif // wxUSE_STREAMS
813
814 return FALSE;
815 }
816
817 bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
818 {
819 #if wxUSE_STREAMS
820 wxFileOutputStream stream(filename);
821
822 if ( stream.LastError() == wxStream_NOERROR )
823 {
824 wxBufferedOutputStream bstream( stream );
825 return SaveFile(bstream, mimetype);
826 }
827 #endif // wxUSE_STREAMS
828
829 return FALSE;
830 }
831
832 bool wxImage::CanRead( const wxString &name )
833 {
834 #if wxUSE_STREAMS
835 wxFileInputStream stream(name);
836 return CanRead(stream);
837 #else
838 return FALSE;
839 #endif
840 }
841
842 #if wxUSE_STREAMS
843
844 bool wxImage::CanRead( wxInputStream &stream )
845 {
846 wxList &list=GetHandlers();
847
848 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
849 {
850 wxImageHandler *handler=(wxImageHandler*)node->GetData();
851 if (handler->CanRead( stream ))
852 return TRUE;
853 }
854
855 return FALSE;
856 }
857
858 bool wxImage::LoadFile( wxInputStream& stream, long type )
859 {
860 UnRef();
861
862 m_refData = new wxImageRefData;
863
864 wxImageHandler *handler;
865
866 if (type==wxBITMAP_TYPE_ANY)
867 {
868 wxList &list=GetHandlers();
869
870 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
871 {
872 handler=(wxImageHandler*)node->GetData();
873 if (handler->CanRead( stream ))
874 return handler->LoadFile( this, stream );
875
876 }
877
878 wxLogWarning( _("No handler found for image type.") );
879 return FALSE;
880 }
881
882 handler = FindHandler(type);
883
884 if (handler == NULL)
885 {
886 wxLogWarning( _("No image handler for type %d defined."), type );
887
888 return FALSE;
889 }
890
891 return handler->LoadFile( this, stream );
892 }
893
894 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
895 {
896 UnRef();
897
898 m_refData = new wxImageRefData;
899
900 wxImageHandler *handler = FindHandlerMime(mimetype);
901
902 if (handler == NULL)
903 {
904 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
905
906 return FALSE;
907 }
908
909 return handler->LoadFile( this, stream );
910 }
911
912 bool wxImage::SaveFile( wxOutputStream& stream, int type )
913 {
914 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
915
916 wxImageHandler *handler = FindHandler(type);
917
918 if (handler == NULL)
919 {
920 wxLogWarning( _("No image handler for type %d defined."), type );
921
922 return FALSE;
923 }
924
925 return handler->SaveFile( this, stream );
926 }
927
928 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
929 {
930 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
931
932 wxImageHandler *handler = FindHandlerMime(mimetype);
933
934 if (handler == NULL)
935 {
936 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
937
938 return FALSE;
939 }
940
941 return handler->SaveFile( this, stream );
942 }
943 #endif // wxUSE_STREAMS
944
945 void wxImage::AddHandler( wxImageHandler *handler )
946 {
947 // make sure that the memory will be freed at the program end
948 sm_handlers.DeleteContents(TRUE);
949
950 sm_handlers.Append( handler );
951 }
952
953 void wxImage::InsertHandler( wxImageHandler *handler )
954 {
955 // make sure that the memory will be freed at the program end
956 sm_handlers.DeleteContents(TRUE);
957
958 sm_handlers.Insert( handler );
959 }
960
961 bool wxImage::RemoveHandler( const wxString& name )
962 {
963 wxImageHandler *handler = FindHandler(name);
964 if (handler)
965 {
966 sm_handlers.DeleteObject(handler);
967 return TRUE;
968 }
969 else
970 return FALSE;
971 }
972
973 wxImageHandler *wxImage::FindHandler( const wxString& name )
974 {
975 wxNode *node = sm_handlers.First();
976 while (node)
977 {
978 wxImageHandler *handler = (wxImageHandler*)node->Data();
979 if (handler->GetName().Cmp(name) == 0) return handler;
980
981 node = node->Next();
982 }
983 return (wxImageHandler *)NULL;
984 }
985
986 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
987 {
988 wxNode *node = sm_handlers.First();
989 while (node)
990 {
991 wxImageHandler *handler = (wxImageHandler*)node->Data();
992 if ( (handler->GetExtension().Cmp(extension) == 0) &&
993 (bitmapType == -1 || handler->GetType() == bitmapType) )
994 return handler;
995 node = node->Next();
996 }
997 return (wxImageHandler*)NULL;
998 }
999
1000 wxImageHandler *wxImage::FindHandler( long bitmapType )
1001 {
1002 wxNode *node = sm_handlers.First();
1003 while (node)
1004 {
1005 wxImageHandler *handler = (wxImageHandler *)node->Data();
1006 if (handler->GetType() == bitmapType) return handler;
1007 node = node->Next();
1008 }
1009 return NULL;
1010 }
1011
1012 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
1013 {
1014 wxNode *node = sm_handlers.First();
1015 while (node)
1016 {
1017 wxImageHandler *handler = (wxImageHandler *)node->Data();
1018 if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
1019 node = node->Next();
1020 }
1021 return NULL;
1022 }
1023
1024 void wxImage::InitStandardHandlers()
1025 {
1026 AddHandler(new wxBMPHandler);
1027 #if !defined(__WXGTK__) && !defined(__WXMOTIF__)
1028 AddHandler(new wxXPMHandler);
1029 #endif
1030 }
1031
1032 void wxImage::CleanUpHandlers()
1033 {
1034 wxNode *node = sm_handlers.First();
1035 while (node)
1036 {
1037 wxImageHandler *handler = (wxImageHandler *)node->Data();
1038 wxNode *next = node->Next();
1039 delete handler;
1040 delete node;
1041 node = next;
1042 }
1043 }
1044
1045 //-----------------------------------------------------------------------------
1046 // wxImageHandler
1047 //-----------------------------------------------------------------------------
1048
1049 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
1050
1051 #if wxUSE_STREAMS
1052 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
1053 {
1054 return FALSE;
1055 }
1056
1057 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
1058 {
1059 return FALSE;
1060 }
1061
1062 int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
1063 {
1064 return 1;
1065 }
1066
1067 bool wxImageHandler::CanRead( const wxString& name )
1068 {
1069 if (wxFileExists(name))
1070 {
1071 wxFileInputStream stream(name);
1072 return CanRead(stream);
1073 }
1074
1075 else {
1076 wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
1077
1078 return FALSE;
1079 }
1080 // return FALSE;
1081 }
1082
1083 #endif // wxUSE_STREAMS
1084
1085
1086
1087 //-----------------------------------------------------------------------------
1088 // wxBitmap convertion routines
1089 //-----------------------------------------------------------------------------
1090
1091 #if wxUSE_GUI
1092
1093 #ifdef __WXGTK__
1094 wxBitmap wxImage::ConvertToMonoBitmap( unsigned char red, unsigned char green, unsigned char blue ) const
1095 {
1096 wxImage mono = this->ConvertToMono( red, green, blue );
1097 wxBitmap bitmap( mono, 1 );
1098 return bitmap;
1099 }
1100 #endif
1101
1102 wxBitmap wxImage::ConvertToBitmap() const
1103 {
1104 wxBitmap bitmap( *this );
1105 return bitmap;
1106 }
1107
1108 wxImage::wxImage( const wxBitmap &bitmap )
1109 {
1110 *this = bitmap.ConvertToImage();
1111 }
1112
1113 #endif
1114
1115
1116
1117 // A module to allow wxImage initialization/cleanup
1118 // without calling these functions from app.cpp or from
1119 // the user's application.
1120
1121 class wxImageModule: public wxModule
1122 {
1123 DECLARE_DYNAMIC_CLASS(wxImageModule)
1124 public:
1125 wxImageModule() {}
1126 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE; };
1127 void OnExit() { wxImage::CleanUpHandlers(); };
1128 };
1129
1130 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
1131
1132
1133 //-----------------------------------------------------------------------------
1134
1135 // GRG, Dic/99
1136 // Counts and returns the number of different colours. Optionally stops
1137 // when it exceeds 'stopafter' different colours. This is useful, for
1138 // example, to see if the image can be saved as 8-bit (256 colour or
1139 // less, in this case it would be invoked as CountColours(256)). Default
1140 // value for stopafter is -1 (don't care).
1141 //
1142 unsigned long wxImage::CountColours( unsigned long stopafter )
1143 {
1144 wxHashTable h;
1145 wxObject dummy;
1146 unsigned char r, g, b;
1147 unsigned char *p;
1148 unsigned long size, nentries, key;
1149
1150 p = GetData();
1151 size = GetWidth() * GetHeight();
1152 nentries = 0;
1153
1154 for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
1155 {
1156 r = *(p++);
1157 g = *(p++);
1158 b = *(p++);
1159 key = (r << 16) | (g << 8) | b;
1160
1161 if (h.Get(key) == NULL)
1162 {
1163 h.Put(key, &dummy);
1164 nentries++;
1165 }
1166 }
1167
1168 return nentries;
1169 }
1170
1171
1172 // GRG, Dic/99
1173 // Computes the histogram of the image and fills a hash table, indexed
1174 // with integer keys built as 0xRRGGBB, containing wxHNode objects. Each
1175 // wxHNode contains an 'index' (useful to build a palette with the image
1176 // colours) and a 'value', which is the number of pixels in the image with
1177 // that colour.
1178 //
1179 unsigned long wxImage::ComputeHistogram( wxHashTable &h )
1180 {
1181 unsigned char r, g, b;
1182 unsigned char *p;
1183 unsigned long size, nentries, key;
1184 wxHNode *hnode;
1185
1186 p = GetData();
1187 size = GetWidth() * GetHeight();
1188 nentries = 0;
1189
1190 for (unsigned long j = 0; j < size; j++)
1191 {
1192 r = *(p++);
1193 g = *(p++);
1194 b = *(p++);
1195 key = (r << 16) | (g << 8) | b;
1196
1197 hnode = (wxHNode *) h.Get(key);
1198
1199 if (hnode)
1200 hnode->value++;
1201 else
1202 {
1203 hnode = new wxHNode();
1204 hnode->index = nentries++;
1205 hnode->value = 1;
1206
1207 h.Put(key, (wxObject *)hnode);
1208 }
1209 }
1210
1211 return nentries;
1212 }
1213
1214 /*
1215 * Rotation code by Carlos Moreno
1216 */
1217
1218 // GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1219 // does exactly the same thing. And I also got rid of wxRotationPixel
1220 // bacause of potential problems in architectures where alignment
1221 // is an issue, so I had to rewrite parts of the code.
1222
1223 static const double gs_Epsilon = 1e-10;
1224
1225 static inline int wxCint (double x)
1226 {
1227 return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
1228 }
1229
1230
1231 // Auxiliary function to rotate a point (x,y) with respect to point p0
1232 // make it inline and use a straight return to facilitate optimization
1233 // also, the function receives the sine and cosine of the angle to avoid
1234 // repeating the time-consuming calls to these functions -- sin/cos can
1235 // be computed and stored in the calling function.
1236
1237 inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
1238 {
1239 return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
1240 p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
1241 }
1242
1243 inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
1244 {
1245 return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
1246 }
1247
1248 wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
1249 {
1250 int i;
1251 angle = -angle; // screen coordinates are a mirror image of "real" coordinates
1252
1253 // Create pointer-based array to accelerate access to wxImage's data
1254 unsigned char ** data = new unsigned char * [GetHeight()];
1255
1256 data[0] = GetData();
1257
1258 for (i = 1; i < GetHeight(); i++)
1259 data[i] = data[i - 1] + (3 * GetWidth());
1260
1261 // precompute coefficients for rotation formula
1262 // (sine and cosine of the angle)
1263 const double cos_angle = cos(angle);
1264 const double sin_angle = sin(angle);
1265
1266 // Create new Image to store the result
1267 // First, find rectangle that covers the rotated image; to do that,
1268 // rotate the four corners
1269
1270 const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
1271
1272 wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
1273 wxRealPoint p2 = rotated_point (0, GetHeight(), cos_angle, sin_angle, p0);
1274 wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
1275 wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
1276
1277 int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
1278 int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
1279 int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
1280 int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
1281
1282 wxImage rotated (x2 - x1 + 1, y2 - y1 + 1);
1283
1284 if (offset_after_rotation != NULL)
1285 {
1286 *offset_after_rotation = wxPoint (x1, y1);
1287 }
1288
1289 // GRG: The rotated (destination) image is always accessed
1290 // sequentially, so there is no need for a pointer-based
1291 // array here (and in fact it would be slower).
1292 //
1293 unsigned char * dst = rotated.GetData();
1294
1295 // GRG: if the original image has a mask, use its RGB values
1296 // as the blank pixel, else, fall back to default (black).
1297 //
1298 unsigned char blank_r = 0;
1299 unsigned char blank_g = 0;
1300 unsigned char blank_b = 0;
1301
1302 if (HasMask())
1303 {
1304 blank_r = GetMaskRed();
1305 blank_g = GetMaskGreen();
1306 blank_b = GetMaskBlue();
1307 rotated.SetMaskColour( blank_r, blank_g, blank_b );
1308 }
1309
1310 // Now, for each point of the rotated image, find where it came from, by
1311 // performing an inverse rotation (a rotation of -angle) and getting the
1312 // pixel at those coordinates
1313
1314 // GRG: I've taken the (interpolating) test out of the loops, so that
1315 // it is done only once, instead of repeating it for each pixel.
1316
1317 int x;
1318 if (interpolating)
1319 {
1320 for (int y = 0; y < rotated.GetHeight(); y++)
1321 {
1322 for (x = 0; x < rotated.GetWidth(); x++)
1323 {
1324 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
1325
1326 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
1327 -0.25 < src.y && src.y < GetHeight() - 0.75)
1328 {
1329 // interpolate using the 4 enclosing grid-points. Those
1330 // points can be obtained using floor and ceiling of the
1331 // exact coordinates of the point
1332 // C.M. 2000-02-17: when the point is near the border, special care is required.
1333
1334 int x1, y1, x2, y2;
1335
1336 if (0 < src.x && src.x < GetWidth() - 1)
1337 {
1338 x1 = wxCint(floor(src.x));
1339 x2 = wxCint(ceil(src.x));
1340 }
1341 else // else means that x is near one of the borders (0 or width-1)
1342 {
1343 x1 = x2 = wxCint (src.x);
1344 }
1345
1346 if (0 < src.y && src.y < GetHeight() - 1)
1347 {
1348 y1 = wxCint(floor(src.y));
1349 y2 = wxCint(ceil(src.y));
1350 }
1351 else
1352 {
1353 y1 = y2 = wxCint (src.y);
1354 }
1355
1356 // get four points and the distances (square of the distance,
1357 // for efficiency reasons) for the interpolation formula
1358
1359 // GRG: Do not calculate the points until they are
1360 // really needed -- this way we can calculate
1361 // just one, instead of four, if d1, d2, d3
1362 // or d4 are < gs_Epsilon
1363
1364 const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
1365 const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
1366 const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
1367 const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
1368
1369 // Now interpolate as a weighted average of the four surrounding
1370 // points, where the weights are the distances to each of those points
1371
1372 // If the point is exactly at one point of the grid of the source
1373 // image, then don't interpolate -- just assign the pixel
1374
1375 if (d1 < gs_Epsilon) // d1,d2,d3,d4 are positive -- no need for abs()
1376 {
1377 unsigned char *p = data[y1] + (3 * x1);
1378 *(dst++) = *(p++);
1379 *(dst++) = *(p++);
1380 *(dst++) = *(p++);
1381 }
1382 else if (d2 < gs_Epsilon)
1383 {
1384 unsigned char *p = data[y1] + (3 * x2);
1385 *(dst++) = *(p++);
1386 *(dst++) = *(p++);
1387 *(dst++) = *(p++);
1388 }
1389 else if (d3 < gs_Epsilon)
1390 {
1391 unsigned char *p = data[y2] + (3 * x2);
1392 *(dst++) = *(p++);
1393 *(dst++) = *(p++);
1394 *(dst++) = *(p++);
1395 }
1396 else if (d4 < gs_Epsilon)
1397 {
1398 unsigned char *p = data[y2] + (3 * x1);
1399 *(dst++) = *(p++);
1400 *(dst++) = *(p++);
1401 *(dst++) = *(p++);
1402 }
1403 else
1404 {
1405 // weights for the weighted average are proportional to the inverse of the distance
1406 unsigned char *v1 = data[y1] + (3 * x1);
1407 unsigned char *v2 = data[y1] + (3 * x2);
1408 unsigned char *v3 = data[y2] + (3 * x2);
1409 unsigned char *v4 = data[y2] + (3 * x1);
1410
1411 const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
1412
1413 // GRG: Unrolled.
1414
1415 *(dst++) = (unsigned char)
1416 ( (w1 * *(v1++) + w2 * *(v2++) +
1417 w3 * *(v3++) + w4 * *(v4++)) /
1418 (w1 + w2 + w3 + w4) );
1419 *(dst++) = (unsigned char)
1420 ( (w1 * *(v1++) + w2 * *(v2++) +
1421 w3 * *(v3++) + w4 * *(v4++)) /
1422 (w1 + w2 + w3 + w4) );
1423 *(dst++) = (unsigned char)
1424 ( (w1 * *(v1++) + w2 * *(v2++) +
1425 w3 * *(v3++) + w4 * *(v4++)) /
1426 (w1 + w2 + w3 + w4) );
1427 }
1428 }
1429 else
1430 {
1431 *(dst++) = blank_r;
1432 *(dst++) = blank_g;
1433 *(dst++) = blank_b;
1434 }
1435 }
1436 }
1437 }
1438 else // not interpolating
1439 {
1440 for (int y = 0; y < rotated.GetHeight(); y++)
1441 {
1442 for (x = 0; x < rotated.GetWidth(); x++)
1443 {
1444 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
1445
1446 const int xs = wxCint (src.x); // wxCint rounds to the
1447 const int ys = wxCint (src.y); // closest integer
1448
1449 if (0 <= xs && xs < GetWidth() &&
1450 0 <= ys && ys < GetHeight())
1451 {
1452 unsigned char *p = data[ys] + (3 * xs);
1453 *(dst++) = *(p++);
1454 *(dst++) = *(p++);
1455 *(dst++) = *(p++);
1456 }
1457 else
1458 {
1459 *(dst++) = blank_r;
1460 *(dst++) = blank_g;
1461 *(dst++) = blank_b;
1462 }
1463 }
1464 }
1465 }
1466
1467 delete [] data;
1468
1469 return rotated;
1470 }
1471
1472 #endif // wxUSE_IMAGE