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