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