1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 #pragma implementation "image.h"
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
22 #include "wx/bitmap.h"
26 #include "wx/filefn.h"
27 #include "wx/wfstream.h"
29 #include "wx/module.h"
44 //-----------------------------------------------------------------------------
46 //-----------------------------------------------------------------------------
48 class wxImageRefData
: public wxObjectRefData
53 ~wxImageRefData(void);
57 unsigned char *m_data
;
59 unsigned char m_maskRed
,m_maskGreen
,m_maskBlue
;
63 wxImageRefData::wxImageRefData(void)
67 m_data
= (unsigned char*) NULL
;
75 wxImageRefData::~wxImageRefData(void)
77 if (m_data
) free( m_data
);
80 wxList
wxImage::sm_handlers
;
82 //-----------------------------------------------------------------------------
84 #define M_IMGDATA ((wxImageRefData *)m_refData)
86 #if !USE_SHARED_LIBRARIES
87 IMPLEMENT_DYNAMIC_CLASS(wxImage
, wxObject
)
94 wxImage::wxImage( int width
, int height
)
96 Create( width
, height
);
99 wxImage::wxImage( const wxString
& name
, long type
)
101 LoadFile( name
, type
);
105 wxImage::wxImage( wxInputStream
& stream
, long type
)
107 LoadFile( stream
, type
);
109 #endif // wxUSE_STREAMS
111 wxImage::wxImage( const wxImage
& image
)
116 wxImage::wxImage( const wxImage
* image
)
118 if (image
) Ref(*image
);
121 void wxImage::Create( int width
, int height
)
123 m_refData
= new wxImageRefData();
125 M_IMGDATA
->m_data
= (unsigned char *) malloc( width
*height
*3 );
126 if (M_IMGDATA
->m_data
)
128 for (int l
= 0; l
< width
*height
*3; l
++) M_IMGDATA
->m_data
[l
] = 0;
130 M_IMGDATA
->m_width
= width
;
131 M_IMGDATA
->m_height
= height
;
132 M_IMGDATA
->m_ok
= TRUE
;
140 void wxImage::Destroy()
145 wxImage
wxImage::Scale( int width
, int height
)
149 wxCHECK_MSG( Ok(), image
, "invlaid image" );
151 wxCHECK_MSG( (width
> 0) && (height
> 0), image
, "invalid image size" );
153 image
.Create( width
, height
);
155 char unsigned *data
= image
.GetData();
157 wxCHECK_MSG( data
, image
, "unable to create image" );
159 if (M_IMGDATA
->m_hasMask
)
160 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
162 long old_height
= M_IMGDATA
->m_height
;
163 long old_width
= M_IMGDATA
->m_width
;
165 char unsigned *source_data
= M_IMGDATA
->m_data
;
166 char unsigned *target_data
= data
;
168 for (long j
= 0; j
< height
; j
++)
170 long y_offset
= (j
* old_height
/ height
) * old_width
;
172 for (long i
= 0; i
< width
; i
++)
175 source_data
+ 3*(y_offset
+ ((i
* old_width
)/ width
)),
184 void wxImage::SetRGB( int x
, int y
, unsigned char r
, unsigned char g
, unsigned char b
)
186 wxCHECK_RET( Ok(), "invalid image" );
188 int w
= M_IMGDATA
->m_width
;
189 int h
= M_IMGDATA
->m_height
;
191 wxCHECK_RET( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), "invalid image index" );
193 long pos
= (y
* w
+ x
) * 3;
195 M_IMGDATA
->m_data
[ pos
] = r
;
196 M_IMGDATA
->m_data
[ pos
+1 ] = g
;
197 M_IMGDATA
->m_data
[ pos
+2 ] = b
;
200 unsigned char wxImage::GetRed( int x
, int y
)
202 wxCHECK_MSG( Ok(), 0, "invalid image" );
204 int w
= M_IMGDATA
->m_width
;
205 int h
= M_IMGDATA
->m_height
;
207 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, "invalid image index" );
209 long pos
= (y
* w
+ x
) * 3;
211 return M_IMGDATA
->m_data
[pos
];
214 unsigned char wxImage::GetGreen( int x
, int y
)
216 wxCHECK_MSG( Ok(), 0, "invalid image" );
218 int w
= M_IMGDATA
->m_width
;
219 int h
= M_IMGDATA
->m_height
;
221 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, "invalid image index" );
223 long pos
= (y
* w
+ x
) * 3;
225 return M_IMGDATA
->m_data
[pos
+1];
228 unsigned char wxImage::GetBlue( int x
, int y
)
230 wxCHECK_MSG( Ok(), 0, "invalid image" );
232 int w
= M_IMGDATA
->m_width
;
233 int h
= M_IMGDATA
->m_height
;
235 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, "invalid image index" );
237 long pos
= (y
* w
+ x
) * 3;
239 return M_IMGDATA
->m_data
[pos
+2];
242 bool wxImage::Ok() const
244 return (M_IMGDATA
&& M_IMGDATA
->m_ok
);
247 char unsigned *wxImage::GetData() const
249 wxCHECK_MSG( Ok(), (char unsigned *)NULL
, "invalid image" );
251 return M_IMGDATA
->m_data
;
254 void wxImage::SetData( char unsigned *data
)
256 wxCHECK_RET( Ok(), "invalid image" );
258 memcpy(M_IMGDATA
->m_data
, data
, M_IMGDATA
->m_width
* M_IMGDATA
->m_height
* 3);
261 void wxImage::SetMaskColour( unsigned char r
, unsigned char g
, unsigned char b
)
263 wxCHECK_RET( Ok(), "invalid image" );
265 M_IMGDATA
->m_maskRed
= r
;
266 M_IMGDATA
->m_maskGreen
= g
;
267 M_IMGDATA
->m_maskBlue
= b
;
268 M_IMGDATA
->m_hasMask
= TRUE
;
271 unsigned char wxImage::GetMaskRed() const
273 wxCHECK_MSG( Ok(), 0, "invalid image" );
275 return M_IMGDATA
->m_maskRed
;
278 unsigned char wxImage::GetMaskGreen() const
280 wxCHECK_MSG( Ok(), 0, "invalid image" );
282 return M_IMGDATA
->m_maskGreen
;
285 unsigned char wxImage::GetMaskBlue() const
287 wxCHECK_MSG( Ok(), 0, "invalid image" );
289 return M_IMGDATA
->m_maskBlue
;
292 void wxImage::SetMask( bool mask
)
294 wxCHECK_RET( Ok(), "invalid image" );
296 M_IMGDATA
->m_hasMask
= mask
;
299 bool wxImage::HasMask() const
301 wxCHECK_MSG( Ok(), FALSE
, "invalid image" );
303 return M_IMGDATA
->m_hasMask
;
306 int wxImage::GetWidth() const
308 wxCHECK_MSG( Ok(), 0, "invalid image" );
310 return M_IMGDATA
->m_width
;
313 int wxImage::GetHeight() const
315 wxCHECK_MSG( Ok(), 0, "invalid image" );
317 return M_IMGDATA
->m_height
;
320 bool wxImage::LoadFile( const wxString
& filename
, long type
)
323 if (wxFileExists(filename
))
325 wxFileInputStream
stream(filename
);
326 return LoadFile(stream
, type
);
330 wxLogError( "Can't load image from file '%s': file does not exist.", filename
.c_str() );
334 #else // !wxUSE_STREAMS
336 #endif // wxUSE_STREAMS
339 bool wxImage::SaveFile( const wxString
& filename
, int type
)
342 wxFileOutputStream
stream(filename
);
344 if ( stream
.LastError() == wxStream_NOERROR
)
345 return SaveFile(stream
, type
);
347 #endif // wxUSE_STREAMS
352 bool wxImage::LoadFile( wxInputStream
& stream
, long type
)
356 m_refData
= new wxImageRefData
;
358 wxImageHandler
*handler
= FindHandler(type
);
362 wxLogWarning( "No image handler for type %d defined.", type
);
367 return handler
->LoadFile( this, stream
);
370 bool wxImage::SaveFile( wxOutputStream
& stream
, int type
)
372 wxCHECK_MSG( Ok(), FALSE
, "invalid image" );
374 wxImageHandler
*handler
= FindHandler(type
);
378 wxLogWarning( "No image handler for type %d defined.", type
);
383 return handler
->SaveFile( this, stream
);
385 #endif // wxUSE_STREAMS
387 void wxImage::AddHandler( wxImageHandler
*handler
)
389 // make sure that the memory will be freed at the program end
390 sm_handlers
.DeleteContents(TRUE
);
392 sm_handlers
.Append( handler
);
395 void wxImage::InsertHandler( wxImageHandler
*handler
)
397 // make sure that the memory will be freed at the program end
398 sm_handlers
.DeleteContents(TRUE
);
400 sm_handlers
.Insert( handler
);
403 bool wxImage::RemoveHandler( const wxString
& name
)
405 wxImageHandler
*handler
= FindHandler(name
);
408 sm_handlers
.DeleteObject(handler
);
415 wxImageHandler
*wxImage::FindHandler( const wxString
& name
)
417 wxNode
*node
= sm_handlers
.First();
420 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
421 if (handler
->GetName().Cmp(name
) == 0) return handler
;
425 return (wxImageHandler
*)NULL
;
428 wxImageHandler
*wxImage::FindHandler( const wxString
& extension
, long bitmapType
)
430 wxNode
*node
= sm_handlers
.First();
433 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
434 if ( (handler
->GetExtension().Cmp(extension
) == 0) &&
435 (bitmapType
== -1 || handler
->GetType() == bitmapType
) )
439 return (wxImageHandler
*)NULL
;
442 wxImageHandler
*wxImage::FindHandler( long bitmapType
)
444 wxNode
*node
= sm_handlers
.First();
447 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
448 if (handler
->GetType() == bitmapType
) return handler
;
454 void wxImage::InitStandardHandlers()
456 AddHandler( new wxBMPHandler
);
459 void wxImage::CleanUpHandlers()
461 wxNode
*node
= sm_handlers
.First();
464 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
465 wxNode
*next
= node
->Next();
472 //-----------------------------------------------------------------------------
474 //-----------------------------------------------------------------------------
476 #if !USE_SHARED_LIBRARIES
477 IMPLEMENT_DYNAMIC_CLASS(wxImageHandler
,wxObject
)
481 bool wxImageHandler::LoadFile( wxImage
*WXUNUSED(image
), wxInputStream
& WXUNUSED(stream
) )
486 bool wxImageHandler::SaveFile( wxImage
*WXUNUSED(image
), wxOutputStream
& WXUNUSED(stream
) )
490 #endif // wxUSE_STREAMS
492 //-----------------------------------------------------------------------------
494 //-----------------------------------------------------------------------------
496 #if !USE_SHARED_LIBRARIES
497 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler
,wxImageHandler
)
501 bool wxBMPHandler::LoadFile( wxImage
*image
, wxInputStream
& stream
)
503 unsigned char *data
, *ptr
;
504 int done
, i
, bpp
, planes
, comp
, ncolors
, line
, column
,
505 linesize
, linepos
, rshift
= 0, gshift
= 0, bshift
= 0;
508 long int dbuf
[4], dword
, rmask
= 0, gmask
= 0, bmask
= 0, offset
,
510 off_t start_offset
= stream
.TellI();
514 unsigned char r
, g
, b
;
524 #define BI_BITFIELDS 3
531 * Reading the bmp header
534 stream
.Read(&bbuf
, 2);
536 stream
.Read(dbuf
, 4 * 4);
541 stream
.Read(dbuf
, 4 * 2);
542 int width
= (int)dbuf
[0];
543 int height
= (int)dbuf
[1];
546 wxLogError( "Image width > 32767 pixels for file\n" );
551 wxLogError( "Image height > 32767 pixels for file\n" );
554 stream
.Read(&word
, 2);
556 stream
.Read(&word
, 2);
558 if (bpp
!= 1 && bpp
!= 4 && bpp
!= 8 && bpp
&& 16 && bpp
!= 24 && bpp
!= 32)
560 wxLogError( "unknown bitdepth in file\n" );
563 stream
.Read(dbuf
, 4 * 4);
565 if (comp
!= BI_RGB
&& comp
!= BI_RLE4
&& comp
!= BI_RLE8
&& comp
!= BI_BITFIELDS
)
567 wxLogError( "unknown encoding in Windows BMP file\n" );
570 stream
.Read(dbuf
, 4 * 2);
571 ncolors
= (int)dbuf
[0];
574 /* some more sanity checks */
575 if (((comp
== BI_RLE4
) && (bpp
!= 4)) || ((comp
== BI_RLE8
) && (bpp
!= 8)) || ((comp
== BI_BITFIELDS
) && (bpp
!= 16 && bpp
!= 32)))
577 wxLogError( "encoding of BMP doesn't match bitdepth\n" );
582 cmap
= (struct _cmap
*)malloc(sizeof(struct _cmap
) * ncolors
);
586 wxLogError( "Cannot allocate RAM for color map in BMP file\n" );
593 image
->Create( width
, height
);
594 ptr
= image
->GetData();
597 wxLogError( "Cannot allocate RAM for RGB data in file\n" );
604 * Reading the palette, if it exists.
606 if (bpp
< 16 && ncolors
!= 0)
608 for (i
= 0; i
< ncolors
; i
++)
610 stream
.Read(bbuf
, 4);
616 else if (bpp
== 16 || bpp
== 32)
618 if (comp
== BI_BITFIELDS
)
622 stream
.Read(dbuf
, 4 * 3);
626 /* find shift amount.. ugly, but i can't think of a better way */
627 for (bit
= 0; bit
< bpp
; bit
++)
629 if (bmask
& (1 << bit
))
631 if (gmask
& (1 << bit
))
633 if (rmask
& (1 << bit
))
658 * Reading the image data
660 stream
.SeekI(start_offset
+ offset
);
663 /* set the whole image to the background color */
664 if (bpp
< 16 && (comp
== BI_RLE4
|| comp
== BI_RLE8
))
666 for (i
= 0; i
< width
* height
; i
++)
676 #define poffset (line * width * 3 + column * 3)
679 * BMPs are stored upside down... hmmmmmmmmmm....
682 linesize
= ((width
* bpp
+ 31) / 32) * 4;
683 for (line
= (height
- 1); line
>= 0; line
--)
686 for (column
= 0; column
< width
;)
693 aByte
= stream
.GetC();
698 for (bit
= 0; bit
< 8; bit
++)
700 index
= ((aByte
& (0x80 >> bit
)) ? 1 : 0);
701 ptr
[poffset
] = cmap
[index
].r
;
702 ptr
[poffset
+ 1] = cmap
[index
].g
;
703 ptr
[poffset
+ 2] = cmap
[index
].b
;
711 wxLogError( "can't deal with 4bit encoded yet.\n");
720 for (nibble
= 0; nibble
< 2; nibble
++)
722 index
= ((aByte
& (0xF0 >> nibble
* 4)) >> (!nibble
* 4));
725 ptr
[poffset
] = cmap
[index
].r
;
726 ptr
[poffset
+ 1] = cmap
[index
].g
;
727 ptr
[poffset
+ 2] = cmap
[index
].b
;
739 aByte
= stream
.GetC();
744 /* column = width; */
753 aByte
= stream
.GetC();
755 linepos
= column
* bpp
/ 8;
756 aByte
= stream
.GetC();
761 int absolute
= aByte
;
763 for (i
= 0; i
< absolute
; i
++)
766 aByte
= stream
.GetC();
767 ptr
[poffset
] = cmap
[aByte
].r
;
768 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
769 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
773 aByte
= stream
.GetC();
778 for (i
= 0; i
< first
; i
++)
780 ptr
[poffset
] = cmap
[aByte
].r
;
781 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
782 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
790 ptr
[poffset
] = cmap
[aByte
].r
;
791 ptr
[poffset
+ 1] = cmap
[aByte
].g
;
792 ptr
[poffset
+ 2] = cmap
[aByte
].b
;
800 stream
.Read(&bbuf
, 3);
802 ptr
[poffset
] = (unsigned char)bbuf
[2];
803 ptr
[poffset
+ 1] = (unsigned char)bbuf
[1];
804 ptr
[poffset
+ 2] = (unsigned char)bbuf
[0];
811 stream
.Read(&word
, 2);
813 temp
= (word
& rmask
) >> rshift
;
815 temp
= (word
& gmask
) >> gshift
;
816 ptr
[poffset
+ 1] = temp
;
817 temp
= (word
& bmask
) >> gshift
;
818 ptr
[poffset
+ 2] = temp
;
825 stream
.Read(&dword
, 4);
827 temp
= (dword
& rmask
) >> rshift
;
829 temp
= (dword
& gmask
) >> gshift
;
830 ptr
[poffset
+ 1] = temp
;
831 temp
= (dword
& bmask
) >> bshift
;
832 ptr
[poffset
+ 2] = temp
;
836 while ((linepos
< linesize
) && (comp
!= 1) && (comp
!= 2))
838 stream
.Read(&aByte
, 1);
840 if (stream
.LastError() != wxStream_NOERROR
)
844 if (cmap
) free(cmap
);
846 image
->SetMask( FALSE
);
850 #endif // wxUSE_STREAMS
854 wxBitmap
wxImage::ConvertToBitmap() const
856 // sizeLimit is the MS upper limit for the DIB size
857 int sizeLimit
= 1024*768*3;
859 // width and height of the device-dependent bitmap
860 int width
= GetWidth();
861 int bmpHeight
= GetHeight();
863 // calc the number of bytes per scanline and padding
864 int bytePerLine
= width
*3;
865 int sizeDWORD
= sizeof( DWORD
);
866 div_t lineBoundary
= div( bytePerLine
, sizeDWORD
);
868 if( lineBoundary
.rem
> 0 )
870 padding
= sizeDWORD
- lineBoundary
.rem
;
871 bytePerLine
+= padding
;
873 // calc the number of DIBs and heights of DIBs
876 int height
= sizeLimit
/bytePerLine
;
877 if( height
>= bmpHeight
)
881 div_t result
= div( bmpHeight
, height
);
882 numDIB
= result
.quot
;
883 hRemain
= result
.rem
;
884 if( hRemain
>0 ) numDIB
++;
887 // set bitmap parameters
889 wxCHECK_MSG( Ok(), bitmap
, "invalid image" );
890 bitmap
.SetWidth( width
);
891 bitmap
.SetHeight( bmpHeight
);
892 bitmap
.SetDepth( wxDisplayDepth() );
894 // create a DIB header
895 int headersize
= sizeof(BITMAPINFOHEADER
);
896 LPBITMAPINFO lpDIBh
= (BITMAPINFO
*) malloc( headersize
);
897 wxCHECK_MSG( lpDIBh
, bitmap
, "could not allocate memory for DIB header" );
898 // Fill in the DIB header
899 lpDIBh
->bmiHeader
.biSize
= headersize
;
900 lpDIBh
->bmiHeader
.biWidth
= (DWORD
)width
;
901 lpDIBh
->bmiHeader
.biHeight
= (DWORD
)(-height
);
902 lpDIBh
->bmiHeader
.biSizeImage
= bytePerLine
*height
;
903 // the general formula for biSizeImage:
904 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
905 lpDIBh
->bmiHeader
.biPlanes
= 1;
906 lpDIBh
->bmiHeader
.biBitCount
= 24;
907 lpDIBh
->bmiHeader
.biCompression
= BI_RGB
;
908 lpDIBh
->bmiHeader
.biClrUsed
= 0;
909 // These seem not really needed for our purpose here.
910 lpDIBh
->bmiHeader
.biClrImportant
= 0;
911 lpDIBh
->bmiHeader
.biXPelsPerMeter
= 0;
912 lpDIBh
->bmiHeader
.biYPelsPerMeter
= 0;
913 // memory for DIB data
914 unsigned char *lpBits
;
915 lpBits
= (unsigned char *)malloc( lpDIBh
->bmiHeader
.biSizeImage
);
918 wxFAIL_MSG( "could not allocate memory for DIB" );
923 // create and set the device-dependent bitmap
924 HDC hdc
= ::GetDC(NULL
);
925 HDC memdc
= ::CreateCompatibleDC( hdc
);
927 hbitmap
= ::CreateCompatibleBitmap( hdc
, width
, bmpHeight
);
928 ::SelectObject( memdc
, hbitmap
);
930 // copy image data into DIB data and then into DDB (in a loop)
931 unsigned char *data
= GetData();
934 unsigned char *ptdata
= data
;
935 unsigned char *ptbits
;
937 for( n
=0; n
<numDIB
; n
++ )
939 if( numDIB
> 1 && n
== numDIB
-1 && hRemain
> 0 )
941 // redefine height and size of the (possibly) last smaller DIB
942 // memory is not reallocated
944 lpDIBh
->bmiHeader
.biHeight
= (DWORD
)(-height
);
945 lpDIBh
->bmiHeader
.biSizeImage
= bytePerLine
*height
;
949 for( j
=0; j
<height
; j
++ )
951 for( i
=0; i
<width
; i
++ )
953 *(ptbits
++) = *(ptdata
+2);
954 *(ptbits
++) = *(ptdata
+1);
955 *(ptbits
++) = *(ptdata
);
958 for( i
=0; i
< padding
; i
++ ) *(ptbits
++) = 0;
960 ::StretchDIBits( memdc
, 0, origin
, width
, height
,\
961 0, 0, width
, height
, lpBits
, lpDIBh
, DIB_RGB_COLORS
, SRCCOPY
);
963 // if numDIB = 1, lines below can also be used
964 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
965 // The above line is equivalent to the following two lines.
966 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
967 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
968 // or the following lines
969 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
970 // HDC memdc = ::CreateCompatibleDC( hdc );
971 // ::SelectObject( memdc, hbitmap);
972 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
973 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
974 // ::SelectObject( memdc, 0 );
975 // ::DeleteDC( memdc );
977 bitmap
.SetHBITMAP( (WXHBITMAP
) hbitmap
);
979 // similarly, created an mono-bitmap for the possible mask
982 hbitmap
= ::CreateBitmap( (WORD
)width
, (WORD
)bmpHeight
, 1, 1, NULL
);
983 ::SelectObject( memdc
, hbitmap
);
984 if( numDIB
== 1 ) height
= bmpHeight
;
985 else height
= sizeLimit
/bytePerLine
;
986 lpDIBh
->bmiHeader
.biHeight
= (DWORD
)(-height
);
987 lpDIBh
->bmiHeader
.biSizeImage
= bytePerLine
*height
;
989 unsigned char r
= GetMaskRed();
990 unsigned char g
= GetMaskGreen();
991 unsigned char b
= GetMaskBlue();
992 unsigned char zero
= 0, one
= 255;
994 for( n
=0; n
<numDIB
; n
++ )
996 if( numDIB
> 1 && n
== numDIB
- 1 && hRemain
> 0 )
998 // redefine height and size of the (possibly) last smaller DIB
999 // memory is not reallocated
1001 lpDIBh
->bmiHeader
.biHeight
= (DWORD
)(-height
);
1002 lpDIBh
->bmiHeader
.biSizeImage
= bytePerLine
*height
;
1005 for( int j
=0; j
<height
; j
++ )
1007 for(i
=0; i
<width
; i
++ )
1009 if( (*(ptdata
++)!=r
) | (*(ptdata
++)!=g
) | (*(ptdata
++)!=b
) )
1022 for( i
=0; i
< padding
; i
++ ) *(ptbits
++) = zero
;
1024 ::StretchDIBits( memdc
, 0, origin
, width
, height
,\
1025 0, 0, width
, height
, lpBits
, lpDIBh
, DIB_RGB_COLORS
, SRCCOPY
);
1028 // create a wxMask object
1029 wxMask
*mask
= new wxMask();
1030 mask
->SetMaskBitmap( (WXHBITMAP
) hbitmap
);
1031 bitmap
.SetMask( mask
);
1032 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
1033 /* The following can also be used but is slow to run
1034 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
1035 wxMask *mask = new wxMask( bitmap, colour );
1036 bitmap.SetMask( mask );
1040 // free allocated resources
1041 ::SelectObject( memdc
, 0 );
1042 ::DeleteDC( memdc
);
1043 ::ReleaseDC(NULL
, hdc
);
1047 // check the wxBitmap object
1048 if( bitmap
.GetHBITMAP() )
1049 bitmap
.SetOk( TRUE
);
1051 bitmap
.SetOk( FALSE
);
1056 wxImage::wxImage( const wxBitmap
&bitmap
)
1061 wxFAIL_MSG( "invalid bitmap" );
1065 // create an wxImage object
1066 int width
= bitmap
.GetWidth();
1067 int height
= bitmap
.GetHeight();
1068 Create( width
, height
);
1069 unsigned char *data
= GetData();
1072 wxFAIL_MSG( "could not allocate data for image" );
1076 // calc the number of bytes per scanline and padding in the DIB
1077 int bytePerLine
= width
*3;
1078 int sizeDWORD
= sizeof( DWORD
);
1079 div_t lineBoundary
= div( bytePerLine
, sizeDWORD
);
1081 if( lineBoundary
.rem
> 0 )
1083 padding
= sizeDWORD
- lineBoundary
.rem
;
1084 bytePerLine
+= padding
;
1087 // create a DIB header
1088 int headersize
= sizeof(BITMAPINFOHEADER
);
1089 LPBITMAPINFO lpDIBh
= (BITMAPINFO
*) malloc( headersize
);
1092 wxFAIL_MSG( "could not allocate data for DIB header" );
1096 // Fill in the DIB header
1097 lpDIBh
->bmiHeader
.biSize
= headersize
;
1098 lpDIBh
->bmiHeader
.biWidth
= width
;
1099 lpDIBh
->bmiHeader
.biHeight
= -height
;
1100 lpDIBh
->bmiHeader
.biSizeImage
= bytePerLine
* height
;
1101 lpDIBh
->bmiHeader
.biPlanes
= 1;
1102 lpDIBh
->bmiHeader
.biBitCount
= 24;
1103 lpDIBh
->bmiHeader
.biCompression
= BI_RGB
;
1104 lpDIBh
->bmiHeader
.biClrUsed
= 0;
1105 // These seem not really needed for our purpose here.
1106 lpDIBh
->bmiHeader
.biClrImportant
= 0;
1107 lpDIBh
->bmiHeader
.biXPelsPerMeter
= 0;
1108 lpDIBh
->bmiHeader
.biYPelsPerMeter
= 0;
1109 // memory for DIB data
1110 unsigned char *lpBits
;
1111 lpBits
= (unsigned char *) malloc( lpDIBh
->bmiHeader
.biSizeImage
);
1114 wxFAIL_MSG( "could not allocate data for DIB" );
1120 // copy data from the device-dependent bitmap to the DIB
1121 HDC hdc
= ::GetDC(NULL
);
1123 hbitmap
= (HBITMAP
) bitmap
.GetHBITMAP();
1124 ::GetDIBits( hdc
, hbitmap
, 0, height
, lpBits
, lpDIBh
, DIB_RGB_COLORS
);
1126 // copy DIB data into the wxImage object
1128 unsigned char *ptdata
= data
;
1129 unsigned char *ptbits
= lpBits
;
1130 for( i
=0; i
<height
; i
++ )
1132 for( j
=0; j
<width
; j
++ )
1134 *(ptdata
++) = *(ptbits
+2);
1135 *(ptdata
++) = *(ptbits
+1);
1136 *(ptdata
++) = *(ptbits
);
1142 // similarly, set data according to the possible mask bitmap
1143 if( bitmap
.GetMask() && bitmap
.GetMask()->GetMaskBitmap() )
1145 hbitmap
= (HBITMAP
) bitmap
.GetMask()->GetMaskBitmap();
1146 // memory DC created, color set, data copied, and memory DC deleted
1147 HDC memdc
= ::CreateCompatibleDC( hdc
);
1148 ::SetTextColor( memdc
, RGB( 0, 0, 0 ) );
1149 ::SetBkColor( memdc
, RGB( 255, 255, 255 ) );
1150 ::GetDIBits( memdc
, hbitmap
, 0, height
, lpBits
, lpDIBh
, DIB_RGB_COLORS
);
1151 ::DeleteDC( memdc
);
1152 // background color set to RGB(16,16,16) in consistent with wxGTK
1153 unsigned char r
=16, g
=16, b
=16;
1156 for( i
=0; i
<height
; i
++ )
1158 for( j
=0; j
<width
; j
++ )
1172 SetMaskColour( r
, g
, b
);
1179 // free allocated resources
1180 ::ReleaseDC(NULL
, hdc
);
1189 #include "gtk/gtk.h"
1190 #include "gdk/gdk.h"
1191 #include "gdk/gdkx.h"
1193 wxBitmap
wxImage::ConvertToBitmap() const
1197 wxCHECK_MSG( Ok(), bitmap
, "invalid image" );
1199 int width
= GetWidth();
1200 int height
= GetHeight();
1202 bitmap
.SetHeight( height
);
1203 bitmap
.SetWidth( width
);
1207 GdkImage
*data_image
=
1208 gdk_image_new( GDK_IMAGE_FASTEST
, gdk_visual_get_system(), width
, height
);
1210 bitmap
.SetPixmap( gdk_pixmap_new( (GdkWindow
*)&gdk_root_parent
, width
, height
, -1 ) );
1214 GdkImage
*mask_image
= (GdkImage
*) NULL
;
1218 unsigned char *mask_data
= (unsigned char*)malloc( ((width
>> 3)+8) * height
);
1220 mask_image
= gdk_image_new_bitmap( gdk_visual_get_system(), mask_data
, width
, height
);
1222 wxMask
*mask
= new wxMask();
1223 mask
->m_bitmap
= gdk_pixmap_new( (GdkWindow
*)&gdk_root_parent
, width
, height
, 1 );
1225 bitmap
.SetMask( mask
);
1230 GdkVisual
*visual
= gdk_window_get_visual( bitmap
.GetPixmap() );
1231 if (visual
== NULL
) visual
= gdk_window_get_visual( (GdkWindow
*) &gdk_root_parent
);
1232 int bpp
= visual
->depth
;
1234 bitmap
.SetDepth( bpp
);
1236 if ((bpp
== 16) && (visual
->red_mask
!= 0xf800)) bpp
= 15;
1237 if (bpp
< 8) bpp
= 8;
1241 enum byte_order
{ RGB
, RBG
, BRG
, BGR
, GRB
, GBR
};
1242 byte_order b_o
= RGB
;
1246 GdkVisual
*visual
= gdk_visual_get_system();
1247 if ((visual
->red_mask
> visual
->green_mask
) && (visual
->green_mask
> visual
->blue_mask
)) b_o
= RGB
;
1248 else if ((visual
->red_mask
> visual
->blue_mask
) && (visual
->blue_mask
> visual
->green_mask
)) b_o
= RGB
;
1249 else if ((visual
->blue_mask
> visual
->red_mask
) && (visual
->red_mask
> visual
->green_mask
)) b_o
= BRG
;
1250 else if ((visual
->blue_mask
> visual
->green_mask
) && (visual
->green_mask
> visual
->red_mask
)) b_o
= BGR
;
1251 else if ((visual
->green_mask
> visual
->red_mask
) && (visual
->red_mask
> visual
->blue_mask
)) b_o
= GRB
;
1252 else if ((visual
->green_mask
> visual
->blue_mask
) && (visual
->blue_mask
> visual
->red_mask
)) b_o
= GBR
;
1255 int r_mask
= GetMaskRed();
1256 int g_mask
= GetMaskGreen();
1257 int b_mask
= GetMaskBlue();
1259 unsigned char* data
= GetData();
1262 for (int y
= 0; y
< height
; y
++)
1264 for (int x
= 0; x
< width
; x
++)
1266 int r
= data
[index
];
1268 int g
= data
[index
];
1270 int b
= data
[index
];
1275 if ((r
== r_mask
) && (b
== b_mask
) && (g
== g_mask
))
1276 gdk_image_put_pixel( mask_image
, x
, y
, 1 );
1278 gdk_image_put_pixel( mask_image
, x
, y
, 0 );
1283 if ((r
== r_mask
) && (b
== b_mask
) && (g
== g_mask
))
1284 gdk_image_put_pixel( mask_image
, x
, y
, 1 );
1286 gdk_image_put_pixel( mask_image
, x
, y
, 0 );
1294 if (wxTheApp
->m_colorCube
)
1296 pixel
= wxTheApp
->m_colorCube
[ ((r
& 0xf8) << 7) + ((g
& 0xf8) << 2) + ((b
& 0xf8) >> 3) ];
1300 GdkColormap
*cmap
= gtk_widget_get_default_colormap();
1301 GdkColor
*colors
= cmap
->colors
;
1302 int max
= 3 * (65536);
1304 for (int i
= 0; i
< cmap
->size
; i
++)
1306 int rdiff
= (r
<< 8) - colors
[i
].red
;
1307 int gdiff
= (g
<< 8) - colors
[i
].green
;
1308 int bdiff
= (b
<< 8) - colors
[i
].blue
;
1309 int sum
= ABS (rdiff
) + ABS (gdiff
) + ABS (bdiff
);
1310 if (sum
< max
) { pixel
= i
; max
= sum
; }
1314 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
1320 guint32 pixel
= ((r
& 0xf8) << 7) | ((g
& 0xf8) << 2) | ((b
& 0xf8) >> 3);
1321 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
1326 guint32 pixel
= ((r
& 0xf8) << 8) | ((g
& 0xfc) << 3) | ((b
& 0xf8) >> 3);
1327 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
1336 case RGB
: pixel
= (r
<< 16) | (g
<< 8) | b
; break;
1337 case RBG
: pixel
= (r
<< 16) | (b
<< 8) | g
; break;
1338 case BRG
: pixel
= (b
<< 16) | (r
<< 8) | g
; break;
1339 case BGR
: pixel
= (b
<< 16) | (g
<< 8) | r
; break;
1340 case GRB
: pixel
= (g
<< 16) | (r
<< 8) | b
; break;
1341 case GBR
: pixel
= (g
<< 16) | (b
<< 8) | r
; break;
1343 gdk_image_put_pixel( data_image
, x
, y
, pixel
);
1352 GdkGC
*data_gc
= gdk_gc_new( bitmap
.GetPixmap() );
1354 gdk_draw_image( bitmap
.GetPixmap(), data_gc
, data_image
, 0, 0, 0, 0, width
, height
);
1356 gdk_image_destroy( data_image
);
1357 gdk_gc_unref( data_gc
);
1363 GdkGC
*mask_gc
= gdk_gc_new( bitmap
.GetMask()->GetBitmap() );
1365 gdk_draw_image( bitmap
.GetMask()->GetBitmap(), mask_gc
, mask_image
, 0, 0, 0, 0, width
, height
);
1367 gdk_image_destroy( mask_image
);
1368 gdk_gc_unref( mask_gc
);
1374 wxImage::wxImage( const wxBitmap
&bitmap
)
1376 wxCHECK_RET( bitmap
.Ok(), "invalid bitmap" );
1378 GdkImage
*gdk_image
= gdk_image_get( bitmap
.GetPixmap(),
1380 bitmap
.GetWidth(), bitmap
.GetHeight() );
1382 wxCHECK_RET( gdk_image
, "couldn't create image" );
1384 Create( bitmap
.GetWidth(), bitmap
.GetHeight() );
1385 char unsigned *data
= GetData();
1389 gdk_image_destroy( gdk_image
);
1390 wxFAIL_MSG( "couldn't create image" );
1394 GdkImage
*gdk_image_mask
= (GdkImage
*) NULL
;
1395 if (bitmap
.GetMask())
1397 gdk_image_mask
= gdk_image_get( bitmap
.GetMask()->GetBitmap(),
1399 bitmap
.GetWidth(), bitmap
.GetHeight() );
1401 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1404 GdkVisual
*visual
= gdk_window_get_visual( bitmap
.GetPixmap() );
1405 if (visual
== NULL
) visual
= gdk_window_get_visual( (GdkWindow
*) &gdk_root_parent
);
1406 int bpp
= visual
->depth
;
1407 if ((bpp
== 16) && (visual
->red_mask
!= 0xf800)) bpp
= 15;
1409 GdkColormap
*cmap
= gtk_widget_get_default_colormap();
1412 for (int j
= 0; j
< bitmap
.GetHeight(); j
++)
1414 for (int i
= 0; i
< bitmap
.GetWidth(); i
++)
1416 int pixel
= gdk_image_get_pixel( gdk_image
, i
, j
);
1419 data
[pos
] = cmap
->colors
[pixel
].red
>> 8;
1420 data
[pos
+1] = cmap
->colors
[pixel
].green
>> 8;
1421 data
[pos
+2] = cmap
->colors
[pixel
].blue
>> 8;
1422 } else if (bpp
== 15)
1424 data
[pos
] = (pixel
>> 7) & 0xf8;
1425 data
[pos
+1] = (pixel
>> 2) & 0xf8;
1426 data
[pos
+2] = (pixel
<< 3) & 0xf8;
1427 } else if (bpp
== 16)
1429 data
[pos
] = (pixel
>> 8) & 0xf8;
1430 data
[pos
+1] = (pixel
>> 3) & 0xfc;
1431 data
[pos
+2] = (pixel
<< 3) & 0xf8;
1434 data
[pos
] = (pixel
>> 16) & 0xff;
1435 data
[pos
+1] = (pixel
>> 8) & 0xff;
1436 data
[pos
+2] = pixel
& 0xff;
1441 int mask_pixel
= gdk_image_get_pixel( gdk_image_mask
, i
, j
);
1442 if (mask_pixel
== 0)
1454 gdk_image_destroy( gdk_image
);
1455 if (gdk_image_mask
) gdk_image_destroy( gdk_image_mask
);
1463 #include "wx/utils.h"
1466 wxBitmap
wxImage::ConvertToBitmap() const
1470 wxCHECK_MSG( Ok(), bitmap
, "invalid image" );
1472 int width
= GetWidth();
1473 int height
= GetHeight();
1475 bitmap
.SetHeight( height
);
1476 bitmap
.SetWidth( width
);
1478 Display
*dpy
= (Display
*) wxGetDisplay();
1479 Visual
* vis
= DefaultVisual( dpy
, DefaultScreen( dpy
) );
1480 int bpp
= DefaultDepth( dpy
, DefaultScreen( dpy
) );
1484 XImage
*data_image
= XCreateImage( dpy
, vis
, bpp
, ZPixmap
, 0, 0, width
, height
, 32, 0 );
1485 data_image
->data
= (char*) malloc( data_image
->bytes_per_line
* data_image
->height
);
1487 bitmap
.Create( width
, height
, bpp
);
1492 GdkImage *mask_image = (GdkImage*) NULL;
1496 unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
1498 mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
1500 wxMask *mask = new wxMask();
1501 mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
1503 bitmap.SetMask( mask );
1507 // Retrieve depth info
1509 XVisualInfo vinfo_template
;
1512 vinfo_template
.visual
= vis
;
1513 vinfo_template
.visualid
= XVisualIDFromVisual( vis
);
1514 vinfo_template
.depth
= bpp
;
1517 vi
= XGetVisualInfo( dpy
, VisualIDMask
|VisualDepthMask
, &vinfo_template
, &nitem
);
1521 printf("no visual.\n" );
1522 return wxNullBitmap
;
1527 if ((bpp
== 16) && (vi
->red_mask
!= 0xf800)) bpp
= 15;
1528 if (bpp
< 8) bpp
= 8;
1532 enum byte_order
{ RGB
, RBG
, BRG
, BGR
, GRB
, GBR
};
1533 byte_order b_o
= RGB
;
1537 if ((vi
->red_mask
> vi
->green_mask
) && (vi
->green_mask
> vi
->blue_mask
)) b_o
= RGB
;
1538 else if ((vi
->red_mask
> vi
->blue_mask
) && (vi
->blue_mask
> vi
->green_mask
)) b_o
= RGB
;
1539 else if ((vi
->blue_mask
> vi
->red_mask
) && (vi
->red_mask
> vi
->green_mask
)) b_o
= BRG
;
1540 else if ((vi
->blue_mask
> vi
->green_mask
) && (vi
->green_mask
> vi
->red_mask
)) b_o
= BGR
;
1541 else if ((vi
->green_mask
> vi
->red_mask
) && (vi
->red_mask
> vi
->blue_mask
)) b_o
= GRB
;
1542 else if ((vi
->green_mask
> vi
->blue_mask
) && (vi
->blue_mask
> vi
->red_mask
)) b_o
= GBR
;
1546 int r_mask = GetMaskRed();
1547 int g_mask = GetMaskGreen();
1548 int b_mask = GetMaskBlue();
1554 Colormap cmap
= (Colormap
) wxTheApp
->GetMainColormap( dpy
);
1556 for (int i
= 0; i
< 256; i
++) colors
[i
].pixel
= i
;
1557 XQueryColors( dpy
, cmap
, colors
, 256 );
1560 unsigned char* data
= GetData();
1563 for (int y
= 0; y
< height
; y
++)
1565 for (int x
= 0; x
< width
; x
++)
1567 int r
= data
[index
];
1569 int g
= data
[index
];
1571 int b
= data
[index
];
1577 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
1578 gdk_image_put_pixel( mask_image, x, y, 1 );
1580 gdk_image_put_pixel( mask_image, x, y, 0 );
1590 if (wxTheApp->m_colorCube)
1592 pixel = wxTheApp->m_colorCube
1593 [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
1598 int max
= 3 * (65536);
1599 for (int i
= 0; i
< 256; i
++)
1601 int rdiff
= (r
<< 8) - colors
[i
].red
;
1602 int gdiff
= (g
<< 8) - colors
[i
].green
;
1603 int bdiff
= (b
<< 8) - colors
[i
].blue
;
1604 int sum
= abs (rdiff
) + abs (gdiff
) + abs (bdiff
);
1605 if (sum
< max
) { pixel
= i
; max
= sum
; }
1610 XPutPixel( data_image
, x
, y
, pixel
);
1615 int pixel
= ((r
& 0xf8) << 7) | ((g
& 0xf8) << 2) | ((b
& 0xf8) >> 3);
1616 XPutPixel( data_image
, x
, y
, pixel
);
1621 int pixel
= ((r
& 0xf8) << 8) | ((g
& 0xfc) << 3) | ((b
& 0xf8) >> 3);
1622 XPutPixel( data_image
, x
, y
, pixel
);
1631 case RGB
: pixel
= (r
<< 16) | (g
<< 8) | b
; break;
1632 case RBG
: pixel
= (r
<< 16) | (b
<< 8) | g
; break;
1633 case BRG
: pixel
= (b
<< 16) | (r
<< 8) | g
; break;
1634 case BGR
: pixel
= (b
<< 16) | (g
<< 8) | r
; break;
1635 case GRB
: pixel
= (g
<< 16) | (r
<< 8) | b
; break;
1636 case GBR
: pixel
= (g
<< 16) | (b
<< 8) | r
; break;
1638 XPutPixel( data_image
, x
, y
, pixel
);
1648 gcvalues
.foreground
= BlackPixel( dpy
, DefaultScreen( dpy
) );
1649 GC gc
= XCreateGC( dpy
, RootWindow ( dpy
, DefaultScreen(dpy
) ), GCForeground
, &gcvalues
);
1650 XPutImage( dpy
, (Drawable
)bitmap
.GetPixmap(), gc
, data_image
, 0, 0, 0, 0, width
, height
);
1652 XDestroyImage( data_image
);
1660 GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
1662 gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
1664 gdk_image_destroy( mask_image );
1665 gdk_gc_unref( mask_gc );
1672 wxImage::wxImage( const wxBitmap
&bitmap
)
1674 wxCHECK_RET( bitmap
.Ok(), "invalid bitmap" );
1676 Display
*dpy
= (Display
*) wxGetDisplay();
1677 Visual
* vis
= DefaultVisual( dpy
, DefaultScreen( dpy
) );
1678 int bpp
= DefaultDepth( dpy
, DefaultScreen( dpy
) );
1680 XImage
*ximage
= XGetImage( dpy
,
1681 (Drawable
)bitmap
.GetPixmap(),
1683 bitmap
.GetWidth(), bitmap
.GetHeight(),
1684 AllPlanes
, ZPixmap
);
1686 wxCHECK_RET( ximage
, "couldn't create image" );
1688 Create( bitmap
.GetWidth(), bitmap
.GetHeight() );
1689 char unsigned *data
= GetData();
1693 XDestroyImage( ximage
);
1694 wxFAIL_MSG( "couldn't create image" );
1699 GdkImage *gdk_image_mask = (GdkImage*) NULL;
1700 if (bitmap.GetMask())
1702 gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
1704 bitmap.GetWidth(), bitmap.GetHeight() );
1706 SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
1710 // Retrieve depth info
1712 XVisualInfo vinfo_template
;
1715 vinfo_template
.visual
= vis
;
1716 vinfo_template
.visualid
= XVisualIDFromVisual( vis
);
1717 vinfo_template
.depth
= bpp
;
1720 vi
= XGetVisualInfo( dpy
, VisualIDMask
|VisualDepthMask
, &vinfo_template
, &nitem
);
1724 printf("no visual.\n" );
1728 if ((bpp
== 16) && (vi
->red_mask
!= 0xf800)) bpp
= 15;
1735 Colormap cmap
= (Colormap
)wxTheApp
->GetMainColormap( dpy
);
1737 for (int i
= 0; i
< 256; i
++) colors
[i
].pixel
= i
;
1738 XQueryColors( dpy
, cmap
, colors
, 256 );
1742 for (int j
= 0; j
< bitmap
.GetHeight(); j
++)
1744 for (int i
= 0; i
< bitmap
.GetWidth(); i
++)
1746 int pixel
= XGetPixel( ximage
, i
, j
);
1749 data
[pos
] = colors
[pixel
].red
>> 8;
1750 data
[pos
+1] = colors
[pixel
].green
>> 8;
1751 data
[pos
+2] = colors
[pixel
].blue
>> 8;
1752 } else if (bpp
== 15)
1754 data
[pos
] = (pixel
>> 7) & 0xf8;
1755 data
[pos
+1] = (pixel
>> 2) & 0xf8;
1756 data
[pos
+2] = (pixel
<< 3) & 0xf8;
1757 } else if (bpp
== 16)
1759 data
[pos
] = (pixel
>> 8) & 0xf8;
1760 data
[pos
+1] = (pixel
>> 3) & 0xfc;
1761 data
[pos
+2] = (pixel
<< 3) & 0xf8;
1764 data
[pos
] = (pixel
>> 16) & 0xff;
1765 data
[pos
+1] = (pixel
>> 8) & 0xff;
1766 data
[pos
+2] = pixel
& 0xff;
1772 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1773 if (mask_pixel == 0)
1786 XDestroyImage( ximage
);
1788 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1793 // A module to allow wxImage initialization/cleanup
1794 // without calling these functions from app.cpp or from
1795 // the user's application.
1797 class wxImageModule
: public wxModule
1799 DECLARE_DYNAMIC_CLASS(wxImageModule
)
1802 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE
; };
1803 void OnExit() { wxImage::CleanUpHandlers(); };
1806 IMPLEMENT_DYNAMIC_CLASS(wxImageModule
, wxModule
)