1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Stefan Csomor
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #include "wx/wxprec.h"
14 #include "wx/bitmap.h"
18 #include "wx/metafile.h"
19 #include "wx/xpmdecod.h"
21 #include "wx/rawbmp.h"
23 IMPLEMENT_DYNAMIC_CLASS(wxBitmap
, wxGDIObject
)
24 IMPLEMENT_DYNAMIC_CLASS(wxMask
, wxObject
)
25 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler
, wxObject
)
28 #include <ApplicationServices/ApplicationServices.h>
30 #include <PictUtils.h>
33 #include "wx/mac/uma.h"
34 #include "wx/dcmemory.h"
36 // Implementation Notes
37 // --------------------
39 // we are always working with a 32 bit deep pixel buffer
40 // under QuickDraw its alpha parts are going to be ignored in the GWorld,
41 // therefore we have a separate GWorld there for blitting the mask in
43 // under Quartz then content is transformed into a CGImageRef representing the same data
44 // which can be transferred to the GPU by the OS for fast rendering
46 // we don't dare use premultiplied alpha yet
47 #define wxMAC_USE_PREMULTIPLIED_ALPHA 0
51 void wxMacCreateBitmapButton( ControlButtonContentInfo
*info
, const wxBitmap
& bitmap
, int forceType
)
53 memset( info
, 0 , sizeof(ControlButtonContentInfo
) ) ;
56 wxBitmapRefData
* bmap
= bitmap
.GetBitmapData() ;
60 if ( ( bmap
->HasNativeSize() && forceType
== 0 ) || forceType
== kControlContentIconRef
)
63 wxBitmapRefData
* bmp
= bmap
;
65 if ( !bmap
->HasNativeSize() )
67 // as PICT conversion will only result in a 16x16 icon, let's attempt
68 // a few scales for better results
70 int w
= bitmap
.GetWidth() ;
71 int h
= bitmap
.GetHeight() ;
72 int sz
= wxMax( w
, h
) ;
73 if ( sz
== 24 || sz
== 64 )
75 scaleBmp
= wxBitmap( bitmap
.ConvertToImage().Scale( w
* 2 , h
* 2 ) ) ;
76 bmp
= scaleBmp
.GetBitmapData() ;
80 info
->contentType
= kControlContentIconRef
;
81 info
->u
.iconRef
= bmp
->GetIconRef() ;
82 AcquireIconRef( info
->u
.iconRef
) ;
84 #if defined( __WXMAC_OSX__ ) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
85 else if ( forceType
== kControlContentCGImageRef
)
87 info
->contentType
= kControlContentCGImageRef
;
88 info
->u
.imageRef
= (CGImageRef
) bmap
->CGImageCreate() ;
93 info
->contentType
= kControlContentPictHandle
;
94 info
->u
.picture
= bmap
->GetPictHandle() ;
99 void wxMacReleaseBitmapButton( ControlButtonContentInfo
*info
)
101 if ( info
->contentType
== kControlContentIconRef
)
103 ReleaseIconRef( info
->u
.iconRef
) ;
105 else if ( info
->contentType
== kControlNoContent
)
107 // there's no bitmap at all, fall through silently
109 else if ( info
->contentType
== kControlContentPictHandle
)
111 // owned by the bitmap, no release here
113 #if defined( __WXMAC_OSX__ ) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
114 else if ( info
->contentType
== kControlContentCGImageRef
)
116 CGImageRelease( info
->u
.imageRef
) ;
121 wxFAIL_MSG(wxT("Unexpected bitmap type") ) ;
125 #endif //wxUSE_BMPBUTTON
127 #define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
129 void wxBitmapRefData::Init()
135 m_bitmapMask
= NULL
;
138 m_cgImageRef
= NULL
;
142 m_pictHandle
= NULL
;
144 m_hMaskBitmap
= NULL
;
145 m_maskBytesPerRow
= 0 ;
147 m_rawAccessCount
= 0 ;
151 wxBitmapRefData::wxBitmapRefData()
156 wxBitmapRefData::wxBitmapRefData( int w
, int h
, int d
)
159 Create( w
, h
, d
) ;
162 bool wxBitmapRefData::Create( int w
, int h
, int d
)
168 m_bytesPerRow
= w
* 4 ;
169 size_t size
= m_bytesPerRow
* h
;
170 void* data
= m_memBuf
.GetWriteBuf( size
) ;
171 memset( data
, 0 , size
) ;
172 m_memBuf
.UngetWriteBuf( size
) ;
175 Rect rect
= { 0 , 0 , m_height
, m_width
} ;
176 verify_noerr( NewGWorldFromPtr( (GWorldPtr
*) &m_hBitmap
, k32ARGBPixelFormat
, &rect
, NULL
, NULL
, 0 ,
177 (char*) data
, m_bytesPerRow
) ) ;
178 wxASSERT_MSG( m_hBitmap
, wxT("Unable to create GWorld context") ) ;
180 m_ok
= ( m_hBitmap
!= NULL
) ;
185 void wxBitmapRefData::UseAlpha( bool use
)
187 if ( m_hasAlpha
== use
)
193 wxASSERT( m_hMaskBitmap
== NULL
) ;
195 int width
= GetWidth() ;
196 int height
= GetHeight() ;
197 m_maskBytesPerRow
= ( width
* 4 + 3 ) & 0xFFFFFFC ;
198 size_t size
= height
* m_maskBytesPerRow
;
199 unsigned char * data
= (unsigned char * ) m_maskMemBuf
.GetWriteBuf( size
) ;
200 wxASSERT( data
!= NULL
) ;
202 memset( data
, 0 , size
) ;
203 Rect rect
= { 0 , 0 , height
, width
} ;
204 verify_noerr( NewGWorldFromPtr( (GWorldPtr
*) &m_hMaskBitmap
, k32ARGBPixelFormat
, &rect
, NULL
, NULL
, 0 ,
205 (char*) data
, m_maskBytesPerRow
) ) ;
206 wxASSERT_MSG( m_hMaskBitmap
, wxT("Unable to create GWorld context for alpha mask") ) ;
207 m_maskMemBuf
.UngetWriteBuf(size
) ;
209 #if !wxMAC_USE_CORE_GRAPHICS
215 DisposeGWorld( m_hMaskBitmap
) ;
216 m_hMaskBitmap
= NULL
;
217 m_maskBytesPerRow
= 0 ;
221 void *wxBitmapRefData::GetRawAccess() const
223 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") ) ;
224 return m_memBuf
.GetData() ;
227 void *wxBitmapRefData::BeginRawAccess()
229 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") ) ;
230 wxASSERT( m_rawAccessCount
== 0 ) ;
231 wxASSERT_MSG( m_pictHandle
== NULL
&& m_iconRef
== NULL
,
232 wxT("Currently, modifing bitmaps that are used in controls already is not supported") ) ;
237 // we must destroy an existing cached image, as
238 // the bitmap data may change now
241 CGImageRelease( m_cgImageRef
) ;
242 m_cgImageRef
= NULL
;
246 return m_memBuf
.GetData() ;
249 void wxBitmapRefData::EndRawAccess()
251 wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
252 wxASSERT( m_rawAccessCount
== 1 ) ;
256 #if !wxMAC_USE_CORE_GRAPHICS
261 bool wxBitmapRefData::HasNativeSize()
264 int h
= GetHeight() ;
265 int sz
= wxMax( w
, h
) ;
267 return ( sz
== 128 || sz
== 48 || sz
== 32 || sz
== 16 );
270 IconRef
wxBitmapRefData::GetIconRef()
272 if ( m_iconRef
== NULL
)
274 // Create Icon Family Handle
276 IconFamilyHandle iconFamily
= NULL
;
278 #ifdef WORDS_BIGENDIAN
279 iconFamily
= (IconFamilyHandle
) NewHandle( 8 ) ;
280 (**iconFamily
).resourceType
= kIconFamilyType
;
281 (**iconFamily
).resourceSize
= sizeof(OSType
) + sizeof(Size
);
283 // test this solution on big endian as well
284 iconFamily
= (IconFamilyHandle
) NewHandle( 0 ) ;
288 int h
= GetHeight() ;
289 int sz
= wxMax( w
, h
) ;
291 OSType dataType
= 0 ;
292 OSType maskType
= 0 ;
297 dataType
= kThumbnail32BitData
;
298 maskType
= kThumbnail8BitMask
;
302 dataType
= kHuge32BitData
;
303 maskType
= kHuge8BitMask
;
307 dataType
= kLarge32BitData
;
308 maskType
= kLarge8BitMask
;
312 dataType
= kSmall32BitData
;
313 maskType
= kSmall8BitMask
;
322 // setup the header properly
325 Handle maskdata
= NULL
;
326 unsigned char * maskptr
= NULL
;
327 unsigned char * ptr
= NULL
;
328 size_t datasize
, masksize
;
330 datasize
= sz
* sz
* 4 ;
331 data
= NewHandle( datasize
) ;
333 ptr
= (unsigned char*) *data
;
334 memset( ptr
, 0, datasize
) ;
337 maskdata
= NewHandle( masksize
) ;
339 maskptr
= (unsigned char*) *maskdata
;
340 memset( maskptr
, 0 , masksize
) ;
342 bool hasAlpha
= HasAlpha() ;
343 wxMask
*mask
= m_bitmapMask
;
344 unsigned char * source
= (unsigned char*) GetRawAccess() ;
345 unsigned char * masksource
= mask
? (unsigned char*) mask
->GetRawAccess() : NULL
;
347 for ( int y
= 0 ; y
< h
; ++y
)
349 unsigned char * dest
= ptr
+ y
* sz
* 4 ;
350 unsigned char * maskdest
= maskptr
+ y
* sz
;
351 unsigned char a
, r
, g
, b
;
353 for ( int x
= 0 ; x
< w
; ++x
)
367 *maskdest
++ = 0xFF - *masksource
++ ;
378 OSStatus err
= SetIconFamilyData( iconFamily
, dataType
, data
) ;
379 wxASSERT_MSG( err
== noErr
, wxT("Error when adding bitmap") ) ;
381 err
= SetIconFamilyData( iconFamily
, maskType
, maskdata
) ;
382 wxASSERT_MSG( err
== noErr
, wxT("Error when adding mask") ) ;
385 HUnlock( maskdata
) ;
386 DisposeHandle( data
) ;
387 DisposeHandle( maskdata
) ;
391 PicHandle pic
= GetPictHandle() ;
392 SetIconFamilyData( iconFamily
, 'PICT' , (Handle
) pic
) ;
395 // transform into IconRef
397 static int iconCounter
= 2 ;
399 OSStatus err
= RegisterIconRefFromIconFamily( 'WXNG' , (OSType
) iconCounter
, iconFamily
, &m_iconRef
) ;
400 wxASSERT_MSG( err
== noErr
, wxT("Error when adding bitmap") ) ;
402 // we have to retain a reference, as Unregister will decrement it
403 AcquireIconRef( m_iconRef
) ;
404 UnregisterIconRef( 'WXNG' , (OSType
) iconCounter
) ;
405 DisposeHandle( (Handle
) iconFamily
) ;
412 PicHandle
wxBitmapRefData::GetPictHandle()
414 if ( m_pictHandle
== NULL
)
416 CGrafPtr origPort
= NULL
;
417 GDHandle origDev
= NULL
;
418 GWorldPtr wp
= NULL
;
419 GWorldPtr mask
= NULL
;
420 int height
= GetHeight() ;
421 int width
= GetWidth() ;
423 Rect rect
= { 0 , 0 , height
, width
} ;
424 RgnHandle clipRgn
= NULL
;
426 GetGWorld( &origPort
, &origDev
) ;
427 wp
= GetHBITMAP( &mask
) ;
431 GWorldPtr monoworld
;
433 OSStatus err
= NewGWorld( &monoworld
, 1 , &rect
, NULL
, NULL
, 0 ) ;
435 LockPixels( GetGWorldPixMap( monoworld
) ) ;
436 LockPixels( GetGWorldPixMap( mask
) ) ;
437 SetGWorld( monoworld
, NULL
) ;
439 RGBColor white
= { 0xffff , 0xffff , 0xffff } ;
440 RGBColor black
= { 0x0000 , 0x0000 , 0x0000 } ;
441 RGBForeColor( &black
) ;
442 RGBBackColor( &white
) ;
444 CopyBits(GetPortBitMapForCopyBits(mask
),
445 GetPortBitMapForCopyBits(monoworld
),
449 BitMapToRegion( clipRgn
, (BitMap
*) *GetGWorldPixMap( monoworld
) ) ;
451 UnlockPixels( GetGWorldPixMap( monoworld
) ) ;
452 UnlockPixels( GetGWorldPixMap( mask
) ) ;
453 DisposeGWorld( monoworld
) ;
456 SetGWorld( wp
, NULL
) ;
458 GetPortBounds( wp
, &portRect
) ;
459 m_pictHandle
= OpenPicture(&portRect
);
463 RGBColor white
= { 0xffff , 0xffff , 0xffff } ;
464 RGBColor black
= { 0x0000 , 0x0000 , 0x0000 } ;
466 RGBForeColor( &black
) ;
467 RGBBackColor( &white
) ;
472 LockPixels( GetGWorldPixMap( wp
) ) ;
473 CopyBits(GetPortBitMapForCopyBits(wp
),
474 GetPortBitMapForCopyBits(wp
),
478 UnlockPixels( GetGWorldPixMap( wp
) ) ;
482 SetGWorld( origPort
, origDev
) ;
484 DisposeRgn( clipRgn
) ;
487 return m_pictHandle
;
491 void wxMacMemoryBufferReleaseProc(void *info
, const void *data
, size_t size
)
493 wxMemoryBuffer
* membuf
= (wxMemoryBuffer
*) info
;
495 wxASSERT( data
== membuf
->GetData() ) ;
500 CGImageRef
wxBitmapRefData::CGImageCreate() const
503 wxASSERT( m_rawAccessCount
>= 0 ) ;
505 if ( m_rawAccessCount
> 0 || m_cgImageRef
== NULL
)
507 size_t imageSize
= m_width
* m_height
* 4 ;
508 void * dataBuffer
= m_memBuf
.GetData() ;
511 CGImageAlphaInfo alphaInfo
= kCGImageAlphaNoneSkipFirst
;
512 wxMemoryBuffer
* membuf
= NULL
;
516 alphaInfo
= kCGImageAlphaFirst
;
517 membuf
= new wxMemoryBuffer( imageSize
) ;
518 memcpy( membuf
->GetData() , dataBuffer
, imageSize
) ;
519 unsigned char *sourcemaskstart
= (unsigned char *) m_bitmapMask
->GetRawAccess() ;
520 int maskrowbytes
= m_bitmapMask
->GetBytesPerRow() ;
521 unsigned char *destalpha
= (unsigned char *) membuf
->GetData() ;
522 for ( int y
= 0 ; y
< h
; ++y
, sourcemaskstart
+= maskrowbytes
)
524 unsigned char *sourcemask
= sourcemaskstart
;
525 for ( int x
= 0 ; x
< w
; ++x
, sourcemask
+=3 , destalpha
+= 4 )
527 *destalpha
= 0xFF - *sourcemask
;
535 #if wxMAC_USE_PREMULTIPLIED_ALPHA
536 alphaInfo
= kCGImageAlphaPremultipliedFirst
;
538 alphaInfo
= kCGImageAlphaFirst
;
542 membuf
= new wxMemoryBuffer( m_memBuf
) ;
545 CGColorSpaceRef colorSpace
= wxMacGetGenericRGBColorSpace();
546 CGDataProviderRef dataProvider
=
547 CGDataProviderCreateWithData(
548 membuf
, (const void *)membuf
->GetData() , imageSize
,
549 wxMacMemoryBufferReleaseProc
);
552 w
, h
, 8 , 32 , 4 * m_width
, colorSpace
, alphaInfo
,
553 dataProvider
, NULL
, false , kCGRenderingIntentDefault
);
554 CGDataProviderRelease( dataProvider
);
558 image
= m_cgImageRef
;
559 CGImageRetain( image
) ;
562 if ( m_rawAccessCount
== 0 && m_cgImageRef
== NULL
)
564 // we keep it for later use
565 m_cgImageRef
= image
;
566 CGImageRetain( image
) ;
573 GWorldPtr
wxBitmapRefData::GetHBITMAP(GWorldPtr
* mask
) const
575 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") );
581 *mask
= (GWorldPtr
) m_bitmapMask
->GetHBITMAP() ;
583 else if ( m_hasAlpha
)
585 #if !wxMAC_USE_CORE_GRAPHICS
586 if ( m_rawAccessCount
> 0 )
589 // this structure is not kept in synch when using CG, so if something
590 // is really accessing the GrafPorts, we have to sync it
594 *mask
= m_hMaskBitmap
;
601 void wxBitmapRefData::UpdateAlphaMask() const
605 unsigned char *sourcemask
= (unsigned char *) GetRawAccess() ;
606 unsigned char *destalphabase
= (unsigned char *) m_maskMemBuf
.GetData() ;
608 int h
= GetHeight() ;
611 for ( int y
= 0 ; y
< h
; ++y
, destalphabase
+= m_maskBytesPerRow
)
613 unsigned char* destalpha
= destalphabase
;
615 for ( int x
= 0 ; x
< w
; ++x
, sourcemask
+= 4 )
617 // we must have 24 bit depth for non quartz smooth alpha
619 *destalpha
++ = 255 - *sourcemask
;
620 *destalpha
++ = 255 - *sourcemask
;
621 *destalpha
++ = 255 - *sourcemask
;
627 void wxBitmapRefData::Free()
629 wxASSERT_MSG( m_rawAccessCount
== 0 , wxT("Bitmap still selected when destroyed") ) ;
634 CGImageRelease( m_cgImageRef
) ;
635 m_cgImageRef
= NULL
;
641 ReleaseIconRef( m_iconRef
) ;
647 KillPicture( m_pictHandle
) ;
648 m_pictHandle
= NULL
;
653 DisposeGWorld( MAC_WXHBITMAP(m_hBitmap
) ) ;
659 DisposeGWorld( MAC_WXHBITMAP(m_hMaskBitmap
) ) ;
660 m_hMaskBitmap
= NULL
;
670 wxBitmapRefData::~wxBitmapRefData()
675 bool wxBitmap::CopyFromIcon(const wxIcon
& icon
)
677 bool created
= false ;
678 int w
= icon
.GetWidth() ;
679 int h
= icon
.GetHeight() ;
681 Create( icon
.GetWidth() , icon
.GetHeight() ) ;
683 if ( w
== h
&& ( w
== 16 || w
== 32 || w
== 48 || w
== 128 ) )
685 IconFamilyHandle iconFamily
= NULL
;
686 Handle imagehandle
= NewHandle( 0 ) ;
687 Handle maskhandle
= NewHandle( 0 ) ;
691 IconSelectorValue selector
= 0 ;
696 dataType
= kThumbnail32BitData
;
697 maskType
= kThumbnail8BitMask
;
698 selector
= kSelectorAllAvailableData
;
702 dataType
= kHuge32BitData
;
703 maskType
= kHuge8BitMask
;
704 selector
= kSelectorHuge32Bit
| kSelectorHuge8BitMask
;
708 dataType
= kLarge32BitData
;
709 maskType
= kLarge8BitMask
;
710 selector
= kSelectorLarge32Bit
| kSelectorLarge8BitMask
;
714 dataType
= kSmall32BitData
;
715 maskType
= kSmall8BitMask
;
716 selector
= kSelectorSmall32Bit
| kSelectorSmall8BitMask
;
723 OSStatus err
= IconRefToIconFamily( MAC_WXHICON(icon
.GetHICON()) , selector
, &iconFamily
) ;
725 err
= GetIconFamilyData( iconFamily
, dataType
, imagehandle
) ;
726 err
= GetIconFamilyData( iconFamily
, maskType
, maskhandle
) ;
727 size_t imagehandlesize
= GetHandleSize( imagehandle
) ;
728 size_t maskhandlesize
= GetHandleSize( maskhandle
) ;
730 if ( imagehandlesize
!= 0 && maskhandlesize
!= 0 )
732 wxASSERT( GetHandleSize( imagehandle
) == w
* 4 * h
) ;
733 wxASSERT( GetHandleSize( maskhandle
) == w
* h
) ;
737 unsigned char *source
= (unsigned char *) *imagehandle
;
738 unsigned char *sourcemask
= (unsigned char *) *maskhandle
;
739 unsigned char* destination
= (unsigned char*) BeginRawAccess() ;
741 for ( int y
= 0 ; y
< h
; ++y
)
743 for ( int x
= 0 ; x
< w
; ++x
)
745 *destination
++ = *sourcemask
++ ;
747 *destination
++ = *source
++ ;
748 *destination
++ = *source
++ ;
749 *destination
++ = *source
++ ;
754 DisposeHandle( imagehandle
) ;
755 DisposeHandle( maskhandle
) ;
759 DisposeHandle( (Handle
) iconFamily
) ;
765 dc
.SelectObject( *this ) ;
766 dc
.DrawIcon( icon
, 0 , 0 ) ;
767 dc
.SelectObject( wxNullBitmap
) ;
777 wxBitmap::~wxBitmap()
781 wxBitmap::wxBitmap(const char bits
[], int the_width
, int the_height
, int no_bits
)
783 m_refData
= new wxBitmapRefData( the_width
, the_height
, no_bits
) ;
787 int linesize
= ( the_width
/ (sizeof(unsigned char) * 8)) ;
788 if ( the_width
% (sizeof(unsigned char) * 8) )
789 linesize
+= sizeof(unsigned char);
791 unsigned char* linestart
= (unsigned char*) bits
;
792 unsigned char* destination
= (unsigned char*) BeginRawAccess() ;
794 for ( int y
= 0 ; y
< the_height
; ++y
, linestart
+= linesize
)
796 int index
, bit
, mask
;
798 for ( int x
= 0 ; x
< the_width
; ++x
)
804 if ( linestart
[index
] & mask
)
806 *destination
++ = 0xFF ;
813 *destination
++ = 0xFF ;
814 *destination
++ = 0xFF ;
815 *destination
++ = 0xFF ;
816 *destination
++ = 0xFF ;
825 wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
829 wxBitmap::wxBitmap(int w
, int h
, int d
)
831 (void)Create(w
, h
, d
);
834 wxBitmap::wxBitmap(void *data
, wxBitmapType type
, int width
, int height
, int depth
)
836 (void) Create(data
, type
, width
, height
, depth
);
839 wxBitmap::wxBitmap(const wxString
& filename
, wxBitmapType type
)
841 LoadFile(filename
, type
);
844 wxBitmap::wxBitmap(const char **bits
)
846 (void) CreateFromXpm(bits
);
849 wxBitmap::wxBitmap(char **bits
)
851 (void) CreateFromXpm((const char **)bits
);
854 void * wxBitmap::GetRawAccess() const
856 wxCHECK_MSG( Ok() , NULL
, wxT("invalid bitmap") ) ;
858 return M_BITMAPDATA
->GetRawAccess() ;
861 void * wxBitmap::BeginRawAccess()
863 wxCHECK_MSG( Ok() , NULL
, wxT("invalid bitmap") ) ;
865 return M_BITMAPDATA
->BeginRawAccess() ;
868 void wxBitmap::EndRawAccess()
870 wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
872 M_BITMAPDATA
->EndRawAccess() ;
875 bool wxBitmap::CreateFromXpm(const char **bits
)
878 wxCHECK_MSG( bits
!= NULL
, false, wxT("invalid bitmap data") )
880 wxXPMDecoder decoder
;
881 wxImage img
= decoder
.ReadData(bits
);
882 wxCHECK_MSG( img
.Ok(), false, wxT("invalid bitmap data") )
884 *this = wxBitmap(img
);
894 WXCGIMAGEREF
wxBitmap::CGImageCreate() const
896 wxCHECK_MSG( Ok(), NULL
, wxT("invalid bitmap") ) ;
898 return M_BITMAPDATA
->CGImageCreate() ;
902 wxBitmap
wxBitmap::GetSubBitmap(const wxRect
&rect
) const
905 (rect
.x
>= 0) && (rect
.y
>= 0) &&
906 (rect
.x
+rect
.width
<= GetWidth()) &&
907 (rect
.y
+rect
.height
<= GetHeight()),
908 wxNullBitmap
, wxT("invalid bitmap or bitmap region") );
910 wxBitmap
ret( rect
.width
, rect
.height
, GetDepth() );
911 wxASSERT_MSG( ret
.Ok(), wxT("GetSubBitmap error") );
913 int sourcewidth
= GetWidth() ;
914 int destwidth
= rect
.width
;
915 int destheight
= rect
.height
;
918 unsigned char *sourcedata
= (unsigned char*) GetRawAccess() ;
919 unsigned char *destdata
= (unsigned char*) ret
.BeginRawAccess() ;
920 wxASSERT( (sourcedata
!= NULL
) && (destdata
!= NULL
) ) ;
922 int sourcelinesize
= sourcewidth
* 4 ;
923 int destlinesize
= destwidth
* 4 ;
924 unsigned char *source
= sourcedata
+ rect
.x
* 4 + rect
.y
* sourcelinesize
;
925 unsigned char *dest
= destdata
;
927 for (int yy
= 0; yy
< destheight
; ++yy
, source
+= sourcelinesize
, dest
+= destlinesize
)
929 memcpy( dest
, source
, destlinesize
) ;
935 if ( M_BITMAPDATA
->m_bitmapMask
)
937 wxMemoryBuffer maskbuf
;
938 int rowBytes
= ( destwidth
+ 3 ) & 0xFFFFFFC ;
939 size_t maskbufsize
= rowBytes
* destheight
;
941 int sourcelinesize
= M_BITMAPDATA
->m_bitmapMask
->GetBytesPerRow() ;
942 int destlinesize
= rowBytes
;
944 unsigned char *source
= (unsigned char *) M_BITMAPDATA
->m_bitmapMask
->GetRawAccess() ;
945 unsigned char *destdata
= (unsigned char * ) maskbuf
.GetWriteBuf( maskbufsize
) ;
946 wxASSERT( (source
!= NULL
) && (destdata
!= NULL
) ) ;
948 source
+= rect
.x
+ rect
.y
* sourcelinesize
;
949 unsigned char *dest
= destdata
;
951 for (int yy
= 0; yy
< destheight
; ++yy
, source
+= sourcelinesize
, dest
+= destlinesize
)
953 for (int xx
= 0; xx
< destlinesize
; xx
++ )
954 *(dest
+xx
) = 0xFF - *(source
+xx
*3) ;
957 maskbuf
.UngetWriteBuf( maskbufsize
) ;
958 ret
.SetMask( new wxMask( maskbuf
, destwidth
, destheight
, rowBytes
) ) ;
960 else if ( HasAlpha() )
966 bool wxBitmap::Create(int w
, int h
, int d
)
971 d
= wxDisplayDepth() ;
973 m_refData
= new wxBitmapRefData( w
, h
, d
);
975 return M_BITMAPDATA
->Ok() ;
978 bool wxBitmap::LoadFile(const wxString
& filename
, wxBitmapType type
)
982 wxBitmapHandler
*handler
= FindHandler(type
);
986 m_refData
= new wxBitmapRefData
;
988 return handler
->LoadFile(this, filename
, type
, -1, -1);
993 wxImage
loadimage(filename
, type
);
1003 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
1008 bool wxBitmap::Create(void *data
, wxBitmapType type
, int width
, int height
, int depth
)
1012 m_refData
= new wxBitmapRefData
;
1014 wxBitmapHandler
*handler
= FindHandler(type
);
1016 if ( handler
== NULL
)
1018 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
1023 return handler
->Create(this, data
, type
, width
, height
, depth
);
1028 wxBitmap::wxBitmap(const wxImage
& image
, int depth
)
1030 wxCHECK_RET( image
.Ok(), wxT("invalid image") )
1032 // width and height of the device-dependent bitmap
1033 int width
= image
.GetWidth();
1034 int height
= image
.GetHeight();
1036 m_refData
= new wxBitmapRefData( width
, height
, depth
) ;
1040 bool hasAlpha
= false ;
1042 if ( image
.HasMask() )
1044 // takes precedence, don't mix with alpha info
1048 hasAlpha
= image
.HasAlpha() ;
1054 unsigned char* destination
= (unsigned char*) BeginRawAccess() ;
1055 register unsigned char* data
= image
.GetData();
1056 const unsigned char *alpha
= hasAlpha
? image
.GetAlpha() : NULL
;
1058 for (int y
= 0; y
< height
; y
++)
1060 for (int x
= 0; x
< width
; x
++)
1064 const unsigned char a
= *alpha
++;
1065 *destination
++ = a
;
1067 #if wxMAC_USE_PREMULTIPLIED_ALPHA
1068 *destination
++ = ((*data
++) * a
+ 127) / 255 ;
1069 *destination
++ = ((*data
++) * a
+ 127) / 255 ;
1070 *destination
++ = ((*data
++) * a
+ 127) / 255 ;
1072 *destination
++ = *data
++ ;
1073 *destination
++ = *data
++ ;
1074 *destination
++ = *data
++ ;
1079 *destination
++ = 0xFF ;
1080 *destination
++ = *data
++ ;
1081 *destination
++ = *data
++ ;
1082 *destination
++ = *data
++ ;
1088 if ( image
.HasMask() )
1089 SetMask( new wxMask( *this , wxColour( image
.GetMaskRed() , image
.GetMaskGreen() , image
.GetMaskBlue() ) ) ) ;
1092 wxImage
wxBitmap::ConvertToImage() const
1096 wxCHECK_MSG( Ok(), wxNullImage
, wxT("invalid bitmap") );
1098 // create an wxImage object
1099 int width
= GetWidth();
1100 int height
= GetHeight();
1101 image
.Create( width
, height
);
1103 unsigned char *data
= image
.GetData();
1104 wxCHECK_MSG( data
, wxNullImage
, wxT("Could not allocate data for image") );
1106 unsigned char* source
= (unsigned char*) GetRawAccess() ;
1108 bool hasAlpha
= false ;
1109 bool hasMask
= false ;
1110 int maskBytesPerRow
= 0 ;
1111 unsigned char *alpha
= NULL
;
1112 unsigned char *mask
= NULL
;
1120 mask
= (unsigned char*) GetMask()->GetRawAccess() ;
1121 maskBytesPerRow
= GetMask()->GetBytesPerRow() ;
1127 alpha
= image
.GetAlpha() ;
1132 // The following masking algorithm is the same as well in msw/gtk:
1133 // the colour used as transparent one in wxImage and the one it is
1134 // replaced with when it actually occurs in the bitmap
1135 static const int MASK_RED
= 1;
1136 static const int MASK_GREEN
= 2;
1137 static const int MASK_BLUE
= 3;
1138 static const int MASK_BLUE_REPLACEMENT
= 2;
1140 for (int yy
= 0; yy
< height
; yy
++ , mask
+= maskBytesPerRow
)
1142 unsigned char * maskp
= mask
;
1143 unsigned char a
, r
, g
, b
;
1146 for (int xx
= 0; xx
< width
; xx
++)
1148 color
= *((long*) source
) ;
1149 a
= ((color
&0xFF000000) >> 24) ;
1150 r
= ((color
&0x00FF0000) >> 16) ;
1151 g
= ((color
&0x0000FF00) >> 8) ;
1152 b
= (color
&0x000000FF);
1156 if ( *maskp
++ == 0xFF )
1162 else if ( r
== MASK_RED
&& g
== MASK_GREEN
&& b
== MASK_BLUE
)
1163 b
= MASK_BLUE_REPLACEMENT
;
1168 else if ( hasAlpha
)
1172 data
[index
+ 1] = g
;
1173 data
[index
+ 2] = b
;
1181 image
.SetMaskColour( MASK_RED
, MASK_GREEN
, MASK_BLUE
);
1186 #endif //wxUSE_IMAGE
1188 bool wxBitmap::SaveFile( const wxString
& filename
,
1189 wxBitmapType type
, const wxPalette
*palette
) const
1191 bool success
= false;
1192 wxBitmapHandler
*handler
= FindHandler(type
);
1196 success
= handler
->SaveFile(this, filename
, type
, palette
);
1201 wxImage image
= ConvertToImage();
1202 success
= image
.SaveFile(filename
, type
);
1204 wxLogWarning(wxT("no bitmap handler for type %d defined."), type
);
1211 bool wxBitmap::Ok() const
1213 return (M_BITMAPDATA
&& M_BITMAPDATA
->Ok());
1216 int wxBitmap::GetHeight() const
1218 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1220 return M_BITMAPDATA
->GetHeight();
1223 int wxBitmap::GetWidth() const
1225 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1227 return M_BITMAPDATA
->GetWidth() ;
1230 int wxBitmap::GetDepth() const
1232 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1234 return M_BITMAPDATA
->GetDepth();
1237 #if WXWIN_COMPATIBILITY_2_4
1238 int wxBitmap::GetQuality() const
1243 void wxBitmap::SetQuality(int WXUNUSED(quality
))
1248 wxMask
*wxBitmap::GetMask() const
1250 wxCHECK_MSG( Ok(), (wxMask
*) NULL
, wxT("invalid bitmap") );
1252 return M_BITMAPDATA
->m_bitmapMask
;
1255 bool wxBitmap::HasAlpha() const
1257 wxCHECK_MSG( Ok(), false , wxT("invalid bitmap") );
1259 return M_BITMAPDATA
->HasAlpha() ;
1262 void wxBitmap::SetWidth(int w
)
1265 m_refData
= new wxBitmapRefData
;
1267 M_BITMAPDATA
->SetWidth(w
);
1270 void wxBitmap::SetHeight(int h
)
1273 m_refData
= new wxBitmapRefData
;
1275 M_BITMAPDATA
->SetHeight(h
);
1278 void wxBitmap::SetDepth(int d
)
1281 m_refData
= new wxBitmapRefData
;
1283 M_BITMAPDATA
->SetDepth(d
);
1286 void wxBitmap::SetOk(bool isOk
)
1289 m_refData
= new wxBitmapRefData
;
1291 M_BITMAPDATA
->SetOk(isOk
);
1295 wxPalette
*wxBitmap::GetPalette() const
1297 wxCHECK_MSG( Ok(), NULL
, wxT("Invalid bitmap GetPalette()") );
1299 return &M_BITMAPDATA
->m_bitmapPalette
;
1302 void wxBitmap::SetPalette(const wxPalette
& palette
)
1305 m_refData
= new wxBitmapRefData
;
1307 M_BITMAPDATA
->m_bitmapPalette
= palette
;
1309 #endif // wxUSE_PALETTE
1311 void wxBitmap::SetMask(wxMask
*mask
)
1314 m_refData
= new wxBitmapRefData
;
1316 // Remove existing mask if there is one.
1317 delete M_BITMAPDATA
->m_bitmapMask
;
1319 M_BITMAPDATA
->m_bitmapMask
= mask
;
1322 WXHBITMAP
wxBitmap::GetHBITMAP(WXHBITMAP
* mask
) const
1324 return WXHBITMAP(M_BITMAPDATA
->GetHBITMAP((GWorldPtr
*)mask
));
1327 // ----------------------------------------------------------------------------
1329 // ----------------------------------------------------------------------------
1336 // Construct a mask from a bitmap and a colour indicating
1337 // the transparent area
1338 wxMask::wxMask( const wxBitmap
& bitmap
, const wxColour
& colour
)
1341 Create( bitmap
, colour
);
1344 // Construct a mask from a mono bitmap (copies the bitmap).
1345 wxMask::wxMask( const wxBitmap
& bitmap
)
1351 // Construct a mask from a mono bitmap (copies the bitmap).
1352 wxMask::wxMask( const wxMemoryBuffer
& data
, int width
, int height
, int bytesPerRow
)
1355 Create( data
, width
, height
, bytesPerRow
);
1362 DisposeGWorld( (GWorldPtr
)m_maskBitmap
) ;
1363 m_maskBitmap
= NULL
;
1369 m_width
= m_height
= m_bytesPerRow
= 0 ;
1370 m_maskBitmap
= NULL
;
1373 void *wxMask::GetRawAccess() const
1375 return m_memBuf
.GetData() ;
1378 // The default ColorTable for k8IndexedGrayPixelFormat in Intel appears to be broken, so we'll use an non-indexed
1379 // bitmap mask instead; in order to keep the code simple, the change applies to PowerPC implementations as well
1381 void wxMask::RealizeNative()
1385 DisposeGWorld( (GWorldPtr
)m_maskBitmap
) ;
1386 m_maskBitmap
= NULL
;
1389 Rect rect
= { 0 , 0 , m_height
, m_width
} ;
1391 OSStatus err
= NewGWorldFromPtr(
1392 (GWorldPtr
*) &m_maskBitmap
, k24RGBPixelFormat
, &rect
, NULL
, NULL
, 0 ,
1393 (char*) m_memBuf
.GetData() , m_bytesPerRow
) ;
1394 verify_noerr( err
) ;
1397 // Create a mask from a mono bitmap (copies the bitmap).
1398 bool wxMask::Create(const wxMemoryBuffer
& data
,int width
, int height
, int bytesPerRow
)
1403 m_bytesPerRow
= bytesPerRow
;
1405 wxASSERT( data
.GetDataLen() == (size_t)(height
* bytesPerRow
) ) ;
1412 // Create a mask from a mono bitmap (copies the bitmap).
1413 bool wxMask::Create(const wxBitmap
& bitmap
)
1415 m_width
= bitmap
.GetWidth() ;
1416 m_height
= bitmap
.GetHeight() ;
1417 m_bytesPerRow
= ( m_width
* 3 + 3 ) & 0xFFFFFFC ;
1419 size_t size
= m_bytesPerRow
* m_height
;
1420 unsigned char * destdatabase
= (unsigned char*) m_memBuf
.GetWriteBuf( size
) ;
1421 wxASSERT( destdatabase
!= NULL
) ;
1423 memset( destdatabase
, 0 , size
) ;
1424 unsigned char * srcdata
= (unsigned char*) bitmap
.GetRawAccess() ;
1426 for ( int y
= 0 ; y
< m_height
; ++y
, destdatabase
+= m_bytesPerRow
)
1428 unsigned char *destdata
= destdatabase
;
1429 unsigned char r
, g
, b
;
1431 for ( int x
= 0 ; x
< m_width
; ++x
)
1438 if ( ( r
+ g
+ b
) > 0x10 )
1440 *destdata
++ = 0xFF ;
1441 *destdata
++ = 0xFF ;
1442 *destdata
++ = 0xFF ;
1446 *destdata
++ = 0x00 ;
1447 *destdata
++ = 0x00 ;
1448 *destdata
++ = 0x00 ;
1453 m_memBuf
.UngetWriteBuf( size
) ;
1459 // Create a mask from a bitmap and a colour indicating
1460 // the transparent area
1461 bool wxMask::Create(const wxBitmap
& bitmap
, const wxColour
& colour
)
1463 m_width
= bitmap
.GetWidth() ;
1464 m_height
= bitmap
.GetHeight() ;
1465 m_bytesPerRow
= ( m_width
* 3 + 3 ) & 0xFFFFFFC ;
1467 size_t size
= m_bytesPerRow
* m_height
;
1468 unsigned char * destdatabase
= (unsigned char*) m_memBuf
.GetWriteBuf( size
) ;
1469 wxASSERT( destdatabase
!= NULL
) ;
1471 memset( destdatabase
, 0 , size
) ;
1472 unsigned char * srcdata
= (unsigned char*) bitmap
.GetRawAccess() ;
1474 for ( int y
= 0 ; y
< m_height
; ++y
, destdatabase
+= m_bytesPerRow
)
1476 unsigned char *destdata
= destdatabase
;
1477 unsigned char r
, g
, b
;
1479 for ( int x
= 0 ; x
< m_width
; ++x
)
1486 if ( colour
== wxColour( r
, g
, b
) )
1488 *destdata
++ = 0xFF ;
1489 *destdata
++ = 0xFF ;
1490 *destdata
++ = 0xFF ;
1494 *destdata
++ = 0x00 ;
1495 *destdata
++ = 0x00 ;
1496 *destdata
++ = 0x00 ;
1501 m_memBuf
.UngetWriteBuf( size
) ;
1507 WXHBITMAP
wxMask::GetHBITMAP() const
1509 return m_maskBitmap
;
1512 // ----------------------------------------------------------------------------
1514 // ----------------------------------------------------------------------------
1516 wxBitmapHandler::~wxBitmapHandler()
1520 bool wxBitmapHandler::Create(wxBitmap
*bitmap
, void *data
, long type
, int width
, int height
, int depth
)
1525 bool wxBitmapHandler::LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1526 int desiredWidth
, int desiredHeight
)
1531 bool wxBitmapHandler::SaveFile(const wxBitmap
*bitmap
, const wxString
& name
, int type
, const wxPalette
*palette
)
1536 // ----------------------------------------------------------------------------
1537 // Standard Handlers
1538 // ----------------------------------------------------------------------------
1540 class WXDLLEXPORT wxPICTResourceHandler
: public wxBitmapHandler
1542 DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler
)
1545 inline wxPICTResourceHandler()
1547 SetName(wxT("Macintosh Pict resource"));
1548 SetExtension(wxEmptyString
);
1549 SetType(wxBITMAP_TYPE_PICT_RESOURCE
);
1552 virtual bool LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1553 int desiredWidth
, int desiredHeight
);
1556 IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler
, wxBitmapHandler
)
1559 bool wxPICTResourceHandler::LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1560 int desiredWidth
, int desiredHeight
)
1564 wxMacStringToPascal( name
, theName
) ;
1566 PicHandle thePict
= (PicHandle
) GetNamedResource( 'PICT' , theName
) ;
1571 mf
.SetHMETAFILE( (WXHMETAFILE
) thePict
) ;
1572 bitmap
->Create( mf
.GetWidth() , mf
.GetHeight() ) ;
1574 dc
.SelectObject( *bitmap
) ;
1576 dc
.SelectObject( wxNullBitmap
) ;
1585 void wxBitmap::InitStandardHandlers()
1587 AddHandler( new wxPICTResourceHandler
) ;
1588 AddHandler( new wxICONResourceHandler
) ;
1591 // ----------------------------------------------------------------------------
1592 // raw bitmap access support
1593 // ----------------------------------------------------------------------------
1595 void *wxBitmap::GetRawData(wxPixelDataBase
& data
, int bpp
)
1598 // no bitmap, no data (raw or otherwise)
1601 data
.m_width
= GetWidth() ;
1602 data
.m_height
= GetHeight() ;
1603 data
.m_stride
= GetWidth() * 4 ;
1605 return GetRawAccess() ;
1608 void wxBitmap::UngetRawData(wxPixelDataBase
& dataBase
)
1613 // TODO: if we have some information about the API we should check
1614 // this code looks strange...
1616 if ( !M_BITMAPDATA
->HasAlpha() )
1619 wxAlphaPixelData
& data
= (wxAlphaPixelData
&)dataBase
;
1620 int w
= data
.GetWidth();
1621 int h
= data
.GetHeight();
1623 wxBitmap
bmpMask( GetWidth(), GetHeight(), 32 );
1624 wxAlphaPixelData
dataMask( bmpMask
, data
.GetOrigin(), wxSize( w
, h
) );
1625 wxAlphaPixelData::Iterator
pMask( dataMask
), p( data
);
1627 for ( int y
= 0; y
< h
; y
++ )
1629 wxAlphaPixelData::Iterator rowStartMask
= pMask
;
1630 wxAlphaPixelData::Iterator rowStart
= p
;
1632 for ( int x
= 0; x
< w
; x
++ )
1634 const wxAlphaPixelData::Iterator::ChannelType alpha
= p
.Alpha();
1636 pMask
.Red() = alpha
;
1637 pMask
.Green() = alpha
;
1638 pMask
.Blue() = alpha
;
1645 p
.OffsetY( data
, 1 );
1647 pMask
= rowStartMask
;
1648 pMask
.OffsetY( dataMask
, 1 );
1651 SetMask( new wxMask( bmpMask
) );
1654 void wxBitmap::UseAlpha()
1656 // remember that we are using alpha channel:
1657 // we'll need to create a proper mask in UngetRawData()
1658 M_BITMAPDATA
->UseAlpha( true );