src/cocoa/bitmap.mm

/////////////////////////////////////////////////////////////////////////////
// Name:        src/cocoa/bitmap.cpp
// Purpose:     wxBitmap
// Author:      David Elliott
// Modified by:
// Created:     2003/07/19
// RCS-ID:      $Id$
// Copyright:   (c) 2003 David Elliott
// Licence:     wxWidgets licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"
#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/utils.h"
    #include "wx/palette.h"
    #include "wx/icon.h"
    #include "wx/colour.h"
#endif //WX_PRECOMP
#include "wx/bitmap.h"
#include "wx/image.h"
#include "wx/xpmdecod.h"
#include "wx/rawbmp.h"

#include "wx/cocoa/autorelease.h"
#include "wx/cocoa/string.h"

#import <AppKit/NSBitmapImageRep.h>
#import <AppKit/NSGraphics.h>
#import <AppKit/NSImage.h>
#import <AppKit/NSColor.h>

// ========================================================================
// wxBitmapRefData
// ========================================================================
class wxBitmapRefData: public wxGDIRefData
{
    friend class wxBitmap;
public:
    wxBitmapRefData();
    wxBitmapRefData( const wxBitmapRefData& data );
    virtual ~wxBitmapRefData();

protected:
    int                 m_width;
    int                 m_height;
    int                 m_depth;
    bool                m_ok;
    int                 m_numColors;
    wxPalette           m_bitmapPalette;
    int                 m_quality;
    WX_NSBitmapImageRep m_cocoaNSBitmapImageRep;
    wxMask             *m_bitmapMask; // Optional mask
};

#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)

wxBitmapRefData::wxBitmapRefData()
{
    m_ok = FALSE;
    m_width = 0;
    m_height = 0;
    m_depth = 0;
    m_quality = 0;
    m_numColors = 0;
    m_cocoaNSBitmapImageRep = nil;
    m_bitmapMask = NULL;
}

wxBitmapRefData::wxBitmapRefData( const wxBitmapRefData& data)
{
    m_width = data.m_width;
    m_height = data.m_height;
    m_depth = data.m_depth;
    m_ok = data.m_ok;
    m_numColors = data.m_numColors;
    m_bitmapPalette = data.m_bitmapPalette;
    m_quality = data.m_quality;
    m_cocoaNSBitmapImageRep = [data.m_cocoaNSBitmapImageRep copyWithZone:nil];
    m_bitmapMask = data.m_bitmapMask?new wxMask(*data.m_bitmapMask):NULL;
}

wxBitmapRefData::~wxBitmapRefData()
{
    [m_cocoaNSBitmapImageRep release];
    m_cocoaNSBitmapImageRep = NULL;

    delete m_bitmapMask;
    m_bitmapMask = NULL;
}

// ========================================================================
// wxBitmap
// ========================================================================
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)

wxBitmap::wxBitmap()
{
    m_refData = NULL;
}

wxBitmap::~wxBitmap()
{
}

wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
{
    m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_width = the_width ;
    M_BITMAPDATA->m_height = the_height ;
    M_BITMAPDATA->m_depth = no_bits ;
    M_BITMAPDATA->m_numColors = 0;

    /* TODO: create the bitmap from data */
}

wxBitmap::wxBitmap(int w, int h, int d)
{
    (void)Create(w, h, d);
}

wxBitmap::wxBitmap(void *data, wxBitmapType type, int width, int height, int depth)
{
    (void) Create(data, type, width, height, depth);
}

wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
{
    LoadFile(filename, type);
}

wxObjectRefData *wxBitmap::CreateRefData() const
{
    return new wxBitmapRefData;
}

wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
{
    return new wxBitmapRefData(*(wxBitmapRefData*)data);
}

WX_NSBitmapImageRep wxBitmap::GetNSBitmapImageRep()
{
    if(!M_BITMAPDATA)
        return NULL;
    return M_BITMAPDATA->m_cocoaNSBitmapImageRep;
}

