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