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