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