]> 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
pen.h depends from brush.h in compat mode
[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 wxASSERT_MSG( err == noErr , wxT("Error when constructing icon ref") );
569 DisposeHandle( (Handle) iconFamily ) ;
570 }
571
572 return m_iconRef ;
573}
574
575PicHandle wxBitmapRefData::GetPictHandle()
576{
577 if ( m_pictHandle == NULL )
578 {
579#ifndef __LP64__
580 GraphicsExportComponent exporter = 0;
581 OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePicture, &exporter);
582 if (noErr == err)
583 {
584 m_pictHandle = (PicHandle) NewHandle(0);
585 if ( m_pictHandle )
586 {
587 // QT does not correctly export the mask
588 // TODO if we get around to it create a synthetic PICT with the CopyBits and Mask commands
589 CGImageRef imageRef = CreateCGImage();
590 err = GraphicsExportSetInputCGImage( exporter, imageRef );
591 err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
592 err = GraphicsExportDoExport(exporter, NULL);
593 CGImageRelease( imageRef );
594
595 size_t handleSize = GetHandleSize( (Handle) m_pictHandle );
596 // the 512 bytes header is only needed for pict files, but not in memory
597 if ( handleSize >= 512 )
598 {
599 memmove( *m_pictHandle , (char*)(*m_pictHandle)+512, handleSize - 512 );
600 SetHandleSize( (Handle) m_pictHandle, handleSize - 512 );
601 }
602 }
603 CloseComponent( exporter );
604 }
605#endif
606 }
607
608 return m_pictHandle ;
609}
610
611CGImageRef wxBitmapRefData::CreateCGImage() const
612{
613 wxASSERT( m_ok ) ;
614 wxASSERT( m_rawAccessCount >= 0 ) ;
615 CGImageRef image ;
616 if ( m_rawAccessCount > 0 || m_cgImageRef == NULL )
617 {
618 if ( m_depth != 1 && m_bitmapMask == NULL )
619 {
620 if ( m_bitmapMask )
621 {
622 CGImageRef tempImage = CGBitmapContextCreateImage( m_hBitmap );
623 CGImageRef tempMask = CGBitmapContextCreateImage((CGContextRef) m_bitmapMask->GetHBITMAP() );
624 image = CGImageCreateWithMask( tempImage, tempMask );
625 CGImageRelease(tempMask);
626 CGImageRelease(tempImage);
627 }
628 else
629 image = CGBitmapContextCreateImage( m_hBitmap );
630 }
631 else
632 {
633 size_t imageSize = m_height * m_bytesPerRow ;
634 void * dataBuffer = m_memBuf.GetData() ;
635 int w = m_width ;
636 int h = m_height ;
637 CGImageAlphaInfo alphaInfo = kCGImageAlphaNoneSkipFirst ;
638 wxMemoryBuffer membuf;
639
640 if ( m_bitmapMask )
641 {
642 alphaInfo = kCGImageAlphaFirst ;
643 unsigned char *destalphastart = (unsigned char*) membuf.GetWriteBuf( imageSize ) ;
644 memcpy( destalphastart , dataBuffer , imageSize ) ;
645 unsigned char *sourcemaskstart = (unsigned char *) m_bitmapMask->GetRawAccess() ;
646 int maskrowbytes = m_bitmapMask->GetBytesPerRow() ;
647 for ( int y = 0 ; y < h ; ++y , destalphastart += m_bytesPerRow, sourcemaskstart += maskrowbytes)
648 {
649 unsigned char *sourcemask = sourcemaskstart ;
650 unsigned char *destalpha = destalphastart ;
651 for ( int x = 0 ; x < w ; ++x , sourcemask += kMaskBytesPerPixel , destalpha += 4 )
652 {
653 *destalpha = 0xFF - *sourcemask ;
654 }
655 }
656 membuf.UngetWriteBuf( imageSize );
657 }
658 else
659 {
660 if ( m_hasAlpha )
661 {
662#if wxMAC_USE_PREMULTIPLIED_ALPHA
663 alphaInfo = kCGImageAlphaPremultipliedFirst ;
664#else
665 alphaInfo = kCGImageAlphaFirst ;
666#endif
667 }
668
669 membuf = m_memBuf;
670 }
671
672 CGDataProviderRef dataProvider = NULL ;
673 if ( m_depth == 1 )
674 {
675 // TODO CHECK ALIGNMENT
676 wxMemoryBuffer maskBuf;
677 unsigned char * maskBufData = (unsigned char*) maskBuf.GetWriteBuf( m_width * m_height );
678 unsigned char * bufData = (unsigned char *) membuf.GetData() ;
679 // copy one color component
680 size_t i = 0;
681 for( int y = 0 ; y < m_height ; bufData+= m_bytesPerRow, ++y )
682 {
683 unsigned char *bufDataIter = bufData+3;
684 for ( int x = 0 ; x < m_width ; bufDataIter += 4, ++x, ++i )
685 {
686 maskBufData[i] = *bufDataIter;
687 }
688 }
689 maskBuf.UngetWriteBuf( m_width * m_height );
690
691 dataProvider =
692 wxMacCGDataProviderCreateWithMemoryBuffer( maskBuf );
693
694 image = ::CGImageMaskCreate( w, h, 8, 8, m_width , dataProvider, NULL, false );
695 }
696 else
697 {
698 CGColorSpaceRef colorSpace = wxMacGetGenericRGBColorSpace();
699 dataProvider = wxMacCGDataProviderCreateWithMemoryBuffer( membuf );
700 image =
701 ::CGImageCreate(
702 w, h, 8 , 32 , m_bytesPerRow , colorSpace, alphaInfo ,
703 dataProvider, NULL , false , kCGRenderingIntentDefault );
704 }
705 CGDataProviderRelease( dataProvider);
706 }
707 }
708 else
709 {
710 image = m_cgImageRef ;
711 CGImageRetain( image ) ;
712 }
713
714 if ( m_rawAccessCount == 0 && m_cgImageRef == NULL)
715 {
716 // we keep it for later use
717 m_cgImageRef = image ;
718 CGImageRetain( image ) ;
719 }
720
721 return image ;
722}
723
724CGContextRef wxBitmapRefData::GetBitmapContext() const
725{
726 return m_hBitmap;
727}
728
729void wxBitmapRefData::Free()
730{
731 wxASSERT_MSG( m_rawAccessCount == 0 , wxT("Bitmap still selected when destroyed") ) ;
732
733 if ( m_cgImageRef )
734 {
735 CGImageRelease( m_cgImageRef ) ;
736 m_cgImageRef = NULL ;
737 }
738
739 if ( m_iconRef )
740 {
741 ReleaseIconRef( m_iconRef ) ;
742 m_iconRef = NULL ;
743 }
744
745#ifndef __LP64__
746 if ( m_pictHandle )
747 {
748 KillPicture( m_pictHandle ) ;
749 m_pictHandle = NULL ;
750 }
751#endif
752
753 if ( m_hBitmap )
754 {
755 CGContextRelease(m_hBitmap);
756 m_hBitmap = NULL ;
757 }
758
759 if (m_bitmapMask)
760 {
761 delete m_bitmapMask;
762 m_bitmapMask = NULL;
763 }
764}
765
766wxBitmapRefData::~wxBitmapRefData()
767{
768 Free() ;
769}
770
771bool wxBitmap::CopyFromIcon(const wxIcon& icon)
772{
773 bool created = false ;
774 int w = icon.GetWidth() ;
775 int h = icon.GetHeight() ;
776
777 Create( icon.GetWidth() , icon.GetHeight() ) ;
778
779 if ( w == h && ( w == 16 || w == 32 || w == 48 || w == 128 ) )
780 {
781 IconFamilyHandle iconFamily = NULL ;
782 Handle imagehandle = NewHandle( 0 ) ;
783 Handle maskhandle = NewHandle( 0 ) ;
784
785 OSType maskType = 0;
786 OSType dataType = 0;
787 IconSelectorValue selector = 0 ;
788
789 switch (w)
790 {
791 case 128:
792 dataType = kThumbnail32BitData ;
793 maskType = kThumbnail8BitMask ;
794 selector = kSelectorAllAvailableData ;
795 break;
796
797 case 48:
798 dataType = kHuge32BitData ;
799 maskType = kHuge8BitMask ;
800 selector = kSelectorHuge32Bit | kSelectorHuge8BitMask ;
801 break;
802
803 case 32:
804 dataType = kLarge32BitData ;
805 maskType = kLarge8BitMask ;
806 selector = kSelectorLarge32Bit | kSelectorLarge8BitMask ;
807 break;
808
809 case 16:
810 dataType = kSmall32BitData ;
811 maskType = kSmall8BitMask ;
812 selector = kSelectorSmall32Bit | kSelectorSmall8BitMask ;
813 break;
814
815 default:
816 break;
817 }
818
819 OSStatus err = IconRefToIconFamily( MAC_WXHICON(icon.GetHICON()) , selector , &iconFamily ) ;
820
821 err = GetIconFamilyData( iconFamily , dataType , imagehandle ) ;
822 err = GetIconFamilyData( iconFamily , maskType , maskhandle ) ;
823 size_t imagehandlesize = GetHandleSize( imagehandle ) ;
824 size_t maskhandlesize = GetHandleSize( maskhandle ) ;
825
826 if ( imagehandlesize != 0 && maskhandlesize != 0 )
827 {
828 wxASSERT( GetHandleSize( imagehandle ) == w * 4 * h ) ;
829 wxASSERT( GetHandleSize( maskhandle ) == w * h ) ;
830
831 UseAlpha() ;
832
833 unsigned char *source = (unsigned char *) *imagehandle ;
834 unsigned char *sourcemask = (unsigned char *) *maskhandle ;
835 unsigned char* destination = (unsigned char*) BeginRawAccess() ;
836
837 for ( int y = 0 ; y < h ; ++y )
838 {
839 for ( int x = 0 ; x < w ; ++x )
840 {
841 unsigned char a = *sourcemask++;
842 *destination++ = a;
843 source++ ;
844#if wxMAC_USE_PREMULTIPLIED_ALPHA
845 *destination++ = ( (*source++) * a + 127 ) / 255;
846 *destination++ = ( (*source++) * a + 127 ) / 255;
847 *destination++ = ( (*source++) * a + 127 ) / 255;
848#else
849 *destination++ = *source++ ;
850 *destination++ = *source++ ;
851 *destination++ = *source++ ;
852#endif
853 }
854 }
855
856 EndRawAccess() ;
857 DisposeHandle( imagehandle ) ;
858 DisposeHandle( maskhandle ) ;
859 created = true ;
860 }
861
862 DisposeHandle( (Handle) iconFamily ) ;
863 }
864
865 if ( !created )
866 {
867 wxMemoryDC dc ;
868 dc.SelectObject( *this ) ;
869 dc.DrawIcon( icon , 0 , 0 ) ;
870 dc.SelectObject( wxNullBitmap ) ;
871 }
872
873 return true;
874}
875
876wxBitmap::wxBitmap()
877{
878}
879
880wxBitmap::~wxBitmap()
881{
882}
883
884wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
885{
886 wxBitmapRefData* bitmapRefData;
887
888 m_refData = bitmapRefData = new wxBitmapRefData( the_width , the_height , no_bits ) ;
889
890 if (bitmapRefData->IsOk())
891 {
892 if ( no_bits == 1 )
893 {
894 int linesize = ( the_width / (sizeof(unsigned char) * 8)) ;
895 if ( the_width % (sizeof(unsigned char) * 8) )
896 linesize += sizeof(unsigned char);
897
898 unsigned char* linestart = (unsigned char*) bits ;
899 unsigned char* destptr = (unsigned char*) BeginRawAccess() ;
900
901 for ( int y = 0 ; y < the_height ; ++y , linestart += linesize, destptr += M_BITMAPDATA->GetBytesPerRow() )
902 {
903 unsigned char* destination = destptr;
904 int index, bit, mask;
905
906 for ( int x = 0 ; x < the_width ; ++x )
907 {
908 index = x / 8 ;
909 bit = x % 8 ;
910 mask = 1 << bit ;
911
912 if ( linestart[index] & mask )
913 {
914 *destination++ = 0xFF ;
915 *destination++ = 0 ;
916 *destination++ = 0 ;
917 *destination++ = 0 ;
918 }
919 else
920 {
921 *destination++ = 0xFF ;
922 *destination++ = 0xFF ;
923 *destination++ = 0xFF ;
924 *destination++ = 0xFF ;
925 }
926 }
927 }
928
929 EndRawAccess() ;
930 }
931 else
932 {
933 wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
934 }
935 } /* bitmapRefData->IsOk() */
936}
937
938wxBitmap::wxBitmap(int w, int h, int d)
939{
940 (void)Create(w, h, d);
941}
942
943wxBitmap::wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth)
944{
945 (void) Create(data, type, width, height, depth);
946}
947
948wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
949{
950 LoadFile(filename, type);
951}
952
953wxGDIRefData* wxBitmap::CreateGDIRefData() const
954{
955 return new wxBitmapRefData;
956}
957
958wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
959{
960 return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
961}
962
963void * wxBitmap::GetRawAccess() const
964{
965 wxCHECK_MSG( Ok() , NULL , wxT("invalid bitmap") ) ;
966
967 return M_BITMAPDATA->GetRawAccess() ;
968}
969
970void * wxBitmap::BeginRawAccess()
971{
972 wxCHECK_MSG( Ok() , NULL , wxT("invalid bitmap") ) ;
973
974 return M_BITMAPDATA->BeginRawAccess() ;
975}
976
977void wxBitmap::EndRawAccess()
978{
979 wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
980
981 M_BITMAPDATA->EndRawAccess() ;
982}
983
984CGImageRef wxBitmap::CreateCGImage() const
985{
986 wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
987
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;
1003}
1004
1005wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
1006{
1007 wxCHECK_MSG( Ok() &&
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
1013 wxBitmap ret( rect.width, rect.height, GetDepth() );
1014 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
1015
1016 int destwidth = rect.width ;
1017 int destheight = rect.height ;
1018
1019 {
1020 unsigned char *sourcedata = (unsigned char*) GetRawAccess() ;
1021 unsigned char *destdata = (unsigned char*) ret.BeginRawAccess() ;
1022 wxASSERT( (sourcedata != NULL) && (destdata != NULL) ) ;
1023
1024 int sourcelinesize = GetBitmapData()->GetBytesPerRow() ;
1025 int destlinesize = ret.GetBitmapData()->GetBytesPerRow() ;
1026 unsigned char *source = sourcedata + rect.x * 4 + rect.y * sourcelinesize ;
1027 unsigned char *dest = destdata ;
1028
1029 for (int yy = 0; yy < destheight; ++yy, source += sourcelinesize , dest += destlinesize)
1030 {
1031 memcpy( dest , source , destlinesize ) ;
1032 }
1033 }
1034
1035 ret.EndRawAccess() ;
1036
1037 if ( M_BITMAPDATA->m_bitmapMask )
1038 {
1039 wxMemoryBuffer maskbuf ;
1040 int rowBytes = GetBestBytesPerRow( destwidth * kMaskBytesPerPixel );
1041 size_t maskbufsize = rowBytes * destheight ;
1042
1043 int sourcelinesize = M_BITMAPDATA->m_bitmapMask->GetBytesPerRow() ;
1044 int destlinesize = rowBytes ;
1045
1046 unsigned char *source = (unsigned char *) M_BITMAPDATA->m_bitmapMask->GetRawAccess() ;
1047 unsigned char *destdata = (unsigned char * ) maskbuf.GetWriteBuf( maskbufsize ) ;
1048 wxASSERT( (source != NULL) && (destdata != NULL) ) ;
1049
1050 source += rect.x * kMaskBytesPerPixel + rect.y * sourcelinesize ;
1051 unsigned char *dest = destdata ;
1052
1053 for (int yy = 0; yy < destheight; ++yy, source += sourcelinesize , dest += destlinesize)
1054 {
1055 memcpy( dest , source , destlinesize ) ;
1056 }
1057
1058 maskbuf.UngetWriteBuf( maskbufsize ) ;
1059 ret.SetMask( new wxMask( maskbuf , destwidth , destheight , rowBytes ) ) ;
1060 }
1061 else if ( HasAlpha() )
1062 ret.UseAlpha() ;
1063
1064 return ret;
1065}
1066
1067bool wxBitmap::Create(int w, int h, int d)
1068{
1069 UnRef();
1070
1071 if ( d < 0 )
1072 d = wxDisplayDepth() ;
1073
1074 m_refData = new wxBitmapRefData( w , h , d );
1075
1076 return M_BITMAPDATA->IsOk() ;
1077}
1078
1079bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
1080{
1081 UnRef();
1082
1083 wxBitmapHandler *handler = FindHandler(type);
1084
1085 if ( handler )
1086 {
1087 m_refData = new wxBitmapRefData;
1088
1089 return handler->LoadFile(this, filename, type, -1, -1);
1090 }
1091 else
1092 {
1093#if wxUSE_IMAGE
1094 wxImage loadimage(filename, type);
1095 if (loadimage.Ok())
1096 {
1097 *this = loadimage;
1098
1099 return true;
1100 }
1101#endif
1102 }
1103
1104 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
1105
1106 return false;
1107}
1108
1109bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height, int depth)
1110{
1111 UnRef();
1112
1113 m_refData = new wxBitmapRefData;
1114
1115 wxBitmapHandler *handler = FindHandler(type);
1116
1117 if ( handler == NULL )
1118 {
1119 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
1120
1121 return false;
1122 }
1123
1124 return handler->Create(this, data, type, width, height, depth);
1125}
1126
1127#if wxUSE_IMAGE
1128
1129wxBitmap::wxBitmap(const wxImage& image, int depth)
1130{
1131 wxCHECK_RET( image.Ok(), wxT("invalid image") );
1132
1133 // width and height of the device-dependent bitmap
1134 int width = image.GetWidth();
1135 int height = image.GetHeight();
1136
1137 wxBitmapRefData* bitmapRefData;
1138
1139 m_refData = bitmapRefData = new wxBitmapRefData( width , height , depth ) ;
1140
1141 if ( bitmapRefData->IsOk())
1142 {
1143 // Create picture
1144
1145 bool hasAlpha = false ;
1146
1147 if ( image.HasMask() )
1148 {
1149 // takes precedence, don't mix with alpha info
1150 }
1151 else
1152 {
1153 hasAlpha = image.HasAlpha() ;
1154 }
1155
1156 if ( hasAlpha )
1157 UseAlpha() ;
1158
1159 unsigned char* destinationstart = (unsigned char*) BeginRawAccess() ;
1160 register unsigned char* data = image.GetData();
1161 if ( destinationstart != NULL && data != NULL )
1162 {
1163 const unsigned char *alpha = hasAlpha ? image.GetAlpha() : NULL ;
1164 for (int y = 0; y < height; destinationstart += M_BITMAPDATA->GetBytesPerRow(), y++)
1165 {
1166 unsigned char * destination = destinationstart;
1167 for (int x = 0; x < width; x++)
1168 {
1169 if ( hasAlpha )
1170 {
1171 const unsigned char a = *alpha++;
1172 *destination++ = a ;
1173
1174 #if wxMAC_USE_PREMULTIPLIED_ALPHA
1175 *destination++ = ((*data++) * a + 127) / 255 ;
1176 *destination++ = ((*data++) * a + 127) / 255 ;
1177 *destination++ = ((*data++) * a + 127) / 255 ;
1178 #else
1179 *destination++ = *data++ ;
1180 *destination++ = *data++ ;
1181 *destination++ = *data++ ;
1182 #endif
1183 }
1184 else
1185 {
1186 *destination++ = 0xFF ;
1187 *destination++ = *data++ ;
1188 *destination++ = *data++ ;
1189 *destination++ = *data++ ;
1190 }
1191 }
1192 }
1193
1194 EndRawAccess() ;
1195 }
1196 if ( image.HasMask() )
1197 SetMask( new wxMask( *this , wxColour( image.GetMaskRed() , image.GetMaskGreen() , image.GetMaskBlue() ) ) ) ;
1198 } /* bitmapRefData->IsOk() */
1199}
1200
1201wxImage wxBitmap::ConvertToImage() const
1202{
1203 wxImage image;
1204
1205 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
1206
1207 // create an wxImage object
1208 int width = GetWidth();
1209 int height = GetHeight();
1210 image.Create( width, height );
1211
1212 unsigned char *data = image.GetData();
1213 wxCHECK_MSG( data, wxNullImage, wxT("Could not allocate data for image") );
1214
1215 unsigned char* sourcestart = (unsigned char*) GetRawAccess() ;
1216
1217 bool hasAlpha = false ;
1218 bool hasMask = false ;
1219 int maskBytesPerRow = 0 ;
1220 unsigned char *alpha = NULL ;
1221 unsigned char *mask = NULL ;
1222
1223 if ( HasAlpha() )
1224 hasAlpha = true ;
1225
1226 if ( GetMask() )
1227 {
1228 hasMask = true ;
1229 mask = (unsigned char*) GetMask()->GetRawAccess() ;
1230 maskBytesPerRow = GetMask()->GetBytesPerRow() ;
1231 }
1232
1233 if ( hasAlpha )
1234 {
1235 image.SetAlpha() ;
1236 alpha = image.GetAlpha() ;
1237 }
1238
1239 int index = 0;
1240
1241 // The following masking algorithm is the same as well in msw/gtk:
1242 // the colour used as transparent one in wxImage and the one it is
1243 // replaced with when it actually occurs in the bitmap
1244 static const int MASK_RED = 1;
1245 static const int MASK_GREEN = 2;
1246 static const int MASK_BLUE = 3;
1247 static const int MASK_BLUE_REPLACEMENT = 2;
1248
1249 for (int yy = 0; yy < height; yy++ , sourcestart += M_BITMAPDATA->GetBytesPerRow() , mask += maskBytesPerRow )
1250 {
1251 unsigned char * maskp = mask ;
1252 unsigned char * source = sourcestart;
1253 unsigned char a, r, g, b;
1254 long color;
1255
1256 for (int xx = 0; xx < width; xx++)
1257 {
1258 color = *((long*) source) ;
1259#ifdef WORDS_BIGENDIAN
1260 a = ((color&0xFF000000) >> 24) ;
1261 r = ((color&0x00FF0000) >> 16) ;
1262 g = ((color&0x0000FF00) >> 8) ;
1263 b = (color&0x000000FF);
1264#else
1265 b = ((color&0xFF000000) >> 24) ;
1266 g = ((color&0x00FF0000) >> 16) ;
1267 r = ((color&0x0000FF00) >> 8) ;
1268 a = (color&0x000000FF);
1269#endif
1270 if ( hasMask )
1271 {
1272 if ( *maskp++ == 0xFF )
1273 {
1274 r = MASK_RED ;
1275 g = MASK_GREEN ;
1276 b = MASK_BLUE ;
1277 }
1278 else if ( r == MASK_RED && g == MASK_GREEN && b == MASK_BLUE )
1279 b = MASK_BLUE_REPLACEMENT ;
1280 }
1281 else if ( hasAlpha )
1282 {
1283 *alpha++ = a ;
1284#if wxMAC_USE_PREMULTIPLIED_ALPHA
1285 // this must be non-premultiplied data
1286 if ( a != 0xFF && a!= 0 )
1287 {
1288 r = r * 255 / a;
1289 g = g * 255 / a;
1290 b = b * 255 / a;
1291 }
1292#endif
1293 }
1294
1295 data[index ] = r ;
1296 data[index + 1] = g ;
1297 data[index + 2] = b ;
1298
1299 index += 3;
1300 source += 4 ;
1301 }
1302 }
1303
1304 if ( hasMask )
1305 image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
1306
1307 return image;
1308}
1309
1310#endif //wxUSE_IMAGE
1311
1312bool wxBitmap::SaveFile( const wxString& filename,
1313 wxBitmapType type, const wxPalette *palette ) const
1314{
1315 bool success = false;
1316 wxBitmapHandler *handler = FindHandler(type);
1317
1318 if ( handler )
1319 {
1320 success = handler->SaveFile(this, filename, type, palette);
1321 }
1322 else
1323 {
1324#if wxUSE_IMAGE
1325 wxImage image = ConvertToImage();
1326 success = image.SaveFile(filename, type);
1327#else
1328 wxLogWarning(wxT("no bitmap handler for type %d defined."), type);
1329#endif
1330 }
1331
1332 return success;
1333}
1334
1335int wxBitmap::GetHeight() const
1336{
1337 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1338
1339 return M_BITMAPDATA->GetHeight();
1340}
1341
1342int wxBitmap::GetWidth() const
1343{
1344 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1345
1346 return M_BITMAPDATA->GetWidth() ;
1347}
1348
1349int wxBitmap::GetDepth() const
1350{
1351 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
1352
1353 return M_BITMAPDATA->GetDepth();
1354}
1355
1356wxMask *wxBitmap::GetMask() const
1357{
1358 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
1359
1360 return M_BITMAPDATA->m_bitmapMask;
1361}
1362
1363bool wxBitmap::HasAlpha() const
1364{
1365 wxCHECK_MSG( Ok(), false , wxT("invalid bitmap") );
1366
1367 return M_BITMAPDATA->HasAlpha() ;
1368}
1369
1370void wxBitmap::SetWidth(int w)
1371{
1372 AllocExclusive();
1373 M_BITMAPDATA->SetWidth(w);
1374}
1375
1376void wxBitmap::SetHeight(int h)
1377{
1378 AllocExclusive();
1379 M_BITMAPDATA->SetHeight(h);
1380}
1381
1382void wxBitmap::SetDepth(int d)
1383{
1384 AllocExclusive();
1385 M_BITMAPDATA->SetDepth(d);
1386}
1387
1388void wxBitmap::SetOk(bool isOk)
1389{
1390 AllocExclusive();
1391 M_BITMAPDATA->SetOk(isOk);
1392}
1393
1394#if wxUSE_PALETTE
1395wxPalette *wxBitmap::GetPalette() const
1396{
1397 wxCHECK_MSG( Ok(), NULL, wxT("Invalid bitmap GetPalette()") );
1398
1399 return &M_BITMAPDATA->m_bitmapPalette;
1400}
1401
1402void wxBitmap::SetPalette(const wxPalette& palette)
1403{
1404 AllocExclusive();
1405 M_BITMAPDATA->m_bitmapPalette = palette ;
1406}
1407#endif // wxUSE_PALETTE
1408
1409void wxBitmap::SetMask(wxMask *mask)
1410{
1411 AllocExclusive();
1412 // Remove existing mask if there is one.
1413 delete M_BITMAPDATA->m_bitmapMask;
1414
1415 M_BITMAPDATA->m_bitmapMask = mask ;
1416}
1417
1418WXHBITMAP wxBitmap::GetHBITMAP(WXHBITMAP* mask) const
1419{
1420 wxUnusedVar(mask);
1421
1422 return WXHBITMAP(M_BITMAPDATA->GetBitmapContext());
1423}
1424
1425// ----------------------------------------------------------------------------
1426// wxMask
1427// ----------------------------------------------------------------------------
1428
1429wxMask::wxMask()
1430{
1431 Init() ;
1432}
1433
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();
1445 memcpy( dest, source, size );
1446 m_memBuf.UngetWriteBuf( size ) ;
1447 RealizeNative() ;
1448}
1449
1450// Construct a mask from a bitmap and a colour indicating
1451// the transparent area
1452wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
1453{
1454 Init() ;
1455 Create( bitmap, colour );
1456}
1457
1458// Construct a mask from a mono bitmap (copies the bitmap).
1459wxMask::wxMask( const wxBitmap& bitmap )
1460{
1461 Init() ;
1462 Create( bitmap );
1463}
1464
1465// Construct a mask from a mono bitmap (copies the bitmap).
1466
1467wxMask::wxMask( const wxMemoryBuffer& data, int width , int height , int bytesPerRow )
1468{
1469 Init() ;
1470 Create( data, width , height , bytesPerRow );
1471}
1472
1473wxMask::~wxMask()
1474{
1475 if ( m_maskBitmap )
1476 {
1477 CGContextRelease( (CGContextRef) m_maskBitmap );
1478 m_maskBitmap = NULL ;
1479 }
1480}
1481
1482void wxMask::Init()
1483{
1484 m_width = m_height = m_bytesPerRow = 0 ;
1485 m_maskBitmap = NULL ;
1486}
1487
1488void *wxMask::GetRawAccess() const
1489{
1490 return m_memBuf.GetData() ;
1491}
1492
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
1495
1496void wxMask::RealizeNative()
1497{
1498 if ( m_maskBitmap )
1499 {
1500 CGContextRelease( (CGContextRef) m_maskBitmap );
1501 m_maskBitmap = NULL ;
1502 }
1503
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") ) ;
1513}
1514
1515// Create a mask from a mono bitmap (copies the bitmap).
1516
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 ;
1523
1524 wxASSERT( data.GetDataLen() == (size_t)(height * bytesPerRow) ) ;
1525
1526 RealizeNative() ;
1527
1528 return true ;
1529}
1530
1531// Create a mask from a mono bitmap (copies the bitmap).
1532bool wxMask::Create(const wxBitmap& bitmap)
1533{
1534 m_width = bitmap.GetWidth() ;
1535 m_height = bitmap.GetHeight() ;
1536 m_bytesPerRow = GetBestBytesPerRow( m_width * kMaskBytesPerPixel ) ;
1537
1538 size_t size = m_bytesPerRow * m_height ;
1539 unsigned char * destdatabase = (unsigned char*) m_memBuf.GetWriteBuf( size ) ;
1540 wxASSERT( destdatabase != NULL ) ;
1541
1542 memset( destdatabase , 0 , size ) ;
1543 unsigned char * srcdata = (unsigned char*) bitmap.GetRawAccess() ;
1544
1545 for ( int y = 0 ; y < m_height ; ++y , destdatabase += m_bytesPerRow )
1546 {
1547 unsigned char *destdata = destdatabase ;
1548 unsigned char r, g, b;
1549
1550 for ( int x = 0 ; x < m_width ; ++x )
1551 {
1552 srcdata++ ;
1553 r = *srcdata++ ;
1554 g = *srcdata++ ;
1555 b = *srcdata++ ;
1556
1557 if ( ( r + g + b ) > 0x10 )
1558 *destdata++ = 0xFF ;
1559 else
1560 *destdata++ = 0x00 ;
1561 }
1562 }
1563
1564 m_memBuf.UngetWriteBuf( size ) ;
1565 RealizeNative() ;
1566
1567 return true;
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{
1574 m_width = bitmap.GetWidth() ;
1575 m_height = bitmap.GetHeight() ;
1576 m_bytesPerRow = GetBestBytesPerRow( m_width * kMaskBytesPerPixel ) ;
1577
1578 size_t size = m_bytesPerRow * m_height ;
1579 unsigned char * destdatabase = (unsigned char*) m_memBuf.GetWriteBuf( size ) ;
1580 wxASSERT( destdatabase != NULL ) ;
1581
1582 memset( destdatabase , 0 , size ) ;
1583 unsigned char * srcdatabase = (unsigned char*) bitmap.GetRawAccess() ;
1584 size_t sourceBytesRow = bitmap.GetBitmapData()->GetBytesPerRow();
1585
1586 for ( int y = 0 ; y < m_height ; ++y , srcdatabase+= sourceBytesRow, destdatabase += m_bytesPerRow)
1587 {
1588 unsigned char *srcdata = srcdatabase ;
1589 unsigned char *destdata = destdatabase ;
1590 unsigned char r, g, b;
1591
1592 for ( int x = 0 ; x < m_width ; ++x )
1593 {
1594 srcdata++ ;
1595 r = *srcdata++ ;
1596 g = *srcdata++ ;
1597 b = *srcdata++ ;
1598
1599 if ( colour == wxColour( r , g , b ) )
1600 *destdata++ = 0xFF ;
1601 else
1602 *destdata++ = 0x00 ;
1603 }
1604 }
1605
1606 m_memBuf.UngetWriteBuf( size ) ;
1607 RealizeNative() ;
1608
1609 return true;
1610}
1611
1612WXHBITMAP wxMask::GetHBITMAP() const
1613{
1614 return m_maskBitmap ;
1615}
1616
1617// ----------------------------------------------------------------------------
1618// wxBitmapHandler
1619// ----------------------------------------------------------------------------
1620
1621IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
1622
1623// ----------------------------------------------------------------------------
1624// Standard Handlers
1625// ----------------------------------------------------------------------------
1626
1627#ifndef __LP64__
1628
1629class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
1630{
1631 DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)
1632
1633public:
1634 inline wxPICTResourceHandler()
1635 {
1636 SetName(wxT("Macintosh Pict resource"));
1637 SetExtension(wxEmptyString);
1638 SetType(wxBITMAP_TYPE_PICT_RESOURCE);
1639 };
1640
1641 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1642 int desiredWidth, int desiredHeight);
1643};
1644
1645IMPLEMENT_DYNAMIC_CLASS(wxPICTResourceHandler, wxBitmapHandler)
1646
1647
1648bool wxPICTResourceHandler::LoadFile(wxBitmap *bitmap,
1649 const wxString& name,
1650 long WXUNUSED(flags),
1651 int WXUNUSED(desiredWidth),
1652 int WXUNUSED(desiredHeight))
1653{
1654#if wxUSE_METAFILE
1655 Str255 theName ;
1656 wxMacStringToPascal( name , theName ) ;
1657
1658 PicHandle thePict = (PicHandle ) GetNamedResource( 'PICT' , theName ) ;
1659 if ( thePict )
1660 {
1661 wxMetafile mf ;
1662
1663 mf.SetPICT( thePict ) ;
1664 bitmap->Create( mf.GetWidth() , mf.GetHeight() ) ;
1665 wxMemoryDC dc ;
1666 dc.SelectObject( *bitmap ) ;
1667 mf.Play( &dc ) ;
1668 dc.SelectObject( wxNullBitmap ) ;
1669
1670 return true ;
1671 }
1672#endif
1673
1674 return false ;
1675}
1676#endif
1677
1678void wxBitmap::InitStandardHandlers()
1679{
1680#ifndef __LP64__
1681 AddHandler( new wxPICTResourceHandler ) ;
1682#endif
1683 AddHandler( new wxICONResourceHandler ) ;
1684}
1685
1686// ----------------------------------------------------------------------------
1687// raw bitmap access support
1688// ----------------------------------------------------------------------------
1689
1690void *wxBitmap::GetRawData(wxPixelDataBase& data, int WXUNUSED(bpp))
1691{
1692 if ( !Ok() )
1693 // no bitmap, no data (raw or otherwise)
1694 return NULL;
1695
1696 data.m_width = GetWidth() ;
1697 data.m_height = GetHeight() ;
1698 data.m_stride = GetBitmapData()->GetBytesPerRow() ;
1699
1700 return BeginRawAccess() ;
1701}
1702
1703void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(dataBase))
1704{
1705 EndRawAccess() ;
1706}
1707
1708void wxBitmap::UseAlpha()
1709{
1710 // remember that we are using alpha channel:
1711 // we'll need to create a proper mask in UngetRawData()
1712 M_BITMAPDATA->UseAlpha( true );
1713}
wxWidgets (Impactor)