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