WX_NSImage wxBitmap::GetNSImage(bool useMask) const
{
    if(!Ok())
        return nil;
    NSImage *nsimage = [[[NSImage alloc]
            initWithSize:NSMakeSize(GetWidth(), GetHeight())] autorelease];
    if(!nsimage)
        return nil;
    [nsimage addRepresentation: M_BITMAPDATA->m_cocoaNSBitmapImageRep];
    if(useMask && GetMask())
    {
        // Show before/after to prove that the bitmap itself is not changed
        // even though we just composited onto the NSImage
        wxLogTrace(wxTRACE_COCOA,wxT("Before: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
        NSImage *maskImage = [[NSImage alloc]
                initWithSize:NSMakeSize(GetWidth(), GetHeight())];
        [maskImage addRepresentation: GetMask()->GetNSBitmapImageRep()];
        [nsimage lockFocus];
        [maskImage compositeToPoint:NSZeroPoint operation:NSCompositeDestinationIn];
        [nsimage unlockFocus];
        [maskImage release];
        wxLogTrace(wxTRACE_COCOA,wxT("After: bpp=%d"),[M_BITMAPDATA->m_cocoaNSBitmapImageRep bitsPerPixel]);
    }
    return nsimage;
}

void wxBitmap::SetNSBitmapImageRep(WX_NSBitmapImageRep bitmapImageRep)
{
    if(!M_BITMAPDATA)
        return;
    // NOTE: No checking is done to make sure width/height agree
    [bitmapImageRep retain];
    [M_BITMAPDATA->m_cocoaNSBitmapImageRep release];
    M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImageRep;
}

void wxBitmap::SetWidth(int w)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_width = w;
}

void wxBitmap::SetHeight(int h)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_height = h;
}

void wxBitmap::SetDepth(int d)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_depth = d;
}

void wxBitmap::SetQuality(int q)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_quality = q;
}

void wxBitmap::SetOk(bool isOk)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_ok = isOk;
}

void wxBitmap::SetPalette(const wxPalette& palette)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_bitmapPalette = palette ;
}

void wxBitmap::SetMask(wxMask *mask)
{
    if (!M_BITMAPDATA)
        m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_bitmapMask = mask ;
}

bool wxBitmap::Ok() const
{
    return m_refData && M_BITMAPDATA->m_ok;
}

wxPalette* wxBitmap::GetPalette() const
{
    if(!m_refData)
        return NULL;
    return &M_BITMAPDATA->m_bitmapPalette;
}

wxMask* wxBitmap::GetMask() const
{
    if(!m_refData)
        return NULL;
    return M_BITMAPDATA->m_bitmapMask;
}

int wxBitmap::GetDepth() const
{
    if(!m_refData)
        return 0;
    return M_BITMAPDATA->m_depth;
}

int wxBitmap::GetWidth() const
{
    if(!m_refData)
        return 0;
    return M_BITMAPDATA->m_width;
}

int wxBitmap::GetHeight() const
{
    if(!m_refData)
        return 0;
    return M_BITMAPDATA->m_height;
}

bool wxBitmap::Create(int w, int h, int d)
{
    UnRef();

    m_refData = new wxBitmapRefData;

    M_BITMAPDATA->m_width = w;
    M_BITMAPDATA->m_height = h;
    M_BITMAPDATA->m_depth = d;

    /* TODO: create new bitmap */
    M_BITMAPDATA->m_cocoaNSBitmapImageRep = [[NSBitmapImageRep alloc]
            initWithBitmapDataPlanes: NULL
            pixelsWide: w
            pixelsHigh: h
            bitsPerSample: 8
            samplesPerPixel: 3
            hasAlpha: NO
            isPlanar: NO
            colorSpaceName: NSCalibratedRGBColorSpace
            bytesPerRow: 0  // NOTE: Contrary to Apple documentation Mac OS
                            // 10.4 will add padding bytes when 0 is used here
            bitsPerPixel: 0];

    wxLogTrace(wxTRACE_COCOA,wxT("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p"), M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
    M_BITMAPDATA->m_ok = true;
    M_BITMAPDATA->m_numColors = 0;
    M_BITMAPDATA->m_quality = 0;
    M_BITMAPDATA->m_bitmapMask = NULL;

    return M_BITMAPDATA->m_ok;
}

bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
{
    wxAutoNSAutoreleasePool pool;
    UnRef();

    m_refData = new wxBitmapRefData;

    NSBitmapImageRep *imageRep = [NSBitmapImageRep
        imageRepWithContentsOfFile:wxNSStringWithWxString(filename)];

    if(imageRep)
    {
        M_BITMAPDATA->m_width = [imageRep pixelsWide];
        M_BITMAPDATA->m_height = [imageRep pixelsHigh];
        M_BITMAPDATA->m_depth = 24; // FIXME
        M_BITMAPDATA->m_ok = true;
        M_BITMAPDATA->m_numColors = 0;
        M_BITMAPDATA->m_quality = 0;
        M_BITMAPDATA->m_cocoaNSBitmapImageRep = [imageRep retain];
        M_BITMAPDATA->m_bitmapMask = NULL;
        return true;
    }
    wxImage image;
    if(!image.LoadFile(filename,type))
        return false;
    if(!image.Ok())
        return false;
    *this = wxBitmap(image);
    return true;
}

bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
{
    UnRef();

    m_refData = new wxBitmapRefData;

    return false;
}

bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
{
    return false;
}

bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
    UnRef();
    if(!icon.GetNSImage());
    [icon.GetNSImage() lockFocus];
    NSRect imageRect;
    imageRect.origin.x = imageRect.origin.y = 0.0;
    imageRect.size = [icon.GetNSImage() size];
    NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
    [icon.GetNSImage() unlockFocus];
    if(!newBitmapRep)
        return false;
    m_refData = new wxBitmapRefData;
    M_BITMAPDATA->m_cocoaNSBitmapImageRep = newBitmapRep;
    M_BITMAPDATA->m_width = [newBitmapRep pixelsWide];
    M_BITMAPDATA->m_height = [newBitmapRep pixelsHigh];
    M_BITMAPDATA->m_depth = [newBitmapRep bitsPerSample]*[newBitmapRep samplesPerPixel];
    M_BITMAPDATA->m_ok = true;
    M_BITMAPDATA->m_numColors = 0;
    M_BITMAPDATA->m_quality = 0;
    M_BITMAPDATA->m_bitmapMask = NULL;
    return true;
}

wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
{
    return wxNullBitmap;
}

wxImage wxBitmap::ConvertToImage() const
{
    wxAutoNSAutoreleasePool pool;
    if(!Ok())
        return /*wxImage(5,5)*/wxNullImage;
    NSImage *nsimage = GetNSImage(false /* don't use mask */);
    wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
    [nsimage lockFocus];
    for(int i=0; i < M_BITMAPDATA->m_width; i++)
    {
        // Don't let the pool get too big as you'll notice we're creating
        // two autoreleased NSColor objects with every iteration.
        wxAutoNSAutoreleasePool loopPool;
        for(int j=0; j < M_BITMAPDATA->m_height; j++)
        {
            NSColor *pixelColor = NSReadPixel(NSMakePoint(i,M_BITMAPDATA->m_height - j - 1));
            NSColor *color = [pixelColor colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
            newImage.SetRGB(i,j,int([color redComponent]*255.0), int([color greenComponent]*255.0), int([color blueComponent]*255.0));
        }
    }
    [nsimage unlockFocus];
    return newImage;
}

bool wxBitmap::CreateFromXpm(const char **xpm)
{
#if wxUSE_IMAGE && wxUSE_XPM
    UnRef();

    wxCHECK_MSG( xpm, false, wxT("invalid XPM data") )

    wxXPMDecoder decoder;
    wxImage img = decoder.ReadData(xpm);
    wxCHECK_MSG( img.Ok(), false, wxT("invalid XPM data") )

    *this = wxBitmap(img);
    return true;
#else
    return false;
#endif
}

bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
{
    UnRef();

    wxCHECK_MSG(image.Ok(), false, wxT("invalid image"));
    wxCHECK_MSG(depth == -1 || depth == 1, false, wxT("invalid bitmap depth"));

    m_refData = new wxBitmapRefData();

    M_BITMAPDATA->m_width = image.GetWidth();
    M_BITMAPDATA->m_height = image.GetHeight();
    NSBitmapImageRep *bitmapImage = [[NSBitmapImageRep alloc]
            initWithBitmapDataPlanes: NULL
            pixelsWide: image.GetWidth()
            pixelsHigh: image.GetHeight()
            bitsPerSample: 8
            samplesPerPixel: 3
            hasAlpha: NO
            isPlanar: NO
            colorSpaceName: NSCalibratedRGBColorSpace
            bytesPerRow: image.GetWidth()*3
            bitsPerPixel: 0];

    // TODO: Specify bytesPerRow:0 and then use [bitmapImage bytesPerRow]
    // so that the rows are aligned suitably for altivec by the OS (Tiger)
    const int numBytes = image.GetWidth()*image.GetHeight()*3;
    memcpy([bitmapImage bitmapData], image.GetData(), numBytes);
    // TODO: Alpha and convert to desired depth
    M_BITMAPDATA->m_depth = 24;
    M_BITMAPDATA->m_ok = true;
    M_BITMAPDATA->m_numColors = 0;
    M_BITMAPDATA->m_quality = 0;
    M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImage;
    M_BITMAPDATA->m_bitmapMask = new wxMask(*this,wxColour(image.GetMaskRed(),image.GetMaskGreen(),image.GetMaskBlue()));
    return true;
}

void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
{
    if(!Ok())
        return NULL;

    NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;
    if(!bitmapRep)
        return NULL;

    if([bitmapRep bitsPerPixel]!=bpp)
    {
        wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
        return NULL;
    }
    data.m_width = [bitmapRep pixelsWide];
    data.m_height = [bitmapRep pixelsHigh];
    data.m_stride = [bitmapRep bytesPerRow];
    return [bitmapRep bitmapData];

    // NOTE: It is up to the user to make sure they used the proper
    // pixel format class that details what is actually inside the pixels
    // We can only check to make sure that the total number of bits per
    // pixel are being iterated over properly
    // NSBitmapImageRep can contain grayscale or CMYK data and
    // wxPixelDataBase doesn't really define the color format
}

void wxBitmap::UngetRawData(wxPixelDataBase& data)
{   // TODO
}

void wxBitmap::UseAlpha()
{   // TODO
}

// ========================================================================
// wxMask
// ========================================================================

IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)

