]> git.saurik.com Git - wxWidgets.git/blob - src/common/image.cpp
projects / wxWidgets.git / blob
? search:


b0b91397f924be9c1022ee4270bf0d42c2a061e6
[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/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
34 #ifdef __SALFORDC__
35 #undef FAR
36 #endif
37
38 #ifdef __WXMSW__
39 #include "wx/msw/private.h"
40 #endif
41
42 //-----------------------------------------------------------------------------
43 // wxImage
44 //-----------------------------------------------------------------------------
45
46 class wxImageRefData: public wxObjectRefData
47 {
48
49 public:
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 };
60
61 wxImageRefData::wxImageRefData()
62 {
63 m_width = 0;
64 m_height = 0;
65 m_data = (unsigned char*) NULL;
66 m_ok = FALSE;
67 m_maskRed = 0;
68 m_maskGreen = 0;
69 m_maskBlue = 0;
70 m_hasMask = FALSE;
71 }
72
73 wxImageRefData::~wxImageRefData()
74 {
75 if (m_data) free( m_data );
76 }
77
78 wxList wxImage::sm_handlers;
79
80 //-----------------------------------------------------------------------------
81
82 #define M_IMGDATA ((wxImageRefData *)m_refData)
83
84 #if !USE_SHARED_LIBRARIES
85 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
86 #endif
87
88 wxImage::wxImage()
89 {
90 }
91
92 wxImage::wxImage( int width, int height )
93 {
94 Create( width, height );
95 }
96
97 wxImage::wxImage( const wxString& name, long type )
98 {
99 LoadFile( name, type );
100 }
101
102 wxImage::wxImage( const wxString& name, const wxString& mimetype )
103 {
104 LoadFile( name, mimetype );
105 }
106
107 #if wxUSE_STREAMS
108 wxImage::wxImage( wxInputStream& stream, long type )
109 {
110 LoadFile( stream, type );
111 }
112
113 wxImage::wxImage( wxInputStream& stream, const wxString& mimetype )
114 {
115 LoadFile( stream, mimetype );
116 }
117 #endif // wxUSE_STREAMS
118
119 wxImage::wxImage( const wxImage& image )
120 {
121 Ref(image);
122 }
123
124 wxImage::wxImage( const wxImage* image )
125 {
126 if (image) Ref(*image);
127 }
128
129 void wxImage::Create( int width, int height )
130 {
131 m_refData = new wxImageRefData();
132
133 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
134 if (M_IMGDATA->m_data)
135 {
136 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
137
138 M_IMGDATA->m_width = width;
139 M_IMGDATA->m_height = height;
140 M_IMGDATA->m_ok = TRUE;
141 }
142 else
143 {
144 UnRef();
145 }
146 }
147
148 void wxImage::Destroy()
149 {
150 UnRef();
151 }
152
153 wxImage wxImage::Scale( int width, int height ) const
154 {
155 wxImage image;
156
157 wxCHECK_MSG( Ok(), image, _T("invalid image") );
158
159 wxCHECK_MSG( (width > 0) && (height > 0), image, _T("invalid image size") );
160
161 image.Create( width, height );
162
163 char unsigned *data = image.GetData();
164
165 wxCHECK_MSG( data, image, _T("unable to create image") );
166
167 if (M_IMGDATA->m_hasMask)
168 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
169
170 long old_height = M_IMGDATA->m_height;
171 long old_width = M_IMGDATA->m_width;
172
173 char unsigned *source_data = M_IMGDATA->m_data;
174 char unsigned *target_data = data;
175
176 for (long j = 0; j < height; j++)
177 {
178 long y_offset = (j * old_height / height) * old_width;
179
180 for (long i = 0; i < width; i++)
181 {
182 memcpy( target_data,
183 source_data + 3*(y_offset + ((i * old_width )/ width)),
184 3 );
185 target_data += 3;
186 }
187 }
188
189 return image;
190 }
191
192 wxImage wxImage::GetSubImage( const wxRect &rect ) const
193 {
194 wxImage image;
195
196 wxCHECK_MSG( Ok(), image, _T("invalid image") );
197
198 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight())
199 , image, _T("invalid subimage size") );
200
201 int subwidth=rect.GetWidth();
202 const int subheight=rect.GetHeight();
203
204 image.Create( subwidth, subheight );
205
206 char unsigned *subdata = image.GetData(), *data=GetData();
207
208 wxCHECK_MSG( subdata, image, _T("unable to create image") );
209
210 if (M_IMGDATA->m_hasMask)
211 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
212
213 const int subleft=3*rect.GetLeft();
214 const int width=3*GetWidth();
215 subwidth*=3;
216
217 data+=rect.GetTop()*width+subleft;
218
219 for (long j = 0; j < subheight; ++j)
220 {
221 memcpy( subdata, data, subwidth);
222 subdata+=subwidth;
223 data+=width;
224 }
225
226 return image;
227 }
228
229 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
230 {
231 wxCHECK_RET( Ok(), _T("invalid image") );
232
233 int w = M_IMGDATA->m_width;
234 int h = M_IMGDATA->m_height;
235
236 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), _T("invalid image index") );
237
238 long pos = (y * w + x) * 3;
239
240 M_IMGDATA->m_data[ pos ] = r;
241 M_IMGDATA->m_data[ pos+1 ] = g;
242 M_IMGDATA->m_data[ pos+2 ] = b;
243 }
244
245 unsigned char wxImage::GetRed( int x, int y )
246 {
247 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
248
249 int w = M_IMGDATA->m_width;
250 int h = M_IMGDATA->m_height;
251
252 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
253
254 long pos = (y * w + x) * 3;
255
256 return M_IMGDATA->m_data[pos];
257 }
258
259 unsigned char wxImage::GetGreen( int x, int y )
260 {
261 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
262
263 int w = M_IMGDATA->m_width;
264 int h = M_IMGDATA->m_height;
265
266 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
267
268 long pos = (y * w + x) * 3;
269
270 return M_IMGDATA->m_data[pos+1];
271 }
272
273 unsigned char wxImage::GetBlue( int x, int y )
274 {
275 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
276
277 int w = M_IMGDATA->m_width;
278 int h = M_IMGDATA->m_height;
279
280 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
281
282 long pos = (y * w + x) * 3;
283
284 return M_IMGDATA->m_data[pos+2];
285 }
286
287 bool wxImage::Ok() const
288 {
289 return (M_IMGDATA && M_IMGDATA->m_ok);
290 }
291
292 char unsigned *wxImage::GetData() const
293 {
294 wxCHECK_MSG( Ok(), (char unsigned *)NULL, _T("invalid image") );
295
296 return M_IMGDATA->m_data;
297 }
298
299 void wxImage::SetData( char unsigned *data )
300 {
301 wxCHECK_RET( Ok(), _T("invalid image") );
302
303 wxImageRefData *newRefData = new wxImageRefData();
304
305 newRefData->m_width = M_IMGDATA->m_width;
306 newRefData->m_height = M_IMGDATA->m_height;
307 newRefData->m_data = data;
308 newRefData->m_ok = TRUE;
309 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
310 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
311 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
312 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
313
314 UnRef();
315
316 m_refData = newRefData;
317 }
318
319 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
320 {
321 wxCHECK_RET( Ok(), _T("invalid image") );
322
323 M_IMGDATA->m_maskRed = r;
324 M_IMGDATA->m_maskGreen = g;
325 M_IMGDATA->m_maskBlue = b;
326 M_IMGDATA->m_hasMask = TRUE;
327 }
328
329 unsigned char wxImage::GetMaskRed() const
330 {
331 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
332
333 return M_IMGDATA->m_maskRed;
334 }
335
336 unsigned char wxImage::GetMaskGreen() const
337 {
338 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
339
340 return M_IMGDATA->m_maskGreen;
341 }
342
343 unsigned char wxImage::GetMaskBlue() const
344 {
345 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
346
347 return M_IMGDATA->m_maskBlue;
348 }
349
350 void wxImage::SetMask( bool mask )
351 {
352 wxCHECK_RET( Ok(), _T("invalid image") );
353
354 M_IMGDATA->m_hasMask = mask;
355 }
356
357 bool wxImage::HasMask() const
358 {
359 wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
360
361 return M_IMGDATA->m_hasMask;
362 }
363
364 int wxImage::GetWidth() const
365 {
366 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
367
368 return M_IMGDATA->m_width;
369 }
370
371 int wxImage::GetHeight() const
372 {
373 wxCHECK_MSG( Ok(), 0, _T("invalid image") );
374
375 return M_IMGDATA->m_height;
376 }
377
378 bool wxImage::LoadFile( const wxString& filename, long type )
379 {
380 #if wxUSE_STREAMS
381 if (wxFileExists(filename))
382 {
383 wxFileInputStream stream(filename);
384 return LoadFile(stream, type);
385 }
386
387 else {
388 wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
389
390 return FALSE;
391 }
392 #else // !wxUSE_STREAMS
393 return FALSE;
394 #endif // wxUSE_STREAMS
395 }
396
397 bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
398 {
399 #if wxUSE_STREAMS
400 if (wxFileExists(filename))
401 {
402 wxFileInputStream stream(filename);
403 return LoadFile(stream, mimetype);
404 }
405
406 else {
407 wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
408
409 return FALSE;
410 }
411 #else // !wxUSE_STREAMS
412 return FALSE;
413 #endif // wxUSE_STREAMS
414 }
415
416 bool wxImage::SaveFile( const wxString& filename, int type )
417 {
418 #if wxUSE_STREAMS
419 wxFileOutputStream stream(filename);
420
421 if ( stream.LastError() == wxStream_NOERROR )
422 return SaveFile(stream, type);
423 else
424 #endif // wxUSE_STREAMS
425 return FALSE;
426 }
427
428 bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype )
429 {
430 #if wxUSE_STREAMS
431 wxFileOutputStream stream(filename);
432
433 if ( stream.LastError() == wxStream_NOERROR )
434 return SaveFile(stream, mimetype);
435 else
436 #endif // wxUSE_STREAMS
437 return FALSE;
438 }
439
440 #if wxUSE_STREAMS
441
442 bool wxImage::LoadFile( wxInputStream& stream, long type )
443 {
444 UnRef();
445
446 m_refData = new wxImageRefData;
447
448 wxImageHandler *handler;
449
450 if (type==wxBITMAP_TYPE_ANY)
451 {
452 wxList &list=GetHandlers();
453
454 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
455 {
456 handler=(wxImageHandler*)node->GetData();
457 if (handler->CanRead( stream ))
458 return handler->LoadFile( this, stream );
459
460 }
461
462 wxLogWarning( _T("No handler found for this image.") );
463 return FALSE;
464 }
465
466 handler = FindHandler(type);
467
468 if (handler == NULL)
469 {
470 wxLogWarning( _T("No image handler for type %d defined."), type );
471
472 return FALSE;
473 }
474
475 return handler->LoadFile( this, stream );
476 }
477
478 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )
479 {
480 UnRef();
481
482 m_refData = new wxImageRefData;
483
484 wxImageHandler *handler = FindHandlerMime(mimetype);
485
486 if (handler == NULL)
487 {
488 wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
489
490 return FALSE;
491 }
492
493 return handler->LoadFile( this, stream );
494 }
495
496 bool wxImage::SaveFile( wxOutputStream& stream, int type )
497 {
498 wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
499
500 wxImageHandler *handler = FindHandler(type);
501
502 if (handler == NULL)
503 {
504 wxLogWarning( _T("No image handler for type %d defined."), type );
505
506 return FALSE;
507 }
508
509 return handler->SaveFile( this, stream );
510 }
511
512 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
513 {
514 wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
515
516 wxImageHandler *handler = FindHandlerMime(mimetype);
517
518 if (handler == NULL)
519 {
520 wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
521
522 return FALSE;
523 }
524
525 return handler->SaveFile( this, stream );
526 }
527 #endif // wxUSE_STREAMS
528
529 void wxImage::AddHandler( wxImageHandler *handler )
530 {
531 // make sure that the memory will be freed at the program end
532 sm_handlers.DeleteContents(TRUE);
533
534 sm_handlers.Append( handler );
535 }
536
537 void wxImage::InsertHandler( wxImageHandler *handler )
538 {
539 // make sure that the memory will be freed at the program end
540 sm_handlers.DeleteContents(TRUE);
541
542 sm_handlers.Insert( handler );
543 }
544
545 bool wxImage::RemoveHandler( const wxString& name )
546 {
547 wxImageHandler *handler = FindHandler(name);
548 if (handler)
549 {
550 sm_handlers.DeleteObject(handler);
551 return TRUE;
552 }
553 else
554 return FALSE;
555 }
556
557 wxImageHandler *wxImage::FindHandler( const wxString& name )
558 {
559 wxNode *node = sm_handlers.First();
560 while (node)
561 {
562 wxImageHandler *handler = (wxImageHandler*)node->Data();
563 if (handler->GetName().Cmp(name) == 0) return handler;
564
565 node = node->Next();
566 }
567 return (wxImageHandler *)NULL;
568 }
569
570 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
571 {
572 wxNode *node = sm_handlers.First();
573 while (node)
574 {
575 wxImageHandler *handler = (wxImageHandler*)node->Data();
576 if ( (handler->GetExtension().Cmp(extension) == 0) &&
577 (bitmapType == -1 || handler->GetType() == bitmapType) )
578 return handler;
579 node = node->Next();
580 }
581 return (wxImageHandler*)NULL;
582 }
583
584 wxImageHandler *wxImage::FindHandler( long bitmapType )
585 {
586 wxNode *node = sm_handlers.First();
587 while (node)
588 {
589 wxImageHandler *handler = (wxImageHandler *)node->Data();
590 if (handler->GetType() == bitmapType) return handler;
591 node = node->Next();
592 }
593 return NULL;
594 }
595
596 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
597 {
598 wxNode *node = sm_handlers.First();
599 while (node)
600 {
601 wxImageHandler *handler = (wxImageHandler *)node->Data();
602 if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
603 node = node->Next();
604 }
605 return NULL;
606 }
607
608 void wxImage::InitStandardHandlers()
609 {
610 AddHandler( new wxBMPHandler );
611 }
612
613 void wxImage::InitAllHandlers()
614 {
615 #if wxUSE_LIBPNG
616 AddHandler( new wxPNGHandler );
617 #endif
618 #if wxUSE_LIBJPEG
619 AddHandler( new wxJPEGHandler );
620 #endif
621 #if wxUSE_GIF
622 AddHandler( new wxGIFHandler );
623 #endif
624 #if wxUSE_PNM
625 AddHandler( new wxPNMHandler );
626 #endif
627 #if wxUSE_PCX
628 AddHandler( new wxPCXHandler );
629 #endif
630 }
631
632 void wxImage::CleanUpHandlers()
633 {
634 wxNode *node = sm_handlers.First();
635 while (node)
636 {
637 wxImageHandler *handler = (wxImageHandler *)node->Data();
638 wxNode *next = node->Next();
639 delete handler;
640 delete node;
641 node = next;
642 }
643 }
644
645 //-----------------------------------------------------------------------------
646 // wxImageHandler
647 //-----------------------------------------------------------------------------
648
649 #if !USE_SHARED_LIBRARIES
650 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler,wxObject)
651 #endif
652
653 #if wxUSE_STREAMS
654 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
655 {
656 return FALSE;
657 }
658
659 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
660 {
661 return FALSE;
662 }
663
664 bool wxImageHandler::CanRead( wxInputStream& stream )
665 {
666 return FALSE;
667 }
668
669 bool wxImageHandler::CanRead( const wxString& name )
670 {
671 #if wxUSE_STREAMS
672 if (wxFileExists(name))
673 {
674 wxFileInputStream stream(name);
675 return CanRead(stream);
676 }
677
678 else {
679 wxLogError( _T("Can't check image format of file '%s': file does not exist."), name.c_str() );
680
681 return FALSE;
682 }
683 #else // !wxUSE_STREAMS
684 return FALSE;
685 #endif // wxUSE_STREAMS
686 }
687
688
689
690 #endif // wxUSE_STREAMS
691
692 //-----------------------------------------------------------------------------
693 // MSW conversion routines
694 //-----------------------------------------------------------------------------
695
696 #ifdef __WXMSW__
697
698 wxBitmap wxImage::ConvertToBitmap() const
699 {
700 if ( !Ok() )
701 return wxNullBitmap;
702
703 // sizeLimit is the MS upper limit for the DIB size
704 #ifdef WIN32
705 int sizeLimit = 1024*768*3;
706 #else
707 int sizeLimit = 0x7fff ;
708 #endif
709
710 // width and height of the device-dependent bitmap
711 int width = GetWidth();
712 int bmpHeight = GetHeight();
713
714 // calc the number of bytes per scanline and padding
715 int bytePerLine = width*3;
716 int sizeDWORD = sizeof( DWORD );
717 int lineBoundary = bytePerLine % sizeDWORD;
718 int padding = 0;
719 if( lineBoundary > 0 )
720 {
721 padding = sizeDWORD - lineBoundary;
722 bytePerLine += padding;
723 }
724 // calc the number of DIBs and heights of DIBs
725 int numDIB = 1;
726 int hRemain = 0;
727 int height = sizeLimit/bytePerLine;
728 if( height >= bmpHeight )
729 height = bmpHeight;
730 else
731 {
732 numDIB = bmpHeight / height;
733 hRemain = bmpHeight % height;
734 if( hRemain >0 ) numDIB++;
735 }
736
737 // set bitmap parameters
738 wxBitmap bitmap;
739 wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
740 bitmap.SetWidth( width );
741 bitmap.SetHeight( bmpHeight );
742 bitmap.SetDepth( wxDisplayDepth() );
743
744 // create a DIB header
745 int headersize = sizeof(BITMAPINFOHEADER);
746 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
747 wxCHECK_MSG( lpDIBh, bitmap, _T("could not allocate memory for DIB header") );
748 // Fill in the DIB header
749 lpDIBh->bmiHeader.biSize = headersize;
750 lpDIBh->bmiHeader.biWidth = (DWORD)width;
751 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
752 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
753 // the general formula for biSizeImage:
754 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
755 lpDIBh->bmiHeader.biPlanes = 1;
756 lpDIBh->bmiHeader.biBitCount = 24;
757 lpDIBh->bmiHeader.biCompression = BI_RGB;
758 lpDIBh->bmiHeader.biClrUsed = 0;
759 // These seem not really needed for our purpose here.
760 lpDIBh->bmiHeader.biClrImportant = 0;
761 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
762 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
763 // memory for DIB data
764 unsigned char *lpBits;
765 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
766 if( !lpBits )
767 {
768 wxFAIL_MSG( _T("could not allocate memory for DIB") );
769 free( lpDIBh );
770 return bitmap;
771 }
772
773 // create and set the device-dependent bitmap
774 HDC hdc = ::GetDC(NULL);
775 HDC memdc = ::CreateCompatibleDC( hdc );
776 HBITMAP hbitmap;
777 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
778 ::SelectObject( memdc, hbitmap);
779
780 // copy image data into DIB data and then into DDB (in a loop)
781 unsigned char *data = GetData();
782 int i, j, n;
783 int origin = 0;
784 unsigned char *ptdata = data;
785 unsigned char *ptbits;
786
787 for( n=0; n<numDIB; n++ )
788 {
789 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
790 {
791 // redefine height and size of the (possibly) last smaller DIB
792 // memory is not reallocated
793 height = hRemain;
794 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
795 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
796 }
797 ptbits = lpBits;
798
799 for( j=0; j<height; j++ )
800 {
801 for( i=0; i<width; i++ )
802 {
803 *(ptbits++) = *(ptdata+2);
804 *(ptbits++) = *(ptdata+1);
805 *(ptbits++) = *(ptdata );
806 ptdata += 3;
807 }
808 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
809 }
810 ::StretchDIBits( memdc, 0, origin, width, height,\
811 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
812 origin += height;
813 // if numDIB = 1, lines below can also be used
814 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
815 // The above line is equivalent to the following two lines.
816 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
817 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
818 // or the following lines
819 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
820 // HDC memdc = ::CreateCompatibleDC( hdc );
821 // ::SelectObject( memdc, hbitmap);
822 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
823 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
824 // ::SelectObject( memdc, 0 );
825 // ::DeleteDC( memdc );
826 }
827 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
828
829 // similarly, created an mono-bitmap for the possible mask
830 if( HasMask() )
831 {
832 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
833 ::SelectObject( memdc, hbitmap);
834 if( numDIB == 1 ) height = bmpHeight;
835 else height = sizeLimit/bytePerLine;
836 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
837 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
838 origin = 0;
839 unsigned char r = GetMaskRed();
840 unsigned char g = GetMaskGreen();
841 unsigned char b = GetMaskBlue();
842 unsigned char zero = 0, one = 255;
843 ptdata = data;
844 for( n=0; n<numDIB; n++ )
845 {
846 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
847 {
848 // redefine height and size of the (possibly) last smaller DIB
849 // memory is not reallocated
850 height = hRemain;
851 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
852 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
853 }
854 ptbits = lpBits;
855 for( int j=0; j<height; j++ )
856 {
857 for(i=0; i<width; i++ )
858 {
859 if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
860 {
861 *(ptbits++) = one;
862 *(ptbits++) = one;
863 *(ptbits++) = one;
864 }
865 else
866 {
867 *(ptbits++) = zero;
868 *(ptbits++) = zero;
869 *(ptbits++) = zero;
870 }
871 }
872 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
873 }
874 ::StretchDIBits( memdc, 0, origin, width, height,\
875 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
876 origin += height;
877 }
878 // create a wxMask object
879 wxMask *mask = new wxMask();
880 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
881 bitmap.SetMask( mask );
882 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
883 /* The following can also be used but is slow to run
884 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
885 wxMask *mask = new wxMask( bitmap, colour );
886 bitmap.SetMask( mask );
887 */
888 }
889
890 // free allocated resources
891 ::SelectObject( memdc, 0 );
892 ::DeleteDC( memdc );
893 ::ReleaseDC(NULL, hdc);
894 free(lpDIBh);
895 free(lpBits);
896
897 // check the wxBitmap object
898 if( bitmap.GetHBITMAP() )
899 bitmap.SetOk( TRUE );
900 else
901 bitmap.SetOk( FALSE );
902
903 return bitmap;
904 }
905
906 wxImage::wxImage( const wxBitmap &bitmap )
907 {
908 // check the bitmap
909 if( !bitmap.Ok() )
910 {
911 wxFAIL_MSG( _T("invalid bitmap") );
912 return;
913 }
914
915 // create an wxImage object
916 int width = bitmap.GetWidth();
917 int height = bitmap.GetHeight();
918 Create( width, height );
919 unsigned char *data = GetData();
920 if( !data )
921 {
922 wxFAIL_MSG( _T("could not allocate data for image") );
923 return;
924 }
925
926 // calc the number of bytes per scanline and padding in the DIB
927 int bytePerLine = width*3;
928 int sizeDWORD = sizeof( DWORD );
929 int lineBoundary = bytePerLine % sizeDWORD;
930 int padding = 0;
931 if( lineBoundary > 0 )
932 {
933 padding = sizeDWORD - lineBoundary;
934 bytePerLine += padding;
935 }
936
937 // create a DIB header
938 int headersize = sizeof(BITMAPINFOHEADER);
939 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
940 if( !lpDIBh )
941 {
942 wxFAIL_MSG( _T("could not allocate data for DIB header") );
943 free( data );
944 return;
945 }
946 // Fill in the DIB header
947 lpDIBh->bmiHeader.biSize = headersize;
948 lpDIBh->bmiHeader.biWidth = width;
949 lpDIBh->bmiHeader.biHeight = -height;
950 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
951 lpDIBh->bmiHeader.biPlanes = 1;
952 lpDIBh->bmiHeader.biBitCount = 24;
953 lpDIBh->bmiHeader.biCompression = BI_RGB;
954 lpDIBh->bmiHeader.biClrUsed = 0;
955 // These seem not really needed for our purpose here.
956 lpDIBh->bmiHeader.biClrImportant = 0;
957 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
958 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
959 // memory for DIB data
960 unsigned char *lpBits;
961 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
962 if( !lpBits )
963 {
964 wxFAIL_MSG( _T("could not allocate data for DIB") );
965 free( data );
966 free( lpDIBh );
967 return;
968 }
969
970 // copy data from the device-dependent bitmap to the DIB
971 HDC hdc = ::GetDC(NULL);
972 HBITMAP hbitmap;
973 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
974 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
975
976 // copy DIB data into the wxImage object
977 int i, j;
978 unsigned char *ptdata = data;
979 unsigned char *ptbits = lpBits;
980 for( i=0; i<height; i++ )
981 {
982 for( j=0; j<width; j++ )
983 {
984 *(ptdata++) = *(ptbits+2);
985 *(ptdata++) = *(ptbits+1);
986 *(ptdata++) = *(ptbits );
987 ptbits += 3;
988 }
989 ptbits += padding;
990 }
991
992 // similarly, set data according to the possible mask bitmap
993 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
994 {
995 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
996 // memory DC created, color set, data copied, and memory DC deleted
997 HDC memdc = ::CreateCompatibleDC( hdc );
998 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
999 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
1000 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
1001 ::DeleteDC( memdc );
1002 // background color set to RGB(16,16,16) in consistent with wxGTK
1003 unsigned char r=16, g=16, b=16;
1004 ptdata = data;
1005 ptbits = lpBits;
1006 for( i=0; i<height; i++ )
1007 {
1008 for( j=0; j<width; j++ )
1009 {
1010 if( *ptbits != 0 )
1011 ptdata += 3;
1012 else
1013 {
1014 *(ptdata++) = r;
1015 *(ptdata++) = g;
1016 *(ptdata++) = b;
1017 }
1018 ptbits += 3;
1019 }
1020 ptbits += padding;
1021 }
1022 SetMaskColour( r, g, b );
1023 SetMask( TRUE );
1024 }
1025 else
1026 {
1027 SetMask( FALSE );
1028 }
1029 // free allocated resources
1030 ::ReleaseDC(NULL, hdc);
1031 free(lpDIBh);
1032 free(lpBits);
1033 }
1034
1035 #endif
1036
1037 //-----------------------------------------------------------------------------
1038 // GTK conversion routines
1039 //-----------------------------------------------------------------------------
1040
1041 #ifdef __WXGTK__
1042
1043 #include "gtk/gtk.h"
1044 #include "gdk/gdk.h"
1045 #include "gdk/gdkx.h"
1046
1047 #if (GTK_MINOR_VERSION > 0)
1048 #include "gdk/gdkrgb.h"
1049 #endif
1050
1051 wxBitmap wxImage::ConvertToBitmap() const
1052 {
1053 wxBitmap bitmap;
1054
1055 wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
1056
1057 int width = GetWidth();
1058 int height = GetHeight();
1059
1060 bitmap.SetHeight( height );
1061 bitmap.SetWidth( width );
1062
1063 bitmap.SetPixmap( gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 ) );
1064
1065 // Retrieve depth
1066
1067 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1068 if (visual == NULL) visual = gdk_visual_get_system();
1069 int bpp = visual->depth;
1070
1071 bitmap.SetDepth( bpp );
1072
1073 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1074 if (bpp < 8) bpp = 8;
1075
1076 #if (GTK_MINOR_VERSION > 0)
1077
1078 if (!HasMask() && (bpp > 8))
1079 {
1080 static bool s_hasInitialized = FALSE;
1081
1082 if (!s_hasInitialized)
1083 {
1084 gdk_rgb_init();
1085 s_hasInitialized = TRUE;
1086 }
1087
1088 GdkGC *gc = gdk_gc_new( bitmap.GetPixmap() );
1089
1090 gdk_draw_rgb_image( bitmap.GetPixmap(),
1091 gc,
1092 0, 0,
1093 width, height,
1094 GDK_RGB_DITHER_NONE,
1095 GetData(),
1096 width*3 );
1097
1098 gdk_gc_unref( gc );
1099
1100 return bitmap;
1101 }
1102
1103 #endif
1104
1105 // Create picture image
1106
1107 GdkImage *data_image =
1108 gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
1109
1110 // Create mask image
1111
1112 GdkImage *mask_image = (GdkImage*) NULL;
1113
1114 if (HasMask())
1115 {
1116 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1117
1118 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1119
1120 wxMask *mask = new wxMask();
1121 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1122
1123 bitmap.SetMask( mask );
1124 }
1125
1126 // Render
1127
1128 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1129 byte_order b_o = RGB;
1130
1131 if (bpp >= 24)
1132 {
1133 GdkVisual *visual = gdk_visual_get_system();
1134 if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask)) b_o = RGB;
1135 else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask)) b_o = RGB;
1136 else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask)) b_o = BRG;
1137 else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
1138 else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask)) b_o = GRB;
1139 else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask)) b_o = GBR;
1140 }
1141
1142 int r_mask = GetMaskRed();
1143 int g_mask = GetMaskGreen();
1144 int b_mask = GetMaskBlue();
1145
1146 unsigned char* data = GetData();
1147
1148 int index = 0;
1149 for (int y = 0; y < height; y++)
1150 {
1151 for (int x = 0; x < width; x++)
1152 {
1153 int r = data[index];
1154 index++;
1155 int g = data[index];
1156 index++;
1157 int b = data[index];
1158 index++;
1159
1160 if (HasMask())
1161 {
1162 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1163 gdk_image_put_pixel( mask_image, x, y, 1 );
1164 else
1165 gdk_image_put_pixel( mask_image, x, y, 0 );
1166 }
1167
1168 if (HasMask())
1169 {
1170 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1171 gdk_image_put_pixel( mask_image, x, y, 1 );
1172 else
1173 gdk_image_put_pixel( mask_image, x, y, 0 );
1174 }
1175
1176 switch (bpp)
1177 {
1178 case 8:
1179 {
1180 int pixel = -1;
1181 if (wxTheApp->m_colorCube)
1182 {
1183 pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1184 }
1185 else
1186 {
1187 GdkColormap *cmap = gtk_widget_get_default_colormap();
1188 GdkColor *colors = cmap->colors;
1189 int max = 3 * (65536);
1190
1191 for (int i = 0; i < cmap->size; i++)
1192 {
1193 int rdiff = (r << 8) - colors[i].red;
1194 int gdiff = (g << 8) - colors[i].green;
1195 int bdiff = (b << 8) - colors[i].blue;
1196 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1197 if (sum < max) { pixel = i; max = sum; }
1198 }
1199 }
1200
1201 gdk_image_put_pixel( data_image, x, y, pixel );
1202
1203 break;
1204 }
1205 case 15:
1206 {
1207 guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1208 gdk_image_put_pixel( data_image, x, y, pixel );
1209 break;
1210 }
1211 case 16:
1212 {
1213 guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1214 gdk_image_put_pixel( data_image, x, y, pixel );
1215 break;
1216 }
1217 case 32:
1218 case 24:
1219 {
1220 guint32 pixel = 0;
1221 switch (b_o)
1222 {
1223 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1224 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1225 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1226 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1227 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1228 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1229 }
1230 gdk_image_put_pixel( data_image, x, y, pixel );
1231 }
1232 default: break;
1233 }
1234 } // for
1235 } // for
1236
1237 // Blit picture
1238
1239 GdkGC *data_gc = gdk_gc_new( bitmap.GetPixmap() );
1240
1241 gdk_draw_image( bitmap.GetPixmap(), data_gc, data_image, 0, 0, 0, 0, width, height );
1242
1243 gdk_image_destroy( data_image );
1244 gdk_gc_unref( data_gc );
1245
1246 // Blit mask
1247
1248 if (HasMask())
1249 {
1250 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1251
1252 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1253
1254 gdk_image_destroy( mask_image );
1255 gdk_gc_unref( mask_gc );
1256 }
1257
1258 return bitmap;
1259 }
1260
1261 wxImage::wxImage( const wxBitmap &bitmap )
1262 {
1263 wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
1264
1265 GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
1266 0, 0,
1267 bitmap.GetWidth(), bitmap.GetHeight() );
1268
1269 wxCHECK_RET( gdk_image, _T("couldn't create image") );
1270
1271 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1272 char unsigned *data = GetData();
1273
1274 if (!data)
1275 {
1276 gdk_image_destroy( gdk_image );
1277 wxFAIL_MSG( _T("couldn't create image") );
1278 return;
1279 }
1280
1281 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1282 if (bitmap.GetMask())
1283 {
1284 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1285 0, 0,
1286 bitmap.GetWidth(), bitmap.GetHeight() );
1287
1288 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1289 }
1290
1291 GdkVisual *visual = gdk_window_get_visual( bitmap.GetPixmap() );
1292 if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
1293 int bpp = visual->depth;
1294 if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
1295
1296 GdkColormap *cmap = gtk_widget_get_default_colormap();
1297
1298 long pos = 0;
1299 for (int j = 0; j < bitmap.GetHeight(); j++)
1300 {
1301 for (int i = 0; i < bitmap.GetWidth(); i++)
1302 {
1303 wxInt32 pixel = gdk_image_get_pixel( gdk_image, i, j );
1304 pixel = wxINT32_SWAP_ON_BE( pixel );
1305 if (bpp <= 8)
1306 {
1307 data[pos] = cmap->colors[pixel].red >> 8;
1308 data[pos+1] = cmap->colors[pixel].green >> 8;
1309 data[pos+2] = cmap->colors[pixel].blue >> 8;
1310 } else if (bpp == 15)
1311 {
1312 data[pos] = (pixel >> 7) & 0xf8;
1313 data[pos+1] = (pixel >> 2) & 0xf8;
1314 data[pos+2] = (pixel << 3) & 0xf8;
1315 } else if (bpp == 16)
1316 {
1317 data[pos] = (pixel >> 8) & 0xf8;
1318 data[pos+1] = (pixel >> 3) & 0xfc;
1319 data[pos+2] = (pixel << 3) & 0xf8;
1320 } else
1321 {
1322 data[pos] = (pixel >> 16) & 0xff;
1323 data[pos+1] = (pixel >> 8) & 0xff;
1324 data[pos+2] = pixel & 0xff;
1325 }
1326
1327 if (gdk_image_mask)
1328 {
1329 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1330 if (mask_pixel == 0)
1331 {
1332 data[pos] = 16;
1333 data[pos+1] = 16;
1334 data[pos+2] = 16;
1335 }
1336 }
1337
1338 pos += 3;
1339 }
1340 }
1341
1342 gdk_image_destroy( gdk_image );
1343 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1344 }
1345
1346 #endif
1347
1348 //-----------------------------------------------------------------------------
1349 // Motif conversion routines
1350 //-----------------------------------------------------------------------------
1351
1352 #ifdef __WXMOTIF__
1353
1354 #include <Xm/Xm.h>
1355 #include "wx/utils.h"
1356 #include <math.h>
1357
1358 wxBitmap wxImage::ConvertToBitmap() const
1359 {
1360 wxBitmap bitmap;
1361
1362 wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
1363
1364 int width = GetWidth();
1365 int height = GetHeight();
1366
1367 bitmap.SetHeight( height );
1368 bitmap.SetWidth( width );
1369
1370 Display *dpy = (Display*) wxGetDisplay();
1371 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1372 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1373
1374 // Create image
1375
1376 XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
1377 data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
1378
1379 bitmap.Create( width, height, bpp );
1380
1381 /*
1382 // Create mask
1383
1384 GdkImage *mask_image = (GdkImage*) NULL;
1385
1386 if (HasMask())
1387 {
1388 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1389
1390 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1391
1392 wxMask *mask = new wxMask();
1393 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1394
1395 bitmap.SetMask( mask );
1396 }
1397 */
1398
1399 // Retrieve depth info
1400
1401 XVisualInfo vinfo_template;
1402 XVisualInfo *vi;
1403
1404 vinfo_template.visual = vis;
1405 vinfo_template.visualid = XVisualIDFromVisual( vis );
1406 vinfo_template.depth = bpp;
1407 int nitem = 0;
1408
1409 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1410
1411 wxCHECK_MSG( vi, wxNullBitmap, _T("no visual") );
1412
1413 XFree( vi );
1414
1415 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1416 if (bpp < 8) bpp = 8;
1417
1418 // Render
1419
1420 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
1421 byte_order b_o = RGB;
1422
1423 if (bpp >= 24)
1424 {
1425 if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB;
1426 else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB;
1427 else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG;
1428 else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
1429 else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB;
1430 else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR;
1431 }
1432
1433 /*
1434 int r_mask = GetMaskRed();
1435 int g_mask = GetMaskGreen();
1436 int b_mask = GetMaskBlue();
1437 */
1438
1439 XColor colors[256];
1440 if (bpp == 8)
1441 {
1442 Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
1443
1444 for (int i = 0; i < 256; i++) colors[i].pixel = i;
1445 XQueryColors( dpy, cmap, colors, 256 );
1446 }
1447
1448 unsigned char* data = GetData();
1449
1450 int index = 0;
1451 for (int y = 0; y < height; y++)
1452 {
1453 for (int x = 0; x < width; x++)
1454 {
1455 int r = data[index];
1456 index++;
1457 int g = data[index];
1458 index++;
1459 int b = data[index];
1460 index++;
1461
1462 /*
1463 if (HasMask())
1464 {
1465 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1466 gdk_image_put_pixel( mask_image, x, y, 1 );
1467 else
1468 gdk_image_put_pixel( mask_image, x, y, 0 );
1469 }
1470 */
1471
1472 switch (bpp)
1473 {
1474 case 8:
1475 {
1476 int pixel = -1;
1477 /*
1478 if (wxTheApp->m_colorCube)
1479 {
1480 pixel = wxTheApp->m_colorCube
1481 [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1482 }
1483 else
1484 {
1485 */
1486 int max = 3 * (65536);
1487 for (int i = 0; i < 256; i++)
1488 {
1489 int rdiff = (r << 8) - colors[i].red;
1490 int gdiff = (g << 8) - colors[i].green;
1491 int bdiff = (b << 8) - colors[i].blue;
1492 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
1493 if (sum < max) { pixel = i; max = sum; }
1494 }
1495 /*
1496 }
1497 */
1498 XPutPixel( data_image, x, y, pixel );
1499 break;
1500 }
1501 case 15:
1502 {
1503 int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1504 XPutPixel( data_image, x, y, pixel );
1505 break;
1506 }
1507 case 16:
1508 {
1509 int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1510 XPutPixel( data_image, x, y, pixel );
1511 break;
1512 }
1513 case 32:
1514 case 24:
1515 {
1516 int pixel = 0;
1517 switch (b_o)
1518 {
1519 case RGB: pixel = (r << 16) | (g << 8) | b; break;
1520 case RBG: pixel = (r << 16) | (b << 8) | g; break;
1521 case BRG: pixel = (b << 16) | (r << 8) | g; break;
1522 case BGR: pixel = (b << 16) | (g << 8) | r; break;
1523 case GRB: pixel = (g << 16) | (r << 8) | b; break;
1524 case GBR: pixel = (g << 16) | (b << 8) | r; break;
1525 }
1526 XPutPixel( data_image, x, y, pixel );
1527 }
1528 default: break;
1529 }
1530 } // for
1531 } // for
1532
1533 // Blit picture
1534
1535 XGCValues gcvalues;
1536 gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
1537 GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
1538 XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
1539
1540 XDestroyImage( data_image );
1541 XFreeGC( dpy, gc );
1542
1543 /*
1544 // Blit mask
1545
1546 if (HasMask())
1547 {
1548 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1549
1550 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1551
1552 gdk_image_destroy( mask_image );
1553 gdk_gc_unref( mask_gc );
1554 }
1555 */
1556
1557 return bitmap;
1558 }
1559
1560 wxImage::wxImage( const wxBitmap &bitmap )
1561 {
1562 wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
1563
1564 Display *dpy = (Display*) wxGetDisplay();
1565 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
1566 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
1567
1568 XImage *ximage = XGetImage( dpy,
1569 (Drawable)bitmap.GetPixmap(),
1570 0, 0,
1571 bitmap.GetWidth(), bitmap.GetHeight(),
1572 AllPlanes, ZPixmap );
1573
1574 wxCHECK_RET( ximage, _T("couldn't create image") );
1575
1576 Create( bitmap.GetWidth(), bitmap.GetHeight() );
1577 char unsigned *data = GetData();
1578
1579 if (!data)
1580 {
1581 XDestroyImage( ximage );
1582 wxFAIL_MSG( _T("couldn't create image") );
1583 return;
1584 }
1585
1586 /*
1587 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1588 if (bitmap.GetMask())
1589 {
1590 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1591 0, 0,
1592 bitmap.GetWidth(), bitmap.GetHeight() );
1593
1594 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1595 }
1596 */
1597
1598 // Retrieve depth info
1599
1600 XVisualInfo vinfo_template;
1601 XVisualInfo *vi;
1602
1603 vinfo_template.visual = vis;
1604 vinfo_template.visualid = XVisualIDFromVisual( vis );
1605 vinfo_template.depth = bpp;
1606 int nitem = 0;
1607
1608 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1609
1610 wxCHECK_RET( vi, _T("no visual") );
1611
1612 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
1613
1614 XFree( vi );
1615
1616 XColor colors[256];
1617 if (bpp == 8)
1618 {
1619 Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
1620
1621 for (int i = 0; i < 256; i++) colors[i].pixel = i;
1622 XQueryColors( dpy, cmap, colors, 256 );
1623 }
1624
1625 long pos = 0;
1626 for (int j = 0; j < bitmap.GetHeight(); j++)
1627 {
1628 for (int i = 0; i < bitmap.GetWidth(); i++)
1629 {
1630 int pixel = XGetPixel( ximage, i, j );
1631 if (bpp <= 8)
1632 {
1633 data[pos] = colors[pixel].red >> 8;
1634 data[pos+1] = colors[pixel].green >> 8;
1635 data[pos+2] = colors[pixel].blue >> 8;
1636 } else if (bpp == 15)
1637 {
1638 data[pos] = (pixel >> 7) & 0xf8;
1639 data[pos+1] = (pixel >> 2) & 0xf8;
1640 data[pos+2] = (pixel << 3) & 0xf8;
1641 } else if (bpp == 16)
1642 {
1643 data[pos] = (pixel >> 8) & 0xf8;
1644 data[pos+1] = (pixel >> 3) & 0xfc;
1645 data[pos+2] = (pixel << 3) & 0xf8;
1646 } else
1647 {
1648 data[pos] = (pixel >> 16) & 0xff;
1649 data[pos+1] = (pixel >> 8) & 0xff;
1650 data[pos+2] = pixel & 0xff;
1651 }
1652
1653 /*
1654 if (gdk_image_mask)
1655 {
1656 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1657 if (mask_pixel == 0)
1658 {
1659 data[pos] = 16;
1660 data[pos+1] = 16;
1661 data[pos+2] = 16;
1662 }
1663 }
1664 */
1665
1666 pos += 3;
1667 }
1668 }
1669
1670 XDestroyImage( ximage );
1671 /*
1672 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1673 */
1674 }
1675 #endif
1676
1677 // A module to allow wxImage initialization/cleanup
1678 // without calling these functions from app.cpp or from
1679 // the user's application.
1680
1681 class wxImageModule: public wxModule
1682 {
1683 DECLARE_DYNAMIC_CLASS(wxImageModule)
1684 public:
1685 wxImageModule() {}
1686 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE; };
1687 void OnExit() { wxImage::CleanUpHandlers(); };
1688 };
1689
1690 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
wxWidgets (Impactor)