]> git.saurik.com Git - wxWidgets.git/blame - src/mac/carbon/bitmap.cpp
unload msimg32.dll earlier (before static cleanup time) to avoid lockups when wx...
[wxWidgets.git] / src / mac / carbon / bitmap.cpp
CommitLineData
e9576ca5 1/////////////////////////////////////////////////////////////////////////////
e4db172a 2// Name: src/mac/carbon/bitmap.cpp
e9576ca5 3// Purpose: wxBitmap
a31a5f85 4// Author: Stefan Csomor
e9576ca5 5// Modified by:
a31a5f85 6// Created: 1998-01-01
e9576ca5 7// RCS-ID: $Id$
a31a5f85 8// Copyright: (c) Stefan Csomor
65571936 9// Licence: wxWindows licence
e9576ca5
SC
10/////////////////////////////////////////////////////////////////////////////
11
a8e9860d 12#include "wx/wxprec.h"
b698c8e9 13
e9576ca5 14#include "wx/bitmap.h"
e4db172a
WS
15
16#ifndef WX_PRECOMP
17 #include "wx/log.h"
f38924e8 18 #include "wx/dcmemory.h"
923d28da 19 #include "wx/icon.h"
155ecd4c 20 #include "wx/image.h"
e4db172a
WS
21#endif
22
20b69855 23#include "wx/metafile.h"
973b0afb 24#include "wx/xpmdecod.h"
e9576ca5 25
55e18dbe
VZ
26#include "wx/rawbmp.h"
27
e9576ca5
SC
28IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
29IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
e9576ca5 30
9d463591
SC
31#include <ApplicationServices/ApplicationServices.h>
32#include <QuickTime/QuickTime.h>
519cb848 33
31d30995 34#include "wx/mac/uma.h"
05d8deda 35
20b69855 36// Implementation Notes
902725ee 37// --------------------
20b69855 38//
902725ee
WS
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,
20b69855
SC
41// therefore we have a separate GWorld there for blitting the mask in
42
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
45
968c951f
SC
46class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
47{
48 friend class WXDLLIMPEXP_FWD_CORE wxIcon;
49 friend class WXDLLIMPEXP_FWD_CORE wxCursor;
50public:
51 wxBitmapRefData(int width , int height , int depth);
52 wxBitmapRefData();
53 wxBitmapRefData(const wxBitmapRefData &tocopy);
54
55 virtual ~wxBitmapRefData();
56
57 void Free();
58 bool Ok() const { return IsOk(); }
59 bool IsOk() const { return m_ok; }
60 void SetOk( bool isOk) { m_ok = isOk; }
61
62 void SetWidth( int width ) { m_width = width; }
63 void SetHeight( int height ) { m_height = height; }
64 void SetDepth( int depth ) { m_depth = depth; }
65
66 int GetWidth() const { return m_width; }
67 int GetHeight() const { return m_height; }
68 int GetDepth() const { return m_depth; }
69
70 void *GetRawAccess() const;
71 void *BeginRawAccess();
72 void EndRawAccess();
73
74 bool HasAlpha() const { return m_hasAlpha; }
75 void UseAlpha( bool useAlpha );
76
77public:
78#if wxUSE_PALETTE
79 wxPalette m_bitmapPalette;
80#endif // wxUSE_PALETTE
81
82 wxMask * m_bitmapMask; // Optional mask
83 CGImageRef CreateCGImage() const;
84
85 // returns true if the bitmap has a size that
86 // can be natively transferred into a true icon
87 // if no is returned GetIconRef will still produce
88 // an icon but it will be generated via a PICT and
89 // rescaled to 16 x 16
90 bool HasNativeSize();
91
92 // caller should increase ref count if needed longer
93 // than the bitmap exists
94 IconRef GetIconRef();
95
96 // returns a Pict from the bitmap content
97 PicHandle GetPictHandle();
98
99 CGContextRef GetBitmapContext() const;
100
101 int GetBytesPerRow() const { return m_bytesPerRow; }
102 private :
103 bool Create(int width , int height , int depth);
104 void Init();
105
106 int m_width;
107 int m_height;
108 int m_bytesPerRow;
109 int m_depth;
110 bool m_hasAlpha;
111 wxMemoryBuffer m_memBuf;
112 int m_rawAccessCount;
113 bool m_ok;
114 mutable CGImageRef m_cgImageRef;
115
116 IconRef m_iconRef;
117 PicHandle m_pictHandle;
118
119 CGContextRef m_hBitmap;
120};
121
122
e1673e52
SC
123#define wxMAC_USE_PREMULTIPLIED_ALPHA 1
124static const int kBestByteAlignement = 16;
125static const int kMaskBytesPerPixel = 1;
6239ee05
SC
126
127static int GetBestBytesPerRow( int rawBytes )
128{
129 return (((rawBytes)+kBestByteAlignement-1) & ~(kBestByteAlignement-1) );
130}
20b69855 131
968c951f
SC
132#if wxUSE_GUI
133
134// this is used for more controls than just the wxBitmap button, also for notebooks etc
d45318b8 135
20b69855 136void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bitmap , int forceType )
519cb848 137{
20b69855
SC
138 memset( info , 0 , sizeof(ControlButtonContentInfo) ) ;
139 if ( bitmap.Ok() )
140 {
45cf8535 141 wxBitmapRefData * bmap = bitmap.GetBitmapData() ;
20b69855
SC
142 if ( bmap == NULL )
143 return ;
902725ee 144
6239ee05
SC
145 if ( forceType == 0 )
146 {
e1673e52 147 forceType = kControlContentCGImageRef;
6239ee05
SC
148 }
149
150 if ( forceType == kControlContentIconRef )
b28aeea5 151 {
45cf8535 152 wxBitmap scaleBmp ;
45cf8535 153 wxBitmapRefData* bmp = bmap ;
902725ee 154
45cf8535
SC
155 if ( !bmap->HasNativeSize() )
156 {
157 // as PICT conversion will only result in a 16x16 icon, let's attempt
902725ee
WS
158 // a few scales for better results
159
45cf8535
SC
160 int w = bitmap.GetWidth() ;
161 int h = bitmap.GetHeight() ;
162 int sz = wxMax( w , h ) ;
1cb97a54 163 if ( sz == 24 || sz == 64 )
45cf8535
SC
164 {
165 scaleBmp = wxBitmap( bitmap.ConvertToImage().Scale( w * 2 , h * 2 ) ) ;
166 bmp = scaleBmp.GetBitmapData() ;
167 }
168 }
902725ee 169
b28aeea5 170 info->contentType = kControlContentIconRef ;
45cf8535
SC
171 info->u.iconRef = bmp->GetIconRef() ;
172 AcquireIconRef( info->u.iconRef ) ;
b28aeea5 173 }
45cf8535
SC
174 else if ( forceType == kControlContentCGImageRef )
175 {
176 info->contentType = kControlContentCGImageRef ;
968c951f 177 info->u.imageRef = (CGImageRef) bmap->CreateCGImage() ;
45cf8535 178 }
b28aeea5
SC
179 else
180 {
4f74e0d1 181#ifndef __LP64__
b28aeea5
SC
182 info->contentType = kControlContentPictHandle ;
183 info->u.picture = bmap->GetPictHandle() ;
4f74e0d1 184#endif
b28aeea5 185 }
20b69855 186 }
519cb848
SC
187}
188
6239ee05
SC
189CGImageRef wxMacCreateCGImageFromBitmap( const wxBitmap& bitmap )
190{
191 wxBitmapRefData * bmap = bitmap.GetBitmapData() ;
192 if ( bmap == NULL )
193 return NULL ;
968c951f 194 return (CGImageRef) bmap->CreateCGImage();
6239ee05
SC
195}
196
20b69855 197void wxMacReleaseBitmapButton( ControlButtonContentInfo*info )
519cb848 198{
20b69855 199 if ( info->contentType == kControlContentIconRef )
4e9ed364 200 {
45cf8535 201 ReleaseIconRef( info->u.iconRef ) ;
b28aeea5 202 }
531436ec
SC
203 else if ( info->contentType == kControlNoContent )
204 {
205 // there's no bitmap at all, fall through silently
206 }
b28aeea5
SC
207 else if ( info->contentType == kControlContentPictHandle )
208 {
45cf8535 209 // owned by the bitmap, no release here
4e9ed364 210 }
20b69855
SC
211 else if ( info->contentType == kControlContentCGImageRef )
212 {
213 CGImageRelease( info->u.imageRef ) ;
214 }
20b69855 215 else
4e9ed364 216 {
20b69855 217 wxFAIL_MSG(wxT("Unexpected bitmap type") ) ;
4e9ed364 218 }
03e11df5 219}
519cb848 220
d45318b8
RN
221#endif //wxUSE_BMPBUTTON
222
9cc62fc8 223#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
20b69855
SC
224
225void wxBitmapRefData::Init()
519cb848 226{
20b69855
SC
227 m_width = 0 ;
228 m_height = 0 ;
229 m_depth = 0 ;
6239ee05 230 m_bytesPerRow = 0;
20b69855
SC
231 m_ok = false ;
232 m_bitmapMask = NULL ;
20b69855 233 m_cgImageRef = NULL ;
1cb97a54 234
b28aeea5
SC
235 m_iconRef = NULL ;
236 m_pictHandle = NULL ;
20b69855 237 m_hBitmap = NULL ;
71cc158e 238
20b69855
SC
239 m_rawAccessCount = 0 ;
240 m_hasAlpha = false;
519cb848
SC
241}
242
2bf8f4c0
RD
243wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
244{
245 Init();
246 Create(tocopy.m_width, tocopy.m_height, tocopy.m_depth);
247
248 if (tocopy.m_bitmapMask)
249 m_bitmapMask = new wxMask(*tocopy.m_bitmapMask);
6239ee05
SC
250 else if (tocopy.m_hasAlpha)
251 UseAlpha(true);
2bf8f4c0
RD
252
253 unsigned char* dest = (unsigned char*)GetRawAccess();
254 unsigned char* source = (unsigned char*)tocopy.GetRawAccess();
6239ee05
SC
255 size_t numbytes = m_bytesPerRow * m_height;
256 memcpy( dest, source, numbytes );
2bf8f4c0
RD
257}
258
20b69855 259wxBitmapRefData::wxBitmapRefData()
5fde6fcc 260{
20b69855 261 Init() ;
72055702
SC
262}
263
902725ee 264wxBitmapRefData::wxBitmapRefData( int w , int h , int d )
72055702 265{
20b69855
SC
266 Init() ;
267 Create( w , h , d ) ;
268}
55e18dbe 269
902725ee 270bool wxBitmapRefData::Create( int w , int h , int d )
20b69855 271{
f73cd00f
RD
272 m_width = wxMax(1, w);
273 m_height = wxMax(1, h);
20b69855 274 m_depth = d ;
72055702 275
6239ee05 276 m_bytesPerRow = GetBestBytesPerRow( w * 4 ) ;
20b69855 277 size_t size = m_bytesPerRow * h ;
1cb97a54
DS
278 void* data = m_memBuf.GetWriteBuf( size ) ;
279 memset( data , 0 , size ) ;
280 m_memBuf.UngetWriteBuf( size ) ;
71cc158e 281
20b69855 282 m_hBitmap = NULL ;
6239ee05
SC
283 m_hBitmap = CGBitmapContextCreate((char*) data, m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), kCGImageAlphaNoneSkipFirst );
284 wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
285 CGContextTranslateCTM( m_hBitmap, 0, m_height );
286 CGContextScaleCTM( m_hBitmap, 1, -1 );
e1673e52 287
20b69855 288 m_ok = ( m_hBitmap != NULL ) ;
71cc158e 289
902725ee 290 return m_ok ;
20b69855 291}
72055702 292
20b69855
SC
293void wxBitmapRefData::UseAlpha( bool use )
294{
295 if ( m_hasAlpha == use )
296 return ;
902725ee 297
20b69855 298 m_hasAlpha = use ;
e1673e52 299
6239ee05
SC
300 CGContextRelease( m_hBitmap );
301 m_hBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), m_hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst );
302 wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
303 CGContextTranslateCTM( m_hBitmap, 0, m_height );
304 CGContextScaleCTM( m_hBitmap, 1, -1 );
72055702
SC
305}
306
20b69855 307void *wxBitmapRefData::GetRawAccess() const
72055702 308{
20b69855
SC
309 wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
310 return m_memBuf.GetData() ;
311}
72055702 312
902725ee 313void *wxBitmapRefData::BeginRawAccess()
20b69855
SC
314{
315 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ) ;
316 wxASSERT( m_rawAccessCount == 0 ) ;
902725ee 317 wxASSERT_MSG( m_pictHandle == NULL && m_iconRef == NULL ,
b28aeea5 318 wxT("Currently, modifing bitmaps that are used in controls already is not supported") ) ;
1cb97a54
DS
319
320 ++m_rawAccessCount ;
321
1cb97a54
DS
322 // we must destroy an existing cached image, as
323 // the bitmap data may change now
20b69855
SC
324 if ( m_cgImageRef )
325 {
326 CGImageRelease( m_cgImageRef ) ;
327 m_cgImageRef = NULL ;
328 }
1cb97a54 329
20b69855
SC
330 return m_memBuf.GetData() ;
331}
55e18dbe 332
20b69855
SC
333void wxBitmapRefData::EndRawAccess()
334{
335 wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
336 wxASSERT( m_rawAccessCount == 1 ) ;
1cb97a54 337
20b69855 338 --m_rawAccessCount ;
20b69855 339}
55e18dbe 340
b28aeea5
SC
341bool wxBitmapRefData::HasNativeSize()
342{
343 int w = GetWidth() ;
344 int h = GetHeight() ;
345 int sz = wxMax( w , h ) ;
902725ee 346
1cb97a54 347 return ( sz == 128 || sz == 48 || sz == 32 || sz == 16 );
b28aeea5
SC
348}
349
350IconRef wxBitmapRefData::GetIconRef()
351{
352 if ( m_iconRef == NULL )
353 {
354 // Create Icon Family Handle
902725ee 355
e1673e52 356 IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle( 0 );
902725ee 357
b28aeea5
SC
358 int w = GetWidth() ;
359 int h = GetHeight() ;
360 int sz = wxMax( w , h ) ;
902725ee 361
b28aeea5
SC
362 OSType dataType = 0 ;
363 OSType maskType = 0 ;
364
1cb97a54 365 switch (sz)
b28aeea5 366 {
1cb97a54 367 case 128:
e1673e52 368#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
6239ee05
SC
369 if ( UMAGetSystemVersion() >= 0x1050 )
370 {
371 dataType = kIconServices128PixelDataARGB ;
372 }
373 else
374#endif
375 {
376 dataType = kThumbnail32BitData ;
377 maskType = kThumbnail8BitMask ;
378 }
1cb97a54
DS
379 break;
380
381 case 48:
e1673e52 382#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
6239ee05
SC
383 if ( UMAGetSystemVersion() >= 0x1050 )
384 {
385 dataType = kIconServices48PixelDataARGB ;
386 }
387 else
388#endif
389 {
390 dataType = kHuge32BitData ;
391 maskType = kHuge8BitMask ;
392 }
1cb97a54
DS
393 break;
394
395 case 32:
e1673e52 396#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
6239ee05
SC
397 if ( UMAGetSystemVersion() >= 0x1050 )
398 {
399 dataType = kIconServices32PixelDataARGB ;
400 }
401 else
402#endif
403 {
404 dataType = kLarge32BitData ;
405 maskType = kLarge8BitMask ;
406 }
1cb97a54
DS
407 break;
408
409 case 16:
e1673e52 410#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
6239ee05
SC
411 if ( UMAGetSystemVersion() >= 0x1050 )
412 {
413 dataType = kIconServices16PixelDataARGB ;
414 }
415 else
416#endif
417 {
418 dataType = kSmall32BitData ;
419 maskType = kSmall8BitMask ;
420 }
1cb97a54
DS
421 break;
422
423 default:
424 break;
b28aeea5
SC
425 }
426
427 if ( dataType != 0 )
428 {
e1673e52 429#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
6239ee05 430 if ( maskType == 0 && UMAGetSystemVersion() >= 0x1050 )
b28aeea5 431 {
6239ee05
SC
432 size_t datasize = sz * sz * 4 ;
433 Handle data = NewHandle( datasize ) ;
434 HLock( data ) ;
435 unsigned char* ptr = (unsigned char*) *data ;
436 memset( ptr, 0, datasize );
437 bool hasAlpha = HasAlpha() ;
438 wxMask *mask = m_bitmapMask ;
439 unsigned char * sourcePtr = (unsigned char*) GetRawAccess() ;
440 unsigned char * masksourcePtr = mask ? (unsigned char*) mask->GetRawAccess() : NULL ;
441
442 for ( int y = 0 ; y < h ; ++y, sourcePtr += m_bytesPerRow , masksourcePtr += mask ? mask->GetBytesPerRow() : 0 )
b28aeea5 443 {
6239ee05
SC
444 unsigned char * source = sourcePtr;
445 unsigned char * masksource = masksourcePtr;
446 unsigned char * dest = ptr + y * sz * 4 ;
447 unsigned char a, r, g, b;
902725ee 448
6239ee05
SC
449 for ( int x = 0 ; x < w ; ++x )
450 {
451 a = *source ++ ;
452 r = *source ++ ;
453 g = *source ++ ;
454 b = *source ++ ;
455
456 if ( mask )
457 {
458 a = 0xFF - *masksource++ ;
459 }
460 else if ( !hasAlpha )
461 a = 0xFF ;
462 else
463 {
464#if wxMAC_USE_PREMULTIPLIED_ALPHA
465 // this must be non-premultiplied data
466 if ( a != 0xFF && a!= 0 )
467 {
468 r = r * 255 / a;
469 g = g * 255 / a;
470 b = b * 255 / a;
471 }
472#endif
473 }
474 *dest++ = a ;
475 *dest++ = r ;
476 *dest++ = g ;
477 *dest++ = b ;
902725ee 478
6239ee05
SC
479 }
480 }
481 HUnlock( data );
482 OSStatus err = SetIconFamilyData( iconFamily, dataType , data );
483 wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") );
484 DisposeHandle( data );
485 }
486 else
487#endif
488 {
489 // setup the header properly
490
491 Handle data = NULL ;
492 Handle maskdata = NULL ;
493 unsigned char * maskptr = NULL ;
494 unsigned char * ptr = NULL ;
495 size_t datasize, masksize ;
496
497 datasize = sz * sz * 4 ;
498 data = NewHandle( datasize ) ;
499 HLock( data ) ;
500 ptr = (unsigned char*) *data ;
501 memset( ptr , 0, datasize ) ;
502
503 masksize = sz * sz ;
504 maskdata = NewHandle( masksize ) ;
505 HLock( maskdata ) ;
506 maskptr = (unsigned char*) *maskdata ;
507 memset( maskptr , 0 , masksize ) ;
508
509 bool hasAlpha = HasAlpha() ;
510 wxMask *mask = m_bitmapMask ;
511 unsigned char * sourcePtr = (unsigned char*) GetRawAccess() ;
512 unsigned char * masksourcePtr = mask ? (unsigned char*) mask->GetRawAccess() : NULL ;
513
514 for ( int y = 0 ; y < h ; ++y, sourcePtr += m_bytesPerRow , masksourcePtr += mask ? mask->GetBytesPerRow() : 0 )
515 {
516 unsigned char * source = sourcePtr;
517 unsigned char * masksource = masksourcePtr;
518 unsigned char * dest = ptr + y * sz * 4 ;
519 unsigned char * maskdest = maskptr + y * sz ;
520 unsigned char a, r, g, b;
521
522 for ( int x = 0 ; x < w ; ++x )
93a2b888 523 {
6239ee05
SC
524 a = *source ++ ;
525 r = *source ++ ;
526 g = *source ++ ;
527 b = *source ++ ;
528
529 *dest++ = 0 ;
530 *dest++ = r ;
531 *dest++ = g ;
532 *dest++ = b ;
533
534 if ( mask )
6239ee05 535 *maskdest++ = 0xFF - *masksource++ ;
6239ee05
SC
536 else if ( hasAlpha )
537 *maskdest++ = a ;
538 else
539 *maskdest++ = 0xFF ;
93a2b888 540 }
b28aeea5 541 }
6239ee05
SC
542
543 OSStatus err = SetIconFamilyData( iconFamily, dataType , data ) ;
544 wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
545
546 err = SetIconFamilyData( iconFamily, maskType , maskdata ) ;
547 wxASSERT_MSG( err == noErr , wxT("Error when adding mask") ) ;
548
549 HUnlock( data ) ;
550 HUnlock( maskdata ) ;
551 DisposeHandle( data ) ;
552 DisposeHandle( maskdata ) ;
b28aeea5 553 }
b28aeea5
SC
554 }
555 else
556 {
b28aeea5
SC
557 PicHandle pic = GetPictHandle() ;
558 SetIconFamilyData( iconFamily, 'PICT' , (Handle) pic ) ;
559 }
b28aeea5 560 // transform into IconRef
6239ee05 561
c881da96
SC
562 // cleaner version existing from 10.3 upwards
563 HLock((Handle) iconFamily);
564 OSStatus err = GetIconRefFromIconFamilyPtr( *iconFamily, GetHandleSize((Handle) iconFamily), &m_iconRef );
565 HUnlock((Handle) iconFamily);
566 wxASSERT_MSG( err == noErr , wxT("Error when constructing icon ref") );
c881da96 567 DisposeHandle( (Handle) iconFamily ) ;
b28aeea5 568 }
1cb97a54 569
b28aeea5
SC
570 return m_iconRef ;
571}
572
573PicHandle wxBitmapRefData::GetPictHandle()
574{
575 if ( m_pictHandle == NULL )
576 {
6239ee05
SC
577#ifndef __LP64__
578 GraphicsExportComponent exporter = 0;
579 OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePicture, &exporter);
580 if (noErr == err)
581 {
582 m_pictHandle = (PicHandle) NewHandle(0);
583 if ( m_pictHandle )
584 {
585 // QT does not correctly export the mask
586 // TODO if we get around to it create a synthetic PICT with the CopyBits and Mask commands
968c951f 587 CGImageRef imageRef = CreateCGImage();
6239ee05
SC
588 err = GraphicsExportSetInputCGImage( exporter, imageRef );
589 err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
590 err = GraphicsExportDoExport(exporter, NULL);
591 CGImageRelease( imageRef );
592
593 size_t handleSize = GetHandleSize( (Handle) m_pictHandle );
594 // the 512 bytes header is only needed for pict files, but not in memory
595 if ( handleSize >= 512 )
596 {
597 memmove( *m_pictHandle , (char*)(*m_pictHandle)+512, handleSize - 512 );
598 SetHandleSize( (Handle) m_pictHandle, handleSize - 512 );
599 }
600 }
601 CloseComponent( exporter );
602 }
4f74e0d1 603#endif
b28aeea5 604 }
1cb97a54 605
b28aeea5
SC
606 return m_pictHandle ;
607}
55e18dbe 608
89954433 609void wxMacMemoryBufferReleaseProc(void *info, const void *data, size_t WXUNUSED(size))
20b69855 610{
71cc158e 611 wxMemoryBuffer* membuf = (wxMemoryBuffer*) info ;
1cb97a54 612
71cc158e 613 wxASSERT( data == membuf->GetData() ) ;
1cb97a54 614
71cc158e 615 delete membuf ;
5fde6fcc
GD
616}
617
968c951f 618CGImageRef wxBitmapRefData::CreateCGImage() const
be295828 619{
20b69855
SC
620 wxASSERT( m_ok ) ;
621 wxASSERT( m_rawAccessCount >= 0 ) ;
622 CGImageRef image ;
623 if ( m_rawAccessCount > 0 || m_cgImageRef == NULL )
be295828 624 {
e1673e52 625 if ( m_depth != 1 && m_bitmapMask == NULL )
be295828 626 {
6239ee05 627 if ( m_bitmapMask )
be295828 628 {
6239ee05
SC
629 CGImageRef tempImage = CGBitmapContextCreateImage( m_hBitmap );
630 CGImageRef tempMask = CGBitmapContextCreateImage((CGContextRef) m_bitmapMask->GetHBITMAP() );
631 image = CGImageCreateWithMask( tempImage, tempMask );
632 CGImageRelease(tempMask);
633 CGImageRelease(tempImage);
be295828 634 }
6239ee05
SC
635 else
636 image = CGBitmapContextCreateImage( m_hBitmap );
be295828 637 }
1cb97a54 638 else
e40298d5 639 {
6239ee05
SC
640 size_t imageSize = m_height * m_bytesPerRow ;
641 void * dataBuffer = m_memBuf.GetData() ;
642 int w = m_width ;
643 int h = m_height ;
644 CGImageAlphaInfo alphaInfo = kCGImageAlphaNoneSkipFirst ;
645 wxMemoryBuffer* membuf = NULL ;
646
647 if ( m_bitmapMask )
1cb97a54 648 {
6239ee05
SC
649 alphaInfo = kCGImageAlphaFirst ;
650 membuf = new wxMemoryBuffer( imageSize ) ;
651 memcpy( membuf->GetData() , dataBuffer , imageSize ) ;
652 unsigned char *sourcemaskstart = (unsigned char *) m_bitmapMask->GetRawAccess() ;
653 int maskrowbytes = m_bitmapMask->GetBytesPerRow() ;
654 unsigned char *destalphastart = (unsigned char *) membuf->GetData() ;
655 for ( int y = 0 ; y < h ; ++y , destalphastart += m_bytesPerRow, sourcemaskstart += maskrowbytes)
656 {
657 unsigned char *sourcemask = sourcemaskstart ;
658 unsigned char *destalpha = destalphastart ;
659 for ( int x = 0 ; x < w ; ++x , sourcemask += kMaskBytesPerPixel , destalpha += 4 )
660 {
661 *destalpha = 0xFF - *sourcemask ;
662 }
663 }
664 }
665 else
666 {
667 if ( m_hasAlpha )
668 {
20b69855 669#if wxMAC_USE_PREMULTIPLIED_ALPHA
6239ee05 670 alphaInfo = kCGImageAlphaPremultipliedFirst ;
20b69855 671#else
6239ee05 672 alphaInfo = kCGImageAlphaFirst ;
20b69855 673#endif
6239ee05
SC
674 }
675
676 membuf = new wxMemoryBuffer( m_memBuf ) ;
1cb97a54 677 }
6239ee05
SC
678
679 CGDataProviderRef dataProvider = NULL ;
680 if ( m_depth == 1 )
681 {
682 wxMemoryBuffer* maskBuf = new wxMemoryBuffer( m_width * m_height );
683 unsigned char * maskBufData = (unsigned char *) maskBuf->GetData();
684 unsigned char * bufData = (unsigned char *) membuf->GetData() ;
685 // copy one color component
686 for( int i = 0 ; i < m_width * m_height ; ++i )
687 maskBufData[i] = bufData[i*4+3];
688 dataProvider =
689 CGDataProviderCreateWithData(
690 maskBuf , (const void *) maskBufData , m_width * m_height,
691 wxMacMemoryBufferReleaseProc );
692 // as we are now passing the mask buffer to the data provider, we have
693 // to release the membuf ourselves
694 delete membuf ;
695
696 image = ::CGImageMaskCreate( w, h, 8, 8, m_width , dataProvider, NULL, false );
697 }
698 else
699 {
700 CGColorSpaceRef colorSpace = wxMacGetGenericRGBColorSpace();
701 dataProvider =
702 CGDataProviderCreateWithData(
703 membuf , (const void *)membuf->GetData() , imageSize,
704 wxMacMemoryBufferReleaseProc );
705 image =
706 ::CGImageCreate(
707 w, h, 8 , 32 , m_bytesPerRow , colorSpace, alphaInfo ,
708 dataProvider, NULL , false , kCGRenderingIntentDefault );
709 }
710 CGDataProviderRelease( dataProvider);
b083987d 711 }
20b69855
SC
712 }
713 else
714 {
715 image = m_cgImageRef ;
716 CGImageRetain( image ) ;
be295828 717 }
1cb97a54 718
20b69855
SC
719 if ( m_rawAccessCount == 0 && m_cgImageRef == NULL)
720 {
721 // we keep it for later use
722 m_cgImageRef = image ;
723 CGImageRetain( image ) ;
902725ee 724 }
1cb97a54 725
20b69855 726 return image ;
be295828
SC
727}
728
6239ee05
SC
729CGContextRef wxBitmapRefData::GetBitmapContext() const
730{
731 return m_hBitmap;
732}
20b69855 733
20b69855
SC
734void wxBitmapRefData::Free()
735{
736 wxASSERT_MSG( m_rawAccessCount == 0 , wxT("Bitmap still selected when destroyed") ) ;
737
20b69855
SC
738 if ( m_cgImageRef )
739 {
740 CGImageRelease( m_cgImageRef ) ;
741 m_cgImageRef = NULL ;
e40298d5 742 }
1cb97a54 743
b28aeea5
SC
744 if ( m_iconRef )
745 {
746 ReleaseIconRef( m_iconRef ) ;
747 m_iconRef = NULL ;
748 }
1cb97a54 749
4f74e0d1 750#ifndef __LP64__
b28aeea5
SC
751 if ( m_pictHandle )
752 {
753 KillPicture( m_pictHandle ) ;
754 m_pictHandle = NULL ;
755 }
6239ee05 756#endif
1cb97a54 757
20b69855
SC
758 if ( m_hBitmap )
759 {
6239ee05 760 CGContextRelease(m_hBitmap);
20b69855
SC
761 m_hBitmap = NULL ;
762 }
1cb97a54 763
20b69855 764 if (m_bitmapMask)
e40298d5 765 {
20b69855
SC
766 delete m_bitmapMask;
767 m_bitmapMask = NULL;
e40298d5 768 }
e9576ca5
SC
769}
770
85f296a3
SC
771wxBitmapRefData::~wxBitmapRefData()
772{
20b69855 773 Free() ;
85f296a3
SC
774}
775
90b959ae
SC
776bool wxBitmap::CopyFromIcon(const wxIcon& icon)
777{
1cb97a54 778 bool created = false ;
20b69855
SC
779 int w = icon.GetWidth() ;
780 int h = icon.GetHeight() ;
b28aeea5 781
20b69855
SC
782 Create( icon.GetWidth() , icon.GetHeight() ) ;
783
71cc158e 784 if ( w == h && ( w == 16 || w == 32 || w == 48 || w == 128 ) )
20b69855
SC
785 {
786 IconFamilyHandle iconFamily = NULL ;
1cb97a54
DS
787 Handle imagehandle = NewHandle( 0 ) ;
788 Handle maskhandle = NewHandle( 0 ) ;
902725ee 789
9cc62fc8
SC
790 OSType maskType = 0;
791 OSType dataType = 0;
902725ee 792 IconSelectorValue selector = 0 ;
1cb97a54
DS
793
794 switch (w)
71cc158e 795 {
1cb97a54
DS
796 case 128:
797 dataType = kThumbnail32BitData ;
798 maskType = kThumbnail8BitMask ;
799 selector = kSelectorAllAvailableData ;
800 break;
801
802 case 48:
803 dataType = kHuge32BitData ;
804 maskType = kHuge8BitMask ;
805 selector = kSelectorHuge32Bit | kSelectorHuge8BitMask ;
806 break;
807
808 case 32:
809 dataType = kLarge32BitData ;
810 maskType = kLarge8BitMask ;
811 selector = kSelectorLarge32Bit | kSelectorLarge8BitMask ;
812 break;
813
814 case 16:
815 dataType = kSmall32BitData ;
816 maskType = kSmall8BitMask ;
817 selector = kSelectorSmall32Bit | kSelectorSmall8BitMask ;
818 break;
819
820 default:
821 break;
71cc158e 822 }
71cc158e 823
1cb97a54 824 OSStatus err = IconRefToIconFamily( MAC_WXHICON(icon.GetHICON()) , selector , &iconFamily ) ;
71cc158e 825
1cb97a54
DS
826 err = GetIconFamilyData( iconFamily , dataType , imagehandle ) ;
827 err = GetIconFamilyData( iconFamily , maskType , maskhandle ) ;
b28aeea5
SC
828 size_t imagehandlesize = GetHandleSize( imagehandle ) ;
829 size_t maskhandlesize = GetHandleSize( maskhandle ) ;
902725ee 830
b28aeea5 831 if ( imagehandlesize != 0 && maskhandlesize != 0 )
20b69855 832 {
b28aeea5
SC
833 wxASSERT( GetHandleSize( imagehandle ) == w * 4 * h ) ;
834 wxASSERT( GetHandleSize( maskhandle ) == w * h ) ;
1cb97a54 835
b28aeea5 836 UseAlpha() ;
1cb97a54 837
b28aeea5
SC
838 unsigned char *source = (unsigned char *) *imagehandle ;
839 unsigned char *sourcemask = (unsigned char *) *maskhandle ;
b28aeea5 840 unsigned char* destination = (unsigned char*) BeginRawAccess() ;
1cb97a54 841
b28aeea5 842 for ( int y = 0 ; y < h ; ++y )
20b69855 843 {
b28aeea5
SC
844 for ( int x = 0 ; x < w ; ++x )
845 {
6239ee05
SC
846 unsigned char a = *sourcemask++;
847 *destination++ = a;
b28aeea5 848 source++ ;
6239ee05
SC
849#if wxMAC_USE_PREMULTIPLIED_ALPHA
850 *destination++ = ( (*source++) * a + 127 ) / 255;
851 *destination++ = ( (*source++) * a + 127 ) / 255;
852 *destination++ = ( (*source++) * a + 127 ) / 255;
853#else
b28aeea5
SC
854 *destination++ = *source++ ;
855 *destination++ = *source++ ;
856 *destination++ = *source++ ;
6239ee05 857#endif
b28aeea5 858 }
20b69855 859 }
1cb97a54 860
b28aeea5
SC
861 EndRawAccess() ;
862 DisposeHandle( imagehandle ) ;
863 DisposeHandle( maskhandle ) ;
95d8425f 864 created = true ;
20b69855 865 }
902725ee 866
1cb97a54 867 DisposeHandle( (Handle) iconFamily ) ;
20b69855 868 }
902725ee 869
b28aeea5 870 if ( !created )
902725ee 871 {
20b69855
SC
872 wxMemoryDC dc ;
873 dc.SelectObject( *this ) ;
874 dc.DrawIcon( icon , 0 , 0 ) ;
875 dc.SelectObject( wxNullBitmap ) ;
876 }
1cb97a54 877
125c389e 878 return true;
90b959ae
SC
879}
880
e9576ca5
SC
881wxBitmap::wxBitmap()
882{
e9576ca5
SC
883}
884
885wxBitmap::~wxBitmap()
886{
e9576ca5
SC
887}
888
889wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
890{
20b69855 891 m_refData = new wxBitmapRefData( the_width , the_height , no_bits ) ;
e9576ca5 892
d2c6d549
GD
893 if ( no_bits == 1 )
894 {
973b0afb 895 int linesize = ( the_width / (sizeof(unsigned char) * 8)) ;
1cb97a54 896 if ( the_width % (sizeof(unsigned char) * 8) )
973b0afb 897 linesize += sizeof(unsigned char);
1cb97a54 898
20b69855 899 unsigned char* linestart = (unsigned char*) bits ;
6239ee05 900 unsigned char* destptr = (unsigned char*) BeginRawAccess() ;
1cb97a54 901
6239ee05 902 for ( int y = 0 ; y < the_height ; ++y , linestart += linesize, destptr += M_BITMAPDATA->GetBytesPerRow() )
973b0afb 903 {
6239ee05 904 unsigned char* destination = destptr;
1cb97a54
DS
905 int index, bit, mask;
906
973b0afb
GD
907 for ( int x = 0 ; x < the_width ; ++x )
908 {
1cb97a54
DS
909 index = x / 8 ;
910 bit = x % 8 ;
911 mask = 1 << bit ;
912
b083987d 913 if ( linestart[index] & mask )
973b0afb 914 {
20b69855
SC
915 *destination++ = 0xFF ;
916 *destination++ = 0 ;
917 *destination++ = 0 ;
918 *destination++ = 0 ;
973b0afb
GD
919 }
920 else
921 {
20b69855
SC
922 *destination++ = 0xFF ;
923 *destination++ = 0xFF ;
924 *destination++ = 0xFF ;
925 *destination++ = 0xFF ;
973b0afb
GD
926 }
927 }
928 }
1cb97a54 929
20b69855 930 EndRawAccess() ;
d2c6d549
GD
931 }
932 else
933 {
973b0afb 934 wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
d2c6d549 935 }
e9576ca5
SC
936}
937
938wxBitmap::wxBitmap(int w, int h, int d)
939{
940 (void)Create(w, h, d);
e9576ca5
SC
941}
942
452418c4 943wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)
e9576ca5
SC
944{
945 (void) Create(data, type, width, height, depth);
e9576ca5
SC
946}
947
a8562f55 948wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
e9576ca5 949{
a8562f55 950 LoadFile(filename, type);
e9576ca5
SC
951}
952
2bf8f4c0
RD
953wxObjectRefData* wxBitmap::CreateRefData() const
954{
955 return new wxBitmapRefData;
956}
957
958wxObjectRefData* wxBitmap::CloneRefData(const wxObjectRefData* data) const
959{
960 return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
961}
962
1cb97a54 963void * wxBitmap::GetRawAccess() const
20b69855
SC
964{
965 wxCHECK_MSG( Ok() , NULL , wxT("invalid bitmap") ) ;
1cb97a54 966
20b69855
SC
967 return M_BITMAPDATA->GetRawAccess() ;
968}
969
1cb97a54 970void * wxBitmap::BeginRawAccess()
20b69855
SC
971{
972 wxCHECK_MSG( Ok() , NULL , wxT("invalid bitmap") ) ;
1cb97a54 973
20b69855
SC
974 return M_BITMAPDATA->BeginRawAccess() ;
975}
976
977void wxBitmap::EndRawAccess()
978{
979 wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
1cb97a54 980
20b69855
SC
981 M_BITMAPDATA->EndRawAccess() ;
982}
983
968c951f 984CGImageRef wxBitmap::CreateCGImage() const
03e11df5 985{
20b69855 986 wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
1cb97a54 987
968c951f
SC
988 return M_BITMAPDATA->CreateCGImage() ;
989}
990
991IconRef wxBitmap::GetIconRef() const
992{
993 wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
994
995 return M_BITMAPDATA->GetIconRef() ;
996}
997
998IconRef wxBitmap::CreateIconRef() const
999{
1000 IconRef icon = GetIconRef();
1001 verify_noerr( AcquireIconRef(icon) );
1002 return icon;
03e11df5
GD
1003}
1004
5fde6fcc
GD
1005wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
1006{
20b69855 1007 wxCHECK_MSG( Ok() &&
5fde6fcc
GD
1008 (rect.x >= 0) && (rect.y >= 0) &&
1009 (rect.x+rect.width <= GetWidth()) &&
1010 (rect.y+rect.height <= GetHeight()),
1011 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
1012
20b69855
SC
1013 wxBitmap ret( rect.width, rect.height, GetDepth() );
1014 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
5fde6fcc 1015
20b69855
SC
1016 int destwidth = rect.width ;
1017 int destheight = rect.height ;
1cb97a54 1018
20b69855 1019 {
1cb97a54
DS
1020 unsigned char *sourcedata = (unsigned char*) GetRawAccess() ;
1021 unsigned char *destdata = (unsigned char*) ret.BeginRawAccess() ;
1022 wxASSERT( (sourcedata != NULL) && (destdata != NULL) ) ;
1023
6239ee05
SC
1024 int sourcelinesize = GetBitmapData()->GetBytesPerRow() ;
1025 int destlinesize = ret.GetBitmapData()->GetBytesPerRow() ;
20b69855
SC
1026 unsigned char *source = sourcedata + rect.x * 4 + rect.y * sourcelinesize ;
1027 unsigned char *dest = destdata ;
1cb97a54
DS
1028
1029 for (int yy = 0; yy < destheight; ++yy, source += sourcelinesize , dest += destlinesize)
20b69855
SC
1030 {
1031 memcpy( dest , source , destlinesize ) ;
1032 }
1033 }
1cb97a54 1034
20b69855 1035 ret.EndRawAccess() ;
902725ee 1036
20b69855
SC
1037 if ( M_BITMAPDATA->m_bitmapMask )
1038 {
1039 wxMemoryBuffer maskbuf ;
6239ee05 1040 int rowBytes = GetBestBytesPerRow( destwidth * kMaskBytesPerPixel );
20b69855 1041 size_t maskbufsize = rowBytes * destheight ;
20b69855 1042
7fe44dee 1043 int sourcelinesize = M_BITMAPDATA->m_bitmapMask->GetBytesPerRow() ;
20b69855 1044 int destlinesize = rowBytes ;
1cb97a54 1045
20b69855 1046 unsigned char *source = (unsigned char *) M_BITMAPDATA->m_bitmapMask->GetRawAccess() ;
1cb97a54
DS
1047 unsigned char *destdata = (unsigned char * ) maskbuf.GetWriteBuf( maskbufsize ) ;
1048 wxASSERT( (source != NULL) && (destdata != NULL) ) ;
1049
6239ee05 1050 source += rect.x * kMaskBytesPerPixel + rect.y * sourcelinesize ;
20b69855
SC
1051 unsigned char *dest = destdata ;
1052
1cb97a54 1053 for (int yy = 0; yy < destheight; ++yy, source += sourcelinesize , dest += destlinesize)
20b69855 1054 {
392e179f 1055 memcpy( dest , source , destlinesize ) ;
20b69855 1056 }
1cb97a54 1057
20b69855
SC
1058 maskbuf.UngetWriteBuf( maskbufsize ) ;
1059 ret.SetMask( new wxMask( maskbuf , destwidth , destheight , rowBytes ) ) ;
1060 }
1061 else if ( HasAlpha() )
1062 ret.UseAlpha() ;
5fde6fcc 1063
20b69855 1064 return ret;
5fde6fcc
GD
1065}
1066
e9576ca5
SC
1067bool wxBitmap::Create(int w, int h, int d)
1068{
1069 UnRef();
1070
20b69855
SC
1071 if ( d < 0 )
1072 d = wxDisplayDepth() ;
2a391f87 1073
20b69855 1074 m_refData = new wxBitmapRefData( w , h , d );
55e18dbe 1075
20b69855 1076 return M_BITMAPDATA->Ok() ;
519cb848
SC
1077}
1078
a8562f55 1079bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
e9576ca5
SC
1080{
1081 UnRef();
1082
e9576ca5
SC
1083 wxBitmapHandler *handler = FindHandler(type);
1084
a8562f55
GD
1085 if ( handler )
1086 {
4e9ed364 1087 m_refData = new wxBitmapRefData;
e9576ca5 1088
a8562f55 1089 return handler->LoadFile(this, filename, type, -1, -1);
e9576ca5 1090 }
a8562f55
GD
1091 else
1092 {
d45318b8 1093#if wxUSE_IMAGE
a8562f55 1094 wxImage loadimage(filename, type);
1cb97a54
DS
1095 if (loadimage.Ok())
1096 {
a8562f55 1097 *this = loadimage;
1cb97a54 1098
a8562f55
GD
1099 return true;
1100 }
d45318b8 1101#endif
a8562f55 1102 }
1cb97a54 1103
427ff662 1104 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
1cb97a54 1105
a8562f55 1106 return false;
e9576ca5
SC
1107}
1108
452418c4 1109bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)
e9576ca5
SC
1110{
1111 UnRef();
1112
1113 m_refData = new wxBitmapRefData;
1114
1115 wxBitmapHandler *handler = FindHandler(type);
1116
1cb97a54
DS
1117 if ( handler == NULL )
1118 {
427ff662 1119 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
e9576ca5 1120
902725ee 1121 return false;
e9576ca5
SC
1122 }
1123
1124 return handler->Create(this, data, type, width, height, depth);
1125}
1126
d45318b8
RN
1127#if wxUSE_IMAGE
1128
fec19ea9
VS
1129wxBitmap::wxBitmap(const wxImage& image, int depth)
1130{
637b7e4f 1131 wxCHECK_RET( image.Ok(), wxT("invalid image") );
6239ee05 1132
fec19ea9
VS
1133 // width and height of the device-dependent bitmap
1134 int width = image.GetWidth();
1135 int height = image.GetHeight();
6239ee05 1136
d0ee33f5 1137 m_refData = new wxBitmapRefData( width , height , depth ) ;
6239ee05 1138
20b69855 1139 // Create picture
6239ee05 1140
20b69855 1141 bool hasAlpha = false ;
6239ee05 1142
20b69855
SC
1143 if ( image.HasMask() )
1144 {
1145 // takes precedence, don't mix with alpha info
1146 }
1147 else
1148 {
1149 hasAlpha = image.HasAlpha() ;
1150 }
6239ee05 1151
20b69855
SC
1152 if ( hasAlpha )
1153 UseAlpha() ;
6239ee05
SC
1154
1155 unsigned char* destinationstart = (unsigned char*) BeginRawAccess() ;
fec19ea9 1156 register unsigned char* data = image.GetData();
6239ee05 1157 if ( destinationstart != NULL && data != NULL )
fec19ea9 1158 {
6239ee05
SC
1159 const unsigned char *alpha = hasAlpha ? image.GetAlpha() : NULL ;
1160 for (int y = 0; y < height; destinationstart += M_BITMAPDATA->GetBytesPerRow(), y++)
fec19ea9 1161 {
6239ee05
SC
1162 unsigned char * destination = destinationstart;
1163 for (int x = 0; x < width; x++)
20b69855 1164 {
6239ee05
SC
1165 if ( hasAlpha )
1166 {
1167 const unsigned char a = *alpha++;
1168 *destination++ = a ;
1169
20b69855 1170#if wxMAC_USE_PREMULTIPLIED_ALPHA
6239ee05
SC
1171 *destination++ = ((*data++) * a + 127) / 255 ;
1172 *destination++ = ((*data++) * a + 127) / 255 ;
1173 *destination++ = ((*data++) * a + 127) / 255 ;
20b69855 1174#else
6239ee05
SC
1175 *destination++ = *data++ ;
1176 *destination++ = *data++ ;
1177 *destination++ = *data++ ;
20b69855 1178#endif
6239ee05
SC
1179 }
1180 else
1181 {
1182 *destination++ = 0xFF ;
1183 *destination++ = *data++ ;
1184 *destination++ = *data++ ;
1185 *destination++ = *data++ ;
1186 }
20b69855 1187 }
fec19ea9 1188 }
6239ee05
SC
1189
1190 EndRawAccess() ;
55e18dbe 1191 }
20b69855 1192 if ( image.HasMask() )
20b69855 1193 SetMask( new wxMask( *this , wxColour( image.GetMaskRed() , image.GetMaskGreen() , image.GetMaskBlue() ) ) ) ;
fec19ea9
VS
1194}
1195
1196wxImage wxBitmap::ConvertToImage() const
1197{
1198 wxImage image;
55e18dbe 1199
fec19ea9
VS
1200 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
1201
1202 // create an wxImage object
1203 int width = GetWidth();
1204 int height = GetHeight();
1205 image.Create( width, height );
1206
1207 unsigned char *data = image.GetData();
fec19ea9
VS
1208 wxCHECK_MSG( data, wxNullImage, wxT("Could not allocate data for image") );
1209
6239ee05 1210 unsigned char* sourcestart = (unsigned char*) GetRawAccess() ;
20b69855
SC
1211
1212 bool hasAlpha = false ;
1213 bool hasMask = false ;
7e7f40ed 1214 int maskBytesPerRow = 0 ;
20b69855
SC
1215 unsigned char *alpha = NULL ;
1216 unsigned char *mask = NULL ;
1cb97a54 1217
20b69855 1218 if ( HasAlpha() )
20b69855 1219 hasAlpha = true ;
20b69855
SC
1220
1221 if ( GetMask() )
2b5f62a0 1222 {
20b69855
SC
1223 hasMask = true ;
1224 mask = (unsigned char*) GetMask()->GetRawAccess() ;
7e7f40ed 1225 maskBytesPerRow = GetMask()->GetBytesPerRow() ;
e40298d5 1226 }
20b69855
SC
1227
1228 if ( hasAlpha )
e40298d5 1229 {
20b69855
SC
1230 image.SetAlpha() ;
1231 alpha = image.GetAlpha() ;
e40298d5 1232 }
1cb97a54 1233
20b69855 1234 int index = 0;
902725ee 1235
20b69855
SC
1236 // The following masking algorithm is the same as well in msw/gtk:
1237 // the colour used as transparent one in wxImage and the one it is
7fe44dee 1238 // replaced with when it actually occurs in the bitmap
20b69855
SC
1239 static const int MASK_RED = 1;
1240 static const int MASK_GREEN = 2;
1241 static const int MASK_BLUE = 3;
1242 static const int MASK_BLUE_REPLACEMENT = 2;
1243
6239ee05 1244 for (int yy = 0; yy < height; yy++ , sourcestart += M_BITMAPDATA->GetBytesPerRow() , mask += maskBytesPerRow )
fec19ea9 1245 {
7e7f40ed 1246 unsigned char * maskp = mask ;
6239ee05 1247 unsigned char * source = sourcestart;
1cb97a54
DS
1248 unsigned char a, r, g, b;
1249 long color;
1250
fec19ea9
VS
1251 for (int xx = 0; xx < width; xx++)
1252 {
1cb97a54 1253 color = *((long*) source) ;
f288c87b 1254#ifdef WORDS_BIGENDIAN
1cb97a54
DS
1255 a = ((color&0xFF000000) >> 24) ;
1256 r = ((color&0x00FF0000) >> 16) ;
1257 g = ((color&0x0000FF00) >> 8) ;
1258 b = (color&0x000000FF);
f288c87b
SC
1259#else
1260 b = ((color&0xFF000000) >> 24) ;
1261 g = ((color&0x00FF0000) >> 16) ;
1262 r = ((color&0x0000FF00) >> 8) ;
1263 a = (color&0x000000FF);
1264#endif
20b69855 1265 if ( hasMask )
55e18dbe 1266 {
93a2b888 1267 if ( *maskp++ == 0xFF )
e40298d5 1268 {
e59ea2c5
SC
1269 r = MASK_RED ;
1270 g = MASK_GREEN ;
1271 b = MASK_BLUE ;
e40298d5 1272 }
e59ea2c5
SC
1273 else if ( r == MASK_RED && g == MASK_GREEN && b == MASK_BLUE )
1274 b = MASK_BLUE_REPLACEMENT ;
fec19ea9 1275 }
20b69855 1276 else if ( hasAlpha )
6239ee05 1277 {
20b69855 1278 *alpha++ = a ;
6239ee05
SC
1279#if wxMAC_USE_PREMULTIPLIED_ALPHA
1280 // this must be non-premultiplied data
1281 if ( a != 0xFF && a!= 0 )
1282 {
1283 r = r * 255 / a;
1284 g = g * 255 / a;
1285 b = b * 255 / a;
1286 }
1287#endif
1288 }
20b69855
SC
1289
1290 data[index ] = r ;
1291 data[index + 1] = g ;
1292 data[index + 2] = b ;
1cb97a54 1293
fec19ea9 1294 index += 3;
20b69855 1295 source += 4 ;
fec19ea9
VS
1296 }
1297 }
1cb97a54 1298
20b69855
SC
1299 if ( hasMask )
1300 image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
1cb97a54 1301
fec19ea9
VS
1302 return image;
1303}
1304
d45318b8 1305#endif //wxUSE_IMAGE
fec19ea9 1306
7fe44dee
DS
1307bool wxBitmap::SaveFile( const wxString& filename,
1308 wxBitmapType type, const wxPalette *palette ) const
e9576ca5 1309{
902725ee 1310 bool success = false;
e9576ca5
SC
1311 wxBitmapHandler *handler = FindHandler(type);
1312
a8562f55
GD
1313 if ( handler )
1314 {
902725ee 1315 success = handler->SaveFile(this, filename, type, palette);
a8562f55
GD
1316 }
1317 else
1318 {
d45318b8 1319#if wxUSE_IMAGE
a8562f55 1320 wxImage image = ConvertToImage();
902725ee
WS
1321 success = image.SaveFile(filename, type);
1322#else
1323 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
d45318b8 1324#endif
a8562f55 1325 }
55e18dbe 1326
902725ee 1327 return success;
e9576ca5
SC
1328}
1329
b7cacb43 1330bool wxBitmap::IsOk() const
5fde6fcc 1331{
20b69855 1332 return (M_BITMAPDATA && M_BITMAPDATA->Ok());
5fde6fcc
GD
1333}
1334
1335int wxBitmap::GetHeight() const
1336{
1337 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1338
20b69855 1339 return M_BITMAPDATA->GetHeight();
5fde6fcc
GD
1340}
1341
1342int wxBitmap::GetWidth() const
1343{
1344 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1345
20b69855 1346 return M_BITMAPDATA->GetWidth() ;
5fde6fcc
GD
1347}
1348
1349int wxBitmap::GetDepth() const
1350{
1351 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1352
20b69855 1353 return M_BITMAPDATA->GetDepth();
5fde6fcc
GD
1354}
1355
5fde6fcc
GD
1356wxMask *wxBitmap::GetMask() const
1357{
1358 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
1359
1360 return M_BITMAPDATA->m_bitmapMask;
1361}
1362
20b69855
SC
1363bool wxBitmap::HasAlpha() const
1364{
1365 wxCHECK_MSG( Ok(), false , wxT("invalid bitmap") );
1366
1367 return M_BITMAPDATA->HasAlpha() ;
1368}
1369
e9576ca5
SC
1370void wxBitmap::SetWidth(int w)
1371{
55ccdb93 1372 AllocExclusive();
20b69855 1373 M_BITMAPDATA->SetWidth(w);
e9576ca5
SC
1374}
1375
1376void wxBitmap::SetHeight(int h)
1377{
55ccdb93 1378 AllocExclusive();
20b69855 1379 M_BITMAPDATA->SetHeight(h);
e9576ca5
SC
1380}
1381
1382void wxBitmap::SetDepth(int d)
1383{
55ccdb93 1384 AllocExclusive();
20b69855 1385 M_BITMAPDATA->SetDepth(d);
e9576ca5
SC
1386}
1387
e9576ca5
SC
1388void wxBitmap::SetOk(bool isOk)
1389{
55ccdb93 1390 AllocExclusive();
20b69855 1391 M_BITMAPDATA->SetOk(isOk);
e9576ca5
SC
1392}
1393
a6de86fa 1394#if wxUSE_PALETTE
5fde6fcc
GD
1395wxPalette *wxBitmap::GetPalette() const
1396{
1397 wxCHECK_MSG( Ok(), NULL, wxT("Invalid bitmap GetPalette()") );
1398
1399 return &M_BITMAPDATA->m_bitmapPalette;
1400}
1401
e9576ca5
SC
1402void wxBitmap::SetPalette(const wxPalette& palette)
1403{
55ccdb93 1404 AllocExclusive();
e9576ca5
SC
1405 M_BITMAPDATA->m_bitmapPalette = palette ;
1406}
a6de86fa 1407#endif // wxUSE_PALETTE
e9576ca5
SC
1408
1409void wxBitmap::SetMask(wxMask *mask)
1410{
55ccdb93 1411 AllocExclusive();
a8562f55 1412 // Remove existing mask if there is one.
1e74d03b 1413 delete M_BITMAPDATA->m_bitmapMask;
a8562f55 1414
e9576ca5
SC
1415 M_BITMAPDATA->m_bitmapMask = mask ;
1416}
1417
20b69855 1418WXHBITMAP wxBitmap::GetHBITMAP(WXHBITMAP* mask) const
5fde6fcc 1419{
31c1cbc7
VZ
1420 wxUnusedVar(mask);
1421
6239ee05 1422 return WXHBITMAP(M_BITMAPDATA->GetBitmapContext());
5fde6fcc
GD
1423}
1424
20b69855
SC
1425// ----------------------------------------------------------------------------
1426// wxMask
1427// ----------------------------------------------------------------------------
e9576ca5
SC
1428
1429wxMask::wxMask()
1430{
20b69855 1431 Init() ;
e9576ca5
SC
1432}
1433
2bf8f4c0
RD
1434wxMask::wxMask(const wxMask &tocopy)
1435{
1436 Init();
1437
1438 m_bytesPerRow = tocopy.m_bytesPerRow;
1439 m_width = tocopy.m_width;
1440 m_height = tocopy.m_height;
1441
1442 size_t size = m_bytesPerRow * m_height;
1443 unsigned char* dest = (unsigned char*)m_memBuf.GetWriteBuf( size );
1444 unsigned char* source = (unsigned char*)tocopy.m_memBuf.GetData();
6239ee05 1445 memcpy( dest, source, size );
2bf8f4c0
RD
1446 m_memBuf.UngetWriteBuf( size ) ;
1447 RealizeNative() ;
1448}
1449
e9576ca5
SC
1450// Construct a mask from a bitmap and a colour indicating
1451// the transparent area
7fe44dee 1452wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
e9576ca5 1453{
20b69855 1454 Init() ;
7fe44dee 1455 Create( bitmap, colour );
e9576ca5
SC
1456}
1457
20b69855 1458// Construct a mask from a mono bitmap (copies the bitmap).
7fe44dee 1459wxMask::wxMask( const wxBitmap& bitmap )
e9576ca5 1460{
20b69855 1461 Init() ;
7fe44dee 1462 Create( bitmap );
e9576ca5
SC
1463}
1464
1465// Construct a mask from a mono bitmap (copies the bitmap).
392e179f 1466
1cb97a54 1467wxMask::wxMask( const wxMemoryBuffer& data, int width , int height , int bytesPerRow )
e9576ca5 1468{
20b69855 1469 Init() ;
7fe44dee 1470 Create( data, width , height , bytesPerRow );
e9576ca5
SC
1471}
1472
1473wxMask::~wxMask()
1474{
4e9ed364
RR
1475 if ( m_maskBitmap )
1476 {
6239ee05 1477 CGContextRelease( (CGContextRef) m_maskBitmap );
4e9ed364
RR
1478 m_maskBitmap = NULL ;
1479 }
e9576ca5
SC
1480}
1481
902725ee 1482void wxMask::Init()
e9576ca5 1483{
20b69855 1484 m_width = m_height = m_bytesPerRow = 0 ;
20b69855 1485 m_maskBitmap = NULL ;
20b69855 1486}
5fde6fcc 1487
20b69855
SC
1488void *wxMask::GetRawAccess() const
1489{
1490 return m_memBuf.GetData() ;
1491}
5fde6fcc 1492
7fe44dee
DS
1493// The default ColorTable for k8IndexedGrayPixelFormat in Intel appears to be broken, so we'll use an non-indexed
1494// bitmap mask instead; in order to keep the code simple, the change applies to PowerPC implementations as well
431c82e0 1495
902725ee 1496void wxMask::RealizeNative()
20b69855 1497{
20b69855
SC
1498 if ( m_maskBitmap )
1499 {
6239ee05 1500 CGContextRelease( (CGContextRef) m_maskBitmap );
20b69855
SC
1501 m_maskBitmap = NULL ;
1502 }
1cb97a54 1503
6239ee05
SC
1504 CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceGray();
1505 // from MouseTracking sample :
1506 // Ironically, due to a bug in CGImageCreateWithMask, you cannot use
1507 // CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) at this point!
1508
1509 m_maskBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, colorspace,
1510 kCGImageAlphaNone );
1511 CGColorSpaceRelease( colorspace );
1512 wxASSERT_MSG( m_maskBitmap , wxT("Unable to create CGBitmapContext context") ) ;
20b69855 1513}
5fde6fcc 1514
20b69855 1515// Create a mask from a mono bitmap (copies the bitmap).
392e179f 1516
20b69855
SC
1517bool wxMask::Create(const wxMemoryBuffer& data,int width , int height , int bytesPerRow)
1518{
1519 m_memBuf = data ;
1520 m_width = width ;
1521 m_height = height ;
1522 m_bytesPerRow = bytesPerRow ;
1cb97a54 1523
20b69855 1524 wxASSERT( data.GetDataLen() == (size_t)(height * bytesPerRow) ) ;
1cb97a54 1525
20b69855 1526 RealizeNative() ;
1cb97a54 1527
20b69855 1528 return true ;
e9576ca5
SC
1529}
1530
20b69855
SC
1531// Create a mask from a mono bitmap (copies the bitmap).
1532bool wxMask::Create(const wxBitmap& bitmap)
e9576ca5 1533{
20b69855
SC
1534 m_width = bitmap.GetWidth() ;
1535 m_height = bitmap.GetHeight() ;
6239ee05 1536 m_bytesPerRow = GetBestBytesPerRow( m_width * kMaskBytesPerPixel ) ;
1cb97a54 1537
20b69855
SC
1538 size_t size = m_bytesPerRow * m_height ;
1539 unsigned char * destdatabase = (unsigned char*) m_memBuf.GetWriteBuf( size ) ;
1cb97a54
DS
1540 wxASSERT( destdatabase != NULL ) ;
1541
20b69855
SC
1542 memset( destdatabase , 0 , size ) ;
1543 unsigned char * srcdata = (unsigned char*) bitmap.GetRawAccess() ;
1cb97a54 1544
20b69855
SC
1545 for ( int y = 0 ; y < m_height ; ++y , destdatabase += m_bytesPerRow )
1546 {
1cb97a54
DS
1547 unsigned char *destdata = destdatabase ;
1548 unsigned char r, g, b;
1549
1550 for ( int x = 0 ; x < m_width ; ++x )
20b69855
SC
1551 {
1552 srcdata++ ;
1cb97a54
DS
1553 r = *srcdata++ ;
1554 g = *srcdata++ ;
1555 b = *srcdata++ ;
1556
20b69855 1557 if ( ( r + g + b ) > 0x10 )
20b69855 1558 *destdata++ = 0xFF ;
93a2b888 1559 else
392e179f 1560 *destdata++ = 0x00 ;
20b69855
SC
1561 }
1562 }
1cb97a54 1563
20b69855
SC
1564 m_memBuf.UngetWriteBuf( size ) ;
1565 RealizeNative() ;
1cb97a54 1566
902725ee 1567 return true;
e9576ca5
SC
1568}
1569
1570// Create a mask from a bitmap and a colour indicating
1571// the transparent area
1572bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1573{
20b69855
SC
1574 m_width = bitmap.GetWidth() ;
1575 m_height = bitmap.GetHeight() ;
6239ee05 1576 m_bytesPerRow = GetBestBytesPerRow( m_width * kMaskBytesPerPixel ) ;
20b69855 1577
1cb97a54 1578 size_t size = m_bytesPerRow * m_height ;
20b69855 1579 unsigned char * destdatabase = (unsigned char*) m_memBuf.GetWriteBuf( size ) ;
1cb97a54
DS
1580 wxASSERT( destdatabase != NULL ) ;
1581
20b69855 1582 memset( destdatabase , 0 , size ) ;
6239ee05
SC
1583 unsigned char * srcdatabase = (unsigned char*) bitmap.GetRawAccess() ;
1584 size_t sourceBytesRow = bitmap.GetBitmapData()->GetBytesPerRow();
1cb97a54 1585
6239ee05 1586 for ( int y = 0 ; y < m_height ; ++y , srcdatabase+= sourceBytesRow, destdatabase += m_bytesPerRow)
8208e181 1587 {
6239ee05 1588 unsigned char *srcdata = srcdatabase ;
1cb97a54
DS
1589 unsigned char *destdata = destdatabase ;
1590 unsigned char r, g, b;
1591
1592 for ( int x = 0 ; x < m_width ; ++x )
55e18dbe 1593 {
20b69855 1594 srcdata++ ;
1cb97a54
DS
1595 r = *srcdata++ ;
1596 g = *srcdata++ ;
1597 b = *srcdata++ ;
1598
7fe44dee 1599 if ( colour == wxColour( r , g , b ) )
93a2b888 1600 *destdata++ = 0xFF ;
93a2b888 1601 else
93a2b888 1602 *destdata++ = 0x00 ;
8208e181
SC
1603 }
1604 }
1cb97a54 1605
20b69855
SC
1606 m_memBuf.UngetWriteBuf( size ) ;
1607 RealizeNative() ;
1cb97a54 1608
902725ee 1609 return true;
e9576ca5
SC
1610}
1611
20b69855 1612WXHBITMAP wxMask::GetHBITMAP() const
5fde6fcc 1613{
20b69855 1614 return m_maskBitmap ;
5fde6fcc
GD
1615}
1616
20b69855
SC
1617// ----------------------------------------------------------------------------
1618// wxBitmapHandler
1619// ----------------------------------------------------------------------------
e9576ca5 1620
452418c4 1621IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
e9576ca5 1622
20b69855
SC
1623// ----------------------------------------------------------------------------
1624// Standard Handlers
1625// ----------------------------------------------------------------------------
e9576ca5 1626
2078e2f1
SC
1627#ifndef __LP64__
1628
519cb848
SC
1629class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
1630{
1631 DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)
1cb97a54 1632
519cb848
SC
1633public:
1634 inline wxPICTResourceHandler()
1635 {
3bf2bdfb
GD
1636 SetName(wxT("Macintosh Pict resource"));
1637 SetExtension(wxEmptyString);
1638 SetType(wxBITMAP_TYPE_PICT_RESOURCE);
519cb848
SC
1639 };
1640
1641 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1642 int desiredWidth, int desiredHeight);
1643};
7fe44dee 1644
519cb848
SC
1645IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler, wxBitmapHandler)
1646
179e085f 1647
89954433
VZ
1648bool wxPICTResourceHandler::LoadFile(wxBitmap *bitmap,
1649 const wxString& name,
1650 long WXUNUSED(flags),
1651 int WXUNUSED(desiredWidth),
1652 int WXUNUSED(desiredHeight))
519cb848 1653{
179e085f 1654#if wxUSE_METAFILE
4e9ed364 1655 Str255 theName ;
427ff662 1656 wxMacStringToPascal( name , theName ) ;
55e18dbe 1657
4e9ed364
RR
1658 PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ;
1659 if ( thePict )
1660 {
20b69855 1661 wxMetafile mf ;
7fe44dee 1662
6239ee05 1663 mf.SetPICT( thePict ) ;
20b69855
SC
1664 bitmap->Create( mf.GetWidth() , mf.GetHeight() ) ;
1665 wxMemoryDC dc ;
1666 dc.SelectObject( *bitmap ) ;
1667 mf.Play( &dc ) ;
1668 dc.SelectObject( wxNullBitmap ) ;
1cb97a54 1669
902725ee 1670 return true ;
4e9ed364 1671 }
7fe44dee 1672#endif
1cb97a54 1673
902725ee 1674 return false ;
519cb848 1675}
2078e2f1 1676#endif
519cb848 1677
e9576ca5
SC
1678void wxBitmap::InitStandardHandlers()
1679{
2078e2f1 1680#ifndef __LP64__
1cb97a54 1681 AddHandler( new wxPICTResourceHandler ) ;
2078e2f1 1682#endif
1cb97a54 1683 AddHandler( new wxICONResourceHandler ) ;
e9576ca5 1684}
55e18dbe
VZ
1685
1686// ----------------------------------------------------------------------------
1687// raw bitmap access support
1688// ----------------------------------------------------------------------------
1689
89954433 1690void *wxBitmap::GetRawData(wxPixelDataBase& data, int WXUNUSED(bpp))
55e18dbe
VZ
1691{
1692 if ( !Ok() )
55e18dbe
VZ
1693 // no bitmap, no data (raw or otherwise)
1694 return NULL;
55e18dbe 1695
20b69855
SC
1696 data.m_width = GetWidth() ;
1697 data.m_height = GetHeight() ;
6239ee05 1698 data.m_stride = GetBitmapData()->GetBytesPerRow() ;
1cb97a54 1699
6945b587 1700 return BeginRawAccess() ;
55e18dbe
VZ
1701}
1702
89954433 1703void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(dataBase))
55e18dbe 1704{
6945b587 1705 EndRawAccess() ;
55e18dbe
VZ
1706}
1707
1708void wxBitmap::UseAlpha()
1709{
1cb97a54
DS
1710 // remember that we are using alpha channel:
1711 // we'll need to create a proper mask in UngetRawData()
20b69855 1712 M_BITMAPDATA->UseAlpha( true );
55e18dbe 1713}