wxMask::wxMask()
{
    m_cocoaNSBitmapImageRep = nil;
}

// Construct a mask from a bitmap and a colour indicating
// the transparent area
wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
{
    m_cocoaNSBitmapImageRep = nil;
    Create(bitmap, colour);
}

// Construct a mask from a bitmap and a palette index indicating
// the transparent area
wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
{
    m_cocoaNSBitmapImageRep = nil;

    Create(bitmap, paletteIndex);
}

// Construct a mask from a mono bitmap (copies the bitmap).
wxMask::wxMask(const wxBitmap& bitmap)
{
    m_cocoaNSBitmapImageRep = nil;

    Create(bitmap);
}

wxMask::~wxMask()
{
    [m_cocoaNSBitmapImageRep release];
}

// Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap)
{
// TODO
    return FALSE;
}

// Create a mask from a bitmap and a palette index indicating
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
{
// TODO
    return FALSE;
}

template <typename PixelData>
static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
{
    wxCHECK_MSG(dstData,false,wxT("Couldn't access mask data"));
    typename PixelData::Iterator p(srcData);
    const int nRows = srcData.GetHeight();
    const int nCols = srcData.GetWidth();
    // Total number of bytes per destination column
    const int dstRowLength = (nCols+7)/8;
    // Number of source columns that fit into a byte in the destination
    const int width_aligned = nCols/8*8;
    for(int y=0; y<nRows; ++y)
    {
        typename PixelData::Iterator rowStart(p);
        unsigned char *dstRow = dstData + y*dstRowLength;
        for(int x=0; x<width_aligned; x+=8)
        {
            unsigned char *dstByte = dstRow + x/8;
            *dstByte = 0;
            // Take source RGB, compare it with the wxColour
            for(int j=0; j<8; ++j, ++p)
            {
                *dstByte +=
                (   p.Red()!=colour.Red()
                ||  p.Green()!=colour.Green()
                ||  p.Blue()!=colour.Blue()
                )   << (7-j);
            }
        }
        // Handle the remaining 0-7 pixels in the row
        unsigned char *dstByte = dstRow + width_aligned/8;
        if(nCols%8>0)
            *dstByte = 0;
        for(int j=0; j<(nCols%8); ++j, ++p)
        {
            *dstByte +=
            (   p.Red()!=colour.Red()
            ||  p.Green()!=colour.Green()
            ||  p.Blue()!=colour.Blue()
            )   << (7-j);
        }
        p = rowStart;
        p.OffsetY(srcData,1);
    }
    return true;
}

