]> git.saurik.com Git - wxWidgets.git/blob - src/cocoa/bitmap.mm
added possibility to throw different objects and crash directly from the main frame...
[wxWidgets.git] / src / cocoa / bitmap.mm
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/cocoa/bitmap.cpp
3 // Purpose: wxBitmap
4 // Author: David Elliott
5 // Modified by:
6 // Created: 2003/07/19
7 // RCS-ID: $Id$
8 // Copyright: (c) 2003 David Elliott
9 // Licence: wxWidgets licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13 #ifndef WX_PRECOMP
14 #include "wx/log.h"
15 #include "wx/utils.h"
16 #include "wx/palette.h"
17 #include "wx/icon.h"
18 #include "wx/colour.h"
19 #endif //WX_PRECOMP
20 #include "wx/bitmap.h"
21 #include "wx/image.h"
22 #include "wx/xpmdecod.h"
23 #include "wx/rawbmp.h"
24
25 #include "wx/cocoa/autorelease.h"
26 #include "wx/cocoa/string.h"
27
28 #import <AppKit/NSBitmapImageRep.h>
29 #import <AppKit/NSGraphics.h>
30 #import <AppKit/NSImage.h>
31 #import <AppKit/NSColor.h>
32
33 // ========================================================================
34 // wxBitmapRefData
35 // ========================================================================
36 class wxBitmapRefData: public wxGDIRefData
37 {
38 friend class wxBitmap;
39 public:
40 wxBitmapRefData();
41 wxBitmapRefData( const wxBitmapRefData& data );
42 virtual ~wxBitmapRefData();
43
44 protected:
45 int m_width;
46 int m_height;
47 int m_depth;
48 bool m_ok;
49 int m_numColors;
50 wxPalette m_bitmapPalette;
51 int m_quality;
52 WX_NSBitmapImageRep m_cocoaNSBitmapImageRep;
53 wxMask *m_bitmapMask; // Optional mask
54 };
55
56 #define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
57
58 wxBitmapRefData::wxBitmapRefData()
59 {
60 m_ok = FALSE;
61 m_width = 0;
62 m_height = 0;
63 m_depth = 0;
64 m_quality = 0;
65 m_numColors = 0;
66 m_cocoaNSBitmapImageRep = nil;
67 m_bitmapMask = NULL;
68 }
69
70 wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
71 {
72 m_width = data.m_width;
73 m_height = data.m_height;
74 m_depth = data.m_depth;
75 m_ok = data.m_ok;
76 m_numColors = data.m_numColors;
77 m_bitmapPalette = data.m_bitmapPalette;
78 m_quality = data.m_quality;
79 m_cocoaNSBitmapImageRep = [data.m_cocoaNSBitmapImageRep copyWithZone:nil];
80 m_bitmapMask = data.m_bitmapMask?new wxMask(*data.m_bitmapMask):NULL;
81 }
82
83 wxBitmapRefData::~wxBitmapRefData()
84 {
85 [m_cocoaNSBitmapImageRep release];
86 m_cocoaNSBitmapImageRep = NULL;
87
88 delete m_bitmapMask;
89 m_bitmapMask = NULL;
90 }
91
92 // ========================================================================
93 // wxBitmap
94 // ========================================================================
95 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
96
97 wxBitmap::wxBitmap()
98 {
99 m_refData = NULL;
100 }
101
102 wxBitmap::~wxBitmap()
103 {
104 }
105
106 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
107 {
108 m_refData = new wxBitmapRefData;
109
110 M_BITMAPDATA->m_width = the_width ;
111 M_BITMAPDATA->m_height = the_height ;
112 M_BITMAPDATA->m_depth = no_bits ;
113 M_BITMAPDATA->m_numColors = 0;
114
115 /* TODO: create the bitmap from data */
116 }
117
118 wxBitmap::wxBitmap(int w, int h, int d)
119 {
120 (void)Create(w, h, d);
121 }
122
123 wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)
124 {
125 (void) Create(data, type, width, height, depth);
126 }
127
128 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
129 {
130 LoadFile(filename, type);
131 }
132
133 wxObjectRefData *wxBitmap::CreateRefData() const
134 {
135 return new wxBitmapRefData;
136 }
137
138 wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
139 {
140 return new wxBitmapRefData(*(wxBitmapRefData*)data);
141 }
142
143 WX_NSBitmapImageRep wxBitmap::GetNSBitmapImageRep()
144 {
145 if(!M_BITMAPDATA)
146 return NULL;
147 return M_BITMAPDATA->m_cocoaNSBitmapImageRep;
148 }
149
150 WX_NSImage wxBitmap::GetNSImage(bool useMask) const
151 {
152 if(!Ok())
153 return nil;
154 NSImage *nsimage = [[[NSImage alloc]
155 initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];
156 if(!nsimage)
157 return nil;
158 [nsimage addRepresentation: M_BITMAPDATA->m_cocoaNSBitmapImageRep];
159 if(useMask && GetMask())
160 {
161 // Show before/after to prove that the bitmap itself is not changed
162 // even though we just composited onto the NSImage
163 wxLogTrace(wxTRACE_COCOA,wxT("Before: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
164 NSImage *maskImage = [[NSImage alloc]
165 initWithSize:NSMakeSize(GetWidth(), GetHeight())];
166 [maskImage addRepresentation: GetMask()->GetNSBitmapImageRep()];
167 [nsimage lockFocus];
168 [maskImage compositeToPoint:NSZeroPoint operation:NSCompositeDestinationIn];
169 [nsimage unlockFocus];
170 [maskImage release];
171 wxLogTrace(wxTRACE_COCOA,wxT("After: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
172 }
173 return nsimage;
174 }
175
176 void wxBitmap::SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep)
177 {
178 if(!M_BITMAPDATA)
179 return;
180 // NOTE: No checking is done to make sure width/height agree
181 [bitmapImageRep retain];
182 [M_BITMAPDATA->m_cocoaNSBitmapImageRep release];
183 M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImageRep;
184 }
185
186 void wxBitmap::SetWidth(int w)
187 {
188 if (!M_BITMAPDATA)
189 m_refData = new wxBitmapRefData;
190
191 M_BITMAPDATA->m_width = w;
192 }
193
194 void wxBitmap::SetHeight(int h)
195 {
196 if (!M_BITMAPDATA)
197 m_refData = new wxBitmapRefData;
198
199 M_BITMAPDATA->m_height = h;
200 }
201
202 void wxBitmap::SetDepth(int d)
203 {
204 if (!M_BITMAPDATA)
205 m_refData = new wxBitmapRefData;
206
207 M_BITMAPDATA->m_depth = d;
208 }
209
210 void wxBitmap::SetQuality(int q)
211 {
212 if (!M_BITMAPDATA)
213 m_refData = new wxBitmapRefData;
214
215 M_BITMAPDATA->m_quality = q;
216 }
217
218 void wxBitmap::SetOk(bool isOk)
219 {
220 if (!M_BITMAPDATA)
221 m_refData = new wxBitmapRefData;
222
223 M_BITMAPDATA->m_ok = isOk;
224 }
225
226 void wxBitmap::SetPalette(const wxPalette& palette)
227 {
228 if (!M_BITMAPDATA)
229 m_refData = new wxBitmapRefData;
230
231 M_BITMAPDATA->m_bitmapPalette = palette ;
232 }
233
234 void wxBitmap::SetMask(wxMask *mask)
235 {
236 if (!M_BITMAPDATA)
237 m_refData = new wxBitmapRefData;
238
239 M_BITMAPDATA->m_bitmapMask = mask ;
240 }
241
242 bool wxBitmap::Ok() const
243 {
244 return m_refData && M_BITMAPDATA->m_ok;
245 }
246
247 wxPalette* wxBitmap::GetPalette() const
248 {
249 if(!m_refData)
250 return NULL;
251 return &M_BITMAPDATA->m_bitmapPalette;
252 }
253
254 wxMask* wxBitmap::GetMask() const
255 {
256 if(!m_refData)
257 return NULL;
258 return M_BITMAPDATA->m_bitmapMask;
259 }
260
261 int wxBitmap::GetDepth() const
262 {
263 if(!m_refData)
264 return 0;
265 return M_BITMAPDATA->m_depth;
266 }
267
268 int wxBitmap::GetWidth() const
269 {
270 if(!m_refData)
271 return 0;
272 return M_BITMAPDATA->m_width;
273 }
274
275 int wxBitmap::GetHeight() const
276 {
277 if(!m_refData)
278 return 0;
279 return M_BITMAPDATA->m_height;
280 }
281
282 bool wxBitmap::Create(int w, int h, int d)
283 {
284 UnRef();
285
286 m_refData = new wxBitmapRefData;
287
288 M_BITMAPDATA->m_width = w;
289 M_BITMAPDATA->m_height = h;
290 M_BITMAPDATA->m_depth = d;
291
292 /* TODO: create new bitmap */
293 M_BITMAPDATA->m_cocoaNSBitmapImageRep = [[NSBitmapImageRep alloc]
294 initWithBitmapDataPlanes: NULL
295 pixelsWide: w
296 pixelsHigh: h
297 bitsPerSample: 8
298 samplesPerPixel: 3
299 hasAlpha: NO
300 isPlanar: NO
301 colorSpaceName: NSCalibratedRGBColorSpace
302 bytesPerRow: 0
303 bitsPerPixel: 0];
304
305 wxLogTrace(wxTRACE_COCOA,wxT("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p"), M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
306 M_BITMAPDATA->m_ok = true;
307 M_BITMAPDATA->m_numColors = 0;
308 M_BITMAPDATA->m_quality = 0;
309 M_BITMAPDATA->m_bitmapMask = NULL;
310
311 return M_BITMAPDATA->m_ok;
312 }
313
314 bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
315 {
316 wxAutoNSAutoreleasePool pool;
317 UnRef();
318
319 m_refData = new wxBitmapRefData;
320
321 NSBitmapImageRep *imageRep = [NSBitmapImageRep
322 imageRepWithContentsOfFile:wxNSStringWithWxString(filename)];
323
324 if(imageRep)
325 {
326 M_BITMAPDATA->m_width = [imageRep pixelsWide];
327 M_BITMAPDATA->m_height = [imageRep pixelsHigh];
328 M_BITMAPDATA->m_depth = 24; // FIXME
329 M_BITMAPDATA->m_ok = true;
330 M_BITMAPDATA->m_numColors = 0;
331 M_BITMAPDATA->m_quality = 0;
332 M_BITMAPDATA->m_cocoaNSBitmapImageRep = [imageRep retain];
333 M_BITMAPDATA->m_bitmapMask = NULL;
334 return true;
335 }
336 wxImage image;
337 if(!image.LoadFile(filename,type))
338 return false;
339 if(!image.Ok())
340 return false;
341 *this = wxBitmap(image);
342 return true;
343 }
344
345 bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
346 {
347 UnRef();
348
349 m_refData = new wxBitmapRefData;
350
351 return false;
352 }
353
354 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
355 {
356 return false;
357 }
358
359 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
360 {
361 UnRef();
362 if(!icon.GetNSImage());
363 [icon.GetNSImage() lockFocus];
364 NSRect imageRect;
365 imageRect.origin.x = imageRect.origin.y = 0.0;
366 imageRect.size = [icon.GetNSImage() size];
367 NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
368 [icon.GetNSImage() unlockFocus];
369 if(!newBitmapRep)
370 return false;
371 m_refData = new wxBitmapRefData;
372 M_BITMAPDATA->m_cocoaNSBitmapImageRep = newBitmapRep;
373 M_BITMAPDATA->m_width = [newBitmapRep pixelsWide];
374 M_BITMAPDATA->m_height = [newBitmapRep pixelsHigh];
375 M_BITMAPDATA->m_depth = [newBitmapRep bitsPerSample]*[newBitmapRep samplesPerPixel];
376 M_BITMAPDATA->m_ok = true;
377 M_BITMAPDATA->m_numColors = 0;
378 M_BITMAPDATA->m_quality = 0;
379 M_BITMAPDATA->m_bitmapMask = NULL;
380 return true;
381 }
382
383 wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
384 {
385 return wxNullBitmap;
386 }
387
388 wxImage wxBitmap::ConvertToImage() const
389 {
390 wxAutoNSAutoreleasePool pool;
391 if(!Ok())
392 return /*wxImage(5,5)*/wxNullImage;
393 NSImage *nsimage = GetNSImage(false /* don't use mask */);
394 wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
395 [nsimage lockFocus];
396 for(int i=0; i < M_BITMAPDATA->m_width; i++)
397 {
398 // Don't let the pool get too big as you'll notice we're creating
399 // two autoreleased NSColor objects with every iteration.
400 wxAutoNSAutoreleasePool loopPool;
401 for(int j=0; j < M_BITMAPDATA->m_height; j++)
402 {
403 NSColor *pixelColor = NSReadPixel(NSMakePoint(i,M_BITMAPDATA->m_height - j - 1));
404 NSColor *color = [pixelColor colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
405 newImage.SetRGB(i,j,int([color redComponent]*255.0), int([color greenComponent]*255.0), int([color blueComponent]*255.0));
406 }
407 }
408 [nsimage unlockFocus];
409 return newImage;
410 }
411
412 bool wxBitmap::CreateFromXpm(const char **xpm)
413 {
414 #if wxUSE_IMAGE && wxUSE_XPM
415 UnRef();
416
417 wxCHECK_MSG( xpm, false, wxT("invalid XPM data") )
418
419 wxXPMDecoder decoder;
420 wxImage img = decoder.ReadData(xpm);
421 wxCHECK_MSG( img.Ok(), false, wxT("invalid XPM data") )
422
423 *this = wxBitmap(img);
424 return true;
425 #else
426 return false;
427 #endif
428 }
429
430 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
431 {
432 UnRef();
433
434 wxCHECK_MSG(image.Ok(), false, wxT("invalid image"));
435 wxCHECK_MSG(depth == -1 || depth == 1, false, wxT("invalid bitmap depth"));
436
437 m_refData = new wxBitmapRefData();
438
439 M_BITMAPDATA->m_width = image.GetWidth();
440 M_BITMAPDATA->m_height = image.GetHeight();
441 NSBitmapImageRep *bitmapImage = [[NSBitmapImageRep alloc]
442 initWithBitmapDataPlanes: NULL
443 pixelsWide: image.GetWidth()
444 pixelsHigh: image.GetHeight()
445 bitsPerSample: 8
446 samplesPerPixel: 3
447 hasAlpha: NO
448 isPlanar: NO
449 colorSpaceName: NSCalibratedRGBColorSpace
450 bytesPerRow: 0
451 bitsPerPixel: 0];
452
453 const int numBytes = image.GetWidth()*image.GetHeight()*3;
454 memcpy([bitmapImage bitmapData], image.GetData(), numBytes);
455 // TODO: Alpha and convert to desired depth
456 M_BITMAPDATA->m_depth = 24;
457 M_BITMAPDATA->m_ok = true;
458 M_BITMAPDATA->m_numColors = 0;
459 M_BITMAPDATA->m_quality = 0;
460 M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImage;
461 M_BITMAPDATA->m_bitmapMask = new wxMask(*this,wxColour(image.GetMaskRed(),image.GetMaskGreen(),image.GetMaskBlue()));
462 return true;
463 }
464
465 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
466 {
467 if(!Ok())
468 return NULL;
469
470 NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;
471 if(!bitmapRep)
472 return NULL;
473
474 if([bitmapRep bitsPerPixel]!=bpp)
475 {
476 wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
477 return NULL;
478 }
479 data.m_width = [bitmapRep pixelsWide];
480 data.m_height = [bitmapRep pixelsHigh];
481 data.m_stride = [bitmapRep bytesPerRow];
482 return [bitmapRep bitmapData];
483
484 // NOTE: It is up to the user to make sure they used the proper
485 // pixel format class that details what is actually inside the pixels
486 // We can only check to make sure that the total number of bits per
487 // pixel are being iterated over properly
488 // NSBitmapImageRep can contain grayscale or CMYK data and
489 // wxPixelDataBase doesn't really define the color format
490 }
491
492 void wxBitmap::UngetRawData(wxPixelDataBase& data)
493 { // TODO
494 }
495
496 void wxBitmap::UseAlpha()
497 { // TODO
498 }
499
500 // ========================================================================
501 // wxMask
502 // ========================================================================
503
504 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
505
506 wxMask::wxMask()
507 {
508 m_cocoaNSBitmapImageRep = nil;
509 }
510
511 // Construct a mask from a bitmap and a colour indicating
512 // the transparent area
513 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
514 {
515 m_cocoaNSBitmapImageRep = nil;
516 Create(bitmap, colour);
517 }
518
519 // Construct a mask from a bitmap and a palette index indicating
520 // the transparent area
521 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
522 {
523 m_cocoaNSBitmapImageRep = nil;
524
525 Create(bitmap, paletteIndex);
526 }
527
528 // Construct a mask from a mono bitmap (copies the bitmap).
529 wxMask::wxMask(const wxBitmap& bitmap)
530 {
531 m_cocoaNSBitmapImageRep = nil;
532
533 Create(bitmap);
534 }
535
536 wxMask::~wxMask()
537 {
538 [m_cocoaNSBitmapImageRep release];
539 }
540
541 // Create a mask from a mono bitmap (copies the bitmap).
542 bool wxMask::Create(const wxBitmap& bitmap)
543 {
544 // TODO
545 return FALSE;
546 }
547
548 // Create a mask from a bitmap and a palette index indicating
549 // the transparent area
550 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
551 {
552 // TODO
553 return FALSE;
554 }
555
556 template <typename PixelData>
557 static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
558 {
559 wxCHECK_MSG(dstData,false,wxT("Couldn't access mask data"));
560 typename PixelData::Iterator p(srcData);
561 const int nRows = srcData.GetHeight();
562 const int nCols = srcData.GetWidth();
563 // Total number of bytes per destination column
564 const int dstRowLength = (nCols+7)/8;
565 // Number of source columns that fit into a byte in the destination
566 const int width_aligned = nCols/8*8;
567 for(int y=0; y<nRows; ++y)
568 {
569 typename PixelData::Iterator rowStart(p);
570 unsigned char *dstRow = dstData + y*dstRowLength;
571 for(int x=0; x<width_aligned; x+=8)
572 {
573 unsigned char *dstByte = dstRow + x/8;
574 *dstByte = 0;
575 // Take source RGB, compare it with the wxColour
576 for(int j=0; j<8; ++j, ++p)
577 {
578 *dstByte +=
579 ( p.Red()!=colour.Red()
580 || p.Green()!=colour.Green()
581 || p.Blue()!=colour.Blue()
582 ) << (7-j);
583 }
584 }
585 // Handle the remaining 0-7 pixels in the row
586 unsigned char *dstByte = dstRow + width_aligned/8;
587 if(nCols%8>0)
588 *dstByte = 0;
589 for(int j=0; j<(nCols%8); ++j, ++p)
590 {
591 *dstByte +=
592 ( p.Red()!=colour.Red()
593 || p.Green()!=colour.Green()
594 || p.Blue()!=colour.Blue()
595 ) << (7-j);
596 }
597 p = rowStart;
598 p.OffsetY(srcData,1);
599 }
600 return true;
601 }
602
603 // Create a mask from a bitmap and a colour indicating
604 // the transparent area
605 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
606 {
607 wxAutoNSAutoreleasePool pool;
608 if(!bitmap.Ok())
609 return false;
610 int bmpWidth = bitmap.GetWidth();
611 int bmpHeight = bitmap.GetHeight();
612 int dstRowLength = (bmpWidth+7)/8;
613
614 // Create a bitmap image rep with 1-bit per pixel data representing
615 // the alpha channel padded such that rows end on byte boundaries
616 // Since NSBitmapImageRep doesn't have any sort of NSNullColorSpace
617 // we must have at least one channel of non-alpha data. In order to
618 // make our life easy, we use planar data which results in two
619 // separate arrays. We don't need to touch the first because it
620 // should never be used. The second is the 1-bit "alpha" data.
621 NSBitmapImageRep *maskRep = [[[NSBitmapImageRep alloc]
622 initWithBitmapDataPlanes:NULL pixelsWide:bmpWidth
623 pixelsHigh:bmpHeight bitsPerSample:1
624 samplesPerPixel:2 hasAlpha:YES isPlanar:YES
625 colorSpaceName:NSCalibratedWhiteColorSpace
626 bytesPerRow:dstRowLength bitsPerPixel:1] autorelease];
627 wxCHECK(maskRep,false);
628
629 // We need the source NSBitmapImageRep to detemine its pixel format
630 NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();
631 wxCHECK_MSG(srcBitmapRep,false,wxT("Can't create mask for an uninitialized bitmap"));
632
633 // Get a pointer to the destination data
634 unsigned char *dstPlanes[5] = {NULL,NULL,NULL,NULL,NULL};
635 [maskRep getBitmapDataPlanes:dstPlanes];
636 unsigned char *dstData = dstPlanes[1];
637 // The wxImage format (which we use whenever we imported from wxImage)
638 if([srcBitmapRep bitsPerPixel]==24 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
639 {
640 wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
641 wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
642 false, wxT("Unable to access raw data"));
643 }
644 // 32-bpp RGBx (x=throw away, no alpha)
645 else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
646 {
647 typedef wxPixelFormat<unsigned char,32,0,1,2> PixelFormat;
648 wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
649 wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
650 false, wxT("Unable to access raw data"));
651 }
652 // 32-bpp RGBA
653 else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==4 && [srcBitmapRep hasAlpha]==YES)
654 {
655 wxPixelData<wxBitmap,wxAlphaPixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
656 wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
657 false, wxT("Unable to access raw data"));
658 }
659 else
660 { wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }
661
662 // maskRep was autoreleased in case we had to exit quickly
663 m_cocoaNSBitmapImageRep = [maskRep retain];
664 return true;
665 }
666