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