// Create a mask from a bitmap and a colour indicating
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
    wxAutoNSAutoreleasePool pool;
    if(!bitmap.Ok())
        return false;
    int bmpWidth = bitmap.GetWidth();
    int bmpHeight = bitmap.GetHeight();
    int dstRowLength = (bmpWidth+7)/8;

    // Create a bitmap image rep with 1-bit per pixel data representing
    // the alpha channel padded such that rows end on byte boundaries
    // Since NSBitmapImageRep doesn't have any sort of NSNullColorSpace
    // we must have at least one channel of non-alpha data.  In order to
    // make our life easy, we use planar data which results in two
    // separate arrays.  We don't need to touch the first because it
    // should never be used.  The second is the 1-bit "alpha" data.
    NSBitmapImageRep *maskRep = [[[NSBitmapImageRep alloc]
        initWithBitmapDataPlanes:NULL pixelsWide:bmpWidth
        pixelsHigh:bmpHeight bitsPerSample:1
        samplesPerPixel:2 hasAlpha:YES isPlanar:YES
        colorSpaceName:NSCalibratedWhiteColorSpace
        bytesPerRow:dstRowLength bitsPerPixel:1] autorelease];
    wxCHECK(maskRep,false);

    // We need the source NSBitmapImageRep to detemine its pixel format
    NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();
    wxCHECK_MSG(srcBitmapRep,false,wxT("Can't create mask for an uninitialized bitmap"));

    // Get a pointer to the destination data
    unsigned char *dstPlanes[5] = {NULL,NULL,NULL,NULL,NULL};
    [maskRep getBitmapDataPlanes:dstPlanes];
    unsigned char *dstData = dstPlanes[1];
    // The wxImage format (which we use whenever we imported from wxImage)
    if([srcBitmapRep bitsPerPixel]==24 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
    {
        wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
        wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
            false, wxT("Unable to access raw data"));
    }
    // 32-bpp RGBx (x=throw away, no alpha)
    else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
    {
        typedef wxPixelFormat<unsigned char,32,0,1,2> PixelFormat;
        wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
        wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
            false, wxT("Unable to access raw data"));
    }
    // 32-bpp RGBA
    else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==4 && [srcBitmapRep hasAlpha]==YES)
    {
        wxPixelData<wxBitmap,wxAlphaPixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
        wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
            false, wxT("Unable to access raw data"));
    }
    else
    {   wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }

    // maskRep was autoreleased in case we had to exit quickly
    m_cocoaNSBitmapImageRep = [maskRep retain];
    return true;
}
Commit	Line	Data
	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 // NOTE: Contrary to Apple documentation Mac OS
	303	// 10.4 will add padding bytes when 0 is used here
	304	bitsPerPixel: 0];
	305
	306	wxLogTrace(wxTRACE_COCOA,wxT("M_BITMAPDATA=%p NSBitmapImageRep bitmapData=%p"), M_BITMAPDATA, [M_BITMAPDATA->m_cocoaNSBitmapImageRep bitmapData]);
	307	M_BITMAPDATA->m_ok = true;
	308	M_BITMAPDATA->m_numColors = 0;
	309	M_BITMAPDATA->m_quality = 0;
	310	M_BITMAPDATA->m_bitmapMask = NULL;
	311
	312	return M_BITMAPDATA->m_ok;
	313	}
	314
	315	bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
	316	{
	317	wxAutoNSAutoreleasePool pool;
	318	UnRef();
	319
	320	m_refData = new wxBitmapRefData;
	321
	322	NSBitmapImageRep *imageRep = [NSBitmapImageRep
	323	imageRepWithContentsOfFile:wxNSStringWithWxString(filename)];
	324
	325	if(imageRep)
	326	{
	327	M_BITMAPDATA->m_width = [imageRep pixelsWide];
	328	M_BITMAPDATA->m_height = [imageRep pixelsHigh];
	329	M_BITMAPDATA->m_depth = 24; // FIXME
	330	M_BITMAPDATA->m_ok = true;
	331	M_BITMAPDATA->m_numColors = 0;
	332	M_BITMAPDATA->m_quality = 0;
	333	M_BITMAPDATA->m_cocoaNSBitmapImageRep = [imageRep retain];
	334	M_BITMAPDATA->m_bitmapMask = NULL;
	335	return true;
	336	}
	337	wxImage image;
	338	if(!image.LoadFile(filename,type))
	339	return false;
	340	if(!image.Ok())
	341	return false;
	342	*this = wxBitmap(image);
	343	return true;
	344	}
	345
	346	bool wxBitmap::Create(void *data, wxBitmapType type, int width, int height, int depth)
	347	{
	348	UnRef();
	349
	350	m_refData = new wxBitmapRefData;
	351
	352	return false;
	353	}
	354
	355	bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
	356	{
	357	return false;
	358	}
	359
	360	bool wxBitmap::CopyFromIcon(const wxIcon& icon)
	361	{
	362	UnRef();
	363	if(!icon.GetNSImage());
	364	[icon.GetNSImage() lockFocus];
	365	NSRect imageRect;
	366	imageRect.origin.x = imageRect.origin.y = 0.0;
	367	imageRect.size = [icon.GetNSImage() size];
	368	NSBitmapImageRep *newBitmapRep = [[NSBitmapImageRep alloc] initWithFocusedViewRect:imageRect];
	369	[icon.GetNSImage() unlockFocus];
	370	if(!newBitmapRep)
	371	return false;
	372	m_refData = new wxBitmapRefData;
	373	M_BITMAPDATA->m_cocoaNSBitmapImageRep = newBitmapRep;
	374	M_BITMAPDATA->m_width = [newBitmapRep pixelsWide];
	375	M_BITMAPDATA->m_height = [newBitmapRep pixelsHigh];
	376	M_BITMAPDATA->m_depth = [newBitmapRep bitsPerSample]*[newBitmapRep samplesPerPixel];
	377	M_BITMAPDATA->m_ok = true;
	378	M_BITMAPDATA->m_numColors = 0;
	379	M_BITMAPDATA->m_quality = 0;
	380	M_BITMAPDATA->m_bitmapMask = NULL;
	381	return true;
	382	}
	383
	384	wxBitmap wxBitmap::GetSubBitmap(wxRect const&) const
	385	{
	386	return wxNullBitmap;
	387	}
	388
	389	wxImage wxBitmap::ConvertToImage() const
	390	{
	391	wxAutoNSAutoreleasePool pool;
	392	if(!Ok())
	393	return /wxImage(5,5)/wxNullImage;
	394	NSImage nsimage = GetNSImage(false / don't use mask */);
	395	wxImage newImage(M_BITMAPDATA->m_width,M_BITMAPDATA->m_height);
	396	[nsimage lockFocus];
	397	for(int i=0; i < M_BITMAPDATA->m_width; i++)
	398	{
	399	// Don't let the pool get too big as you'll notice we're creating
	400	// two autoreleased NSColor objects with every iteration.
	401	wxAutoNSAutoreleasePool loopPool;
	402	for(int j=0; j < M_BITMAPDATA->m_height; j++)
	403	{
	404	NSColor *pixelColor = NSReadPixel(NSMakePoint(i,M_BITMAPDATA->m_height - j - 1));
	405	NSColor *color = [pixelColor colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
	406	newImage.SetRGB(i,j,int([color redComponent]255.0), int([color greenComponent]255.0), int([color blueComponent]*255.0));
	407	}
	408	}
	409	[nsimage unlockFocus];
	410	return newImage;
	411	}
	412
	413	bool wxBitmap::CreateFromXpm(const char **xpm)
	414	{
	415	#if wxUSE_IMAGE && wxUSE_XPM
	416	UnRef();
	417
	418	wxCHECK_MSG( xpm, false, wxT("invalid XPM data") )
	419
	420	wxXPMDecoder decoder;
	421	wxImage img = decoder.ReadData(xpm);
	422	wxCHECK_MSG( img.Ok(), false, wxT("invalid XPM data") )
	423
	424	*this = wxBitmap(img);
	425	return true;
	426	#else
	427	return false;
	428	#endif
	429	}
	430
	431	bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
	432	{
	433	UnRef();
	434
	435	wxCHECK_MSG(image.Ok(), false, wxT("invalid image"));
	436	wxCHECK_MSG(depth == -1 \|\| depth == 1, false, wxT("invalid bitmap depth"));
	437
	438	m_refData = new wxBitmapRefData();
	439
	440	M_BITMAPDATA->m_width = image.GetWidth();
	441	M_BITMAPDATA->m_height = image.GetHeight();
	442	NSBitmapImageRep *bitmapImage = [[NSBitmapImageRep alloc]
	443	initWithBitmapDataPlanes: NULL
	444	pixelsWide: image.GetWidth()
	445	pixelsHigh: image.GetHeight()
	446	bitsPerSample: 8
	447	samplesPerPixel: 3
	448	hasAlpha: NO
	449	isPlanar: NO
	450	colorSpaceName: NSCalibratedRGBColorSpace
	451	bytesPerRow: image.GetWidth()*3
	452	bitsPerPixel: 0];
	453
	454	// TODO: Specify bytesPerRow:0 and then use [bitmapImage bytesPerRow]
	455	// so that the rows are aligned suitably for altivec by the OS (Tiger)
	456	const int numBytes = image.GetWidth()image.GetHeight()3;
	457	memcpy([bitmapImage bitmapData], image.GetData(), numBytes);
	458	// TODO: Alpha and convert to desired depth
	459	M_BITMAPDATA->m_depth = 24;
	460	M_BITMAPDATA->m_ok = true;
	461	M_BITMAPDATA->m_numColors = 0;
	462	M_BITMAPDATA->m_quality = 0;
	463	M_BITMAPDATA->m_cocoaNSBitmapImageRep = bitmapImage;
	464	M_BITMAPDATA->m_bitmapMask = new wxMask(*this,wxColour(image.GetMaskRed(),image.GetMaskGreen(),image.GetMaskBlue()));
	465	return true;
	466	}
	467
	468	void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
	469	{
	470	if(!Ok())
	471	return NULL;
	472
	473	NSBitmapImageRep *bitmapRep = M_BITMAPDATA->m_cocoaNSBitmapImageRep;
	474	if(!bitmapRep)
	475	return NULL;
	476
	477	if([bitmapRep bitsPerPixel]!=bpp)
	478	{
	479	wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
	480	return NULL;
	481	}
	482	data.m_width = [bitmapRep pixelsWide];
	483	data.m_height = [bitmapRep pixelsHigh];
	484	data.m_stride = [bitmapRep bytesPerRow];
	485	return [bitmapRep bitmapData];
	486
	487	// NOTE: It is up to the user to make sure they used the proper
	488	// pixel format class that details what is actually inside the pixels
	489	// We can only check to make sure that the total number of bits per
	490	// pixel are being iterated over properly
	491	// NSBitmapImageRep can contain grayscale or CMYK data and
	492	// wxPixelDataBase doesn't really define the color format
	493	}
	494
	495	void wxBitmap::UngetRawData(wxPixelDataBase& data)
	496	{ // TODO
	497	}
	498
	499	void wxBitmap::UseAlpha()
	500	{ // TODO
	501	}
	502
	503	// ========================================================================
	504	// wxMask
	505	// ========================================================================
	506
	507	IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
	508
	509	wxMask::wxMask()
	510	{
	511	m_cocoaNSBitmapImageRep = nil;
	512	}
	513
	514	// Construct a mask from a bitmap and a colour indicating
	515	// the transparent area
	516	wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
	517	{
	518	m_cocoaNSBitmapImageRep = nil;
	519	Create(bitmap, colour);
	520	}
	521
	522	// Construct a mask from a bitmap and a palette index indicating
	523	// the transparent area
	524	wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
	525	{
	526	m_cocoaNSBitmapImageRep = nil;
	527
	528	Create(bitmap, paletteIndex);
	529	}
	530
	531	// Construct a mask from a mono bitmap (copies the bitmap).
	532	wxMask::wxMask(const wxBitmap& bitmap)
	533	{
	534	m_cocoaNSBitmapImageRep = nil;
	535
	536	Create(bitmap);
	537	}
	538
	539	wxMask::~wxMask()
	540	{
	541	[m_cocoaNSBitmapImageRep release];
	542	}
	543
	544	// Create a mask from a mono bitmap (copies the bitmap).
	545	bool wxMask::Create(const wxBitmap& bitmap)
	546	{
	547	// TODO
	548	return FALSE;
	549	}
	550
	551	// Create a mask from a bitmap and a palette index indicating
	552	// the transparent area
	553	bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
	554	{
	555	// TODO
	556	return FALSE;
	557	}
	558
	559	template <typename PixelData>
	560	static bool wxMask_CreateFromBitmapData(PixelData srcData, const wxColour& colour, unsigned char *dstData)
	561	{
	562	wxCHECK_MSG(dstData,false,wxT("Couldn't access mask data"));
	563	typename PixelData::Iterator p(srcData);
	564	const int nRows = srcData.GetHeight();
	565	const int nCols = srcData.GetWidth();
	566	// Total number of bytes per destination column
	567	const int dstRowLength = (nCols+7)/8;
	568	// Number of source columns that fit into a byte in the destination
	569	const int width_aligned = nCols/8*8;
	570	for(int y=0; y<nRows; ++y)
	571	{
	572	typename PixelData::Iterator rowStart(p);
	573	unsigned char dstRow = dstData + ydstRowLength;
	574	for(int x=0; x<width_aligned; x+=8)
	575	{
	576	unsigned char *dstByte = dstRow + x/8;
	577	*dstByte = 0;
	578	// Take source RGB, compare it with the wxColour
	579	for(int j=0; j<8; ++j, ++p)
	580	{
	581	*dstByte +=
	582	( p.Red()!=colour.Red()
	583	\|\| p.Green()!=colour.Green()
	584	\|\| p.Blue()!=colour.Blue()
	585	) << (7-j);
	586	}
	587	}
	588	// Handle the remaining 0-7 pixels in the row
	589	unsigned char *dstByte = dstRow + width_aligned/8;
	590	if(nCols%8>0)
	591	*dstByte = 0;
	592	for(int j=0; j<(nCols%8); ++j, ++p)
	593	{
	594	*dstByte +=
	595	( p.Red()!=colour.Red()
	596	\|\| p.Green()!=colour.Green()
	597	\|\| p.Blue()!=colour.Blue()
	598	) << (7-j);
	599	}
	600	p = rowStart;
	601	p.OffsetY(srcData,1);
	602	}
	603	return true;
	604	}
	605
	606	// Create a mask from a bitmap and a colour indicating
	607	// the transparent area
	608	bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
	609	{
	610	wxAutoNSAutoreleasePool pool;
	611	if(!bitmap.Ok())
	612	return false;
	613	int bmpWidth = bitmap.GetWidth();
	614	int bmpHeight = bitmap.GetHeight();
	615	int dstRowLength = (bmpWidth+7)/8;
	616
	617	// Create a bitmap image rep with 1-bit per pixel data representing
	618	// the alpha channel padded such that rows end on byte boundaries
	619	// Since NSBitmapImageRep doesn't have any sort of NSNullColorSpace
	620	// we must have at least one channel of non-alpha data. In order to
	621	// make our life easy, we use planar data which results in two
	622	// separate arrays. We don't need to touch the first because it
	623	// should never be used. The second is the 1-bit "alpha" data.
	624	NSBitmapImageRep *maskRep = [[[NSBitmapImageRep alloc]
	625	initWithBitmapDataPlanes:NULL pixelsWide:bmpWidth
	626	pixelsHigh:bmpHeight bitsPerSample:1
	627	samplesPerPixel:2 hasAlpha:YES isPlanar:YES
	628	colorSpaceName:NSCalibratedWhiteColorSpace
	629	bytesPerRow:dstRowLength bitsPerPixel:1] autorelease];
	630	wxCHECK(maskRep,false);
	631
	632	// We need the source NSBitmapImageRep to detemine its pixel format
	633	NSBitmapImageRep *srcBitmapRep = const_cast<wxBitmap&>(bitmap).GetNSBitmapImageRep();
	634	wxCHECK_MSG(srcBitmapRep,false,wxT("Can't create mask for an uninitialized bitmap"));
	635
	636	// Get a pointer to the destination data
	637	unsigned char *dstPlanes[5] = {NULL,NULL,NULL,NULL,NULL};
	638	[maskRep getBitmapDataPlanes:dstPlanes];
	639	unsigned char *dstData = dstPlanes[1];
	640	// The wxImage format (which we use whenever we imported from wxImage)
	641	if([srcBitmapRep bitsPerPixel]==24 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
	642	{
	643	wxPixelData<wxBitmap,wxNativePixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
	644	wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
	645	false, wxT("Unable to access raw data"));
	646	}
	647	// 32-bpp RGBx (x=throw away, no alpha)
	648	else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==3 && [srcBitmapRep hasAlpha]==NO)
	649	{
	650	typedef wxPixelFormat<unsigned char,32,0,1,2> PixelFormat;
	651	wxPixelData<wxBitmap,PixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
	652	wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
	653	false, wxT("Unable to access raw data"));
	654	}
	655	// 32-bpp RGBA
	656	else if([srcBitmapRep bitsPerPixel]==32 && [srcBitmapRep bitsPerSample]==8 && [srcBitmapRep samplesPerPixel]==4 && [srcBitmapRep hasAlpha]==YES)
	657	{
	658	wxPixelData<wxBitmap,wxAlphaPixelFormat> pixelData(const_cast<wxBitmap&>(bitmap));
	659	wxCHECK_MSG(wxMask_CreateFromBitmapData(pixelData, colour, dstData),
	660	false, wxT("Unable to access raw data"));
	661	}
	662	else
	663	{ wxCHECK_MSG(false,false,wxT("Unimplemented pixel format")); }
	664
	665	// maskRep was autoreleased in case we had to exit quickly
	666	m_cocoaNSBitmapImageRep = [maskRep retain];
	667	return true;
	668	}
	669