correct hhp2cached path

[wxWidgets.git] / src / mac / carbon / bitmap.cpp

diff --git a/src/mac/carbon/bitmap.cpp b/src/mac/carbon/bitmap.cpp
index 1b52261571616a9a0f0af5453609f806a7395c51..19334a0f7c88909ce1efc6fbdc03509a30680821 100644 (file)
--- a/src/mac/carbon/bitmap.cpp
+++ b/src/mac/carbon/bitmap.cpp
@@ -28,12 +28,8 @@
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 

-#ifdef __DARWIN__
-    #include <ApplicationServices/ApplicationServices.h>
-    #include <QuickTime/QuickTime.h>
-#else
-    #include <PictUtils.h>
-#endif
+#include <ApplicationServices/ApplicationServices.h>
+#include <QuickTime/QuickTime.h>

 
 #include "wx/mac/uma.h"
 
 
 #include "wx/mac/uma.h"
 


@@ -47,22 +43,95 @@ IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 // under Quartz then content is transformed into a CGImageRef representing the same data
 // which can be transferred to the GPU by the OS for fast rendering
 
 // under Quartz then content is transformed into a CGImageRef representing the same data
 // which can be transferred to the GPU by the OS for fast rendering
 

-#if wxMAC_USE_CORE_GRAPHICS
-    #define wxMAC_USE_PREMULTIPLIED_ALPHA 1
-    static const int kBestByteAlignement = 16;
-    static const int kMaskBytesPerPixel = 1;
-#else
-#define wxMAC_USE_PREMULTIPLIED_ALPHA 0
-    static const int kBestByteAlignement = 4;
-    static const int kMaskBytesPerPixel = 4;
-#endif
+class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
+{
+    friend class WXDLLIMPEXP_FWD_CORE wxIcon;
+    friend class WXDLLIMPEXP_FWD_CORE wxCursor;
+public:
+    wxBitmapRefData(int width , int height , int depth);
+    wxBitmapRefData();
+    wxBitmapRefData(const wxBitmapRefData &tocopy);
+
+    virtual ~wxBitmapRefData();
+
+    virtual bool IsOk() const { return m_ok; }
+
+    void Free();
+    void SetOk( bool isOk) { m_ok = isOk; }
+
+    void SetWidth( int width ) { m_width = width; }
+    void SetHeight( int height ) { m_height = height; }
+    void SetDepth( int depth ) { m_depth = depth; }
+
+    int GetWidth() const { return m_width; }
+    int GetHeight() const { return m_height; }
+    int GetDepth() const { return m_depth; }
+
+    void *GetRawAccess() const;
+    void *BeginRawAccess();
+    void EndRawAccess();
+
+    bool HasAlpha() const { return m_hasAlpha; }
+    void UseAlpha( bool useAlpha );
+
+public:
+#if wxUSE_PALETTE
+    wxPalette     m_bitmapPalette;
+#endif // wxUSE_PALETTE
+
+    wxMask *      m_bitmapMask; // Optional mask
+    CGImageRef    CreateCGImage() const;
+
+    // returns true if the bitmap has a size that
+    // can be natively transferred into a true icon
+    // if no is returned GetIconRef will still produce
+    // an icon but it will be generated via a PICT and
+    // rescaled to 16 x 16
+    bool          HasNativeSize();
+
+    // caller should increase ref count if needed longer
+    // than the bitmap exists
+    IconRef       GetIconRef();
+
+    // returns a Pict from the bitmap content
+    PicHandle     GetPictHandle();
+
+    CGContextRef  GetBitmapContext() const;
+
+    int           GetBytesPerRow() const { return m_bytesPerRow; }
+    private :
+    bool Create(int width , int height , int depth);
+    void Init();
+
+    int           m_width;
+    int           m_height;
+    int           m_bytesPerRow;
+    int           m_depth;
+    bool          m_hasAlpha;
+    wxMemoryBuffer m_memBuf;
+    int           m_rawAccessCount;
+    bool          m_ok;
+    mutable CGImageRef    m_cgImageRef;
+
+    IconRef       m_iconRef;
+    PicHandle     m_pictHandle;
+
+    CGContextRef  m_hBitmap;
+};
+
+
+#define wxMAC_USE_PREMULTIPLIED_ALPHA 1
+static const int kBestByteAlignement = 16;
+static const int kMaskBytesPerPixel = 1;

 
 static int GetBestBytesPerRow( int rawBytes )
 {
     return (((rawBytes)+kBestByteAlignement-1) & ~(kBestByteAlignement-1) );
 }
 
 
 static int GetBestBytesPerRow( int rawBytes )
 {
     return (((rawBytes)+kBestByteAlignement-1) & ~(kBestByteAlignement-1) );
 }
 

-#if wxUSE_BMPBUTTON
+#if wxUSE_GUI
+
+// this is used for more controls than just the wxBitmap button, also for notebooks etc

 
 void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bitmap , int forceType )
 {
 
 void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bitmap , int forceType )
 {


@@ -75,17 +144,7 @@ void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bi
 
         if ( forceType == 0  )
         {
 
         if ( forceType == 0  )
         {

-            // NOTE : For testing Panther behaviour under higher
-            // Systems make this always be false
-            if ( UMAGetSystemVersion() >= 0x1040 )
-            {
-                // as soon as it is supported, it's a better default
-                forceType = kControlContentCGImageRef;
-            }
-            else if ( bmap->HasNativeSize() )
-            {
-                forceType = kControlContentIconRef;
-            }
+            forceType = kControlContentCGImageRef;

         }
 
         if ( forceType == kControlContentIconRef )
         }
 
         if ( forceType == kControlContentIconRef )


@@ -115,7 +174,7 @@ void wxMacCreateBitmapButton( ControlButtonContentInfo*info , const wxBitmap& bi
         else if ( forceType == kControlContentCGImageRef )
         {
             info->contentType = kControlContentCGImageRef ;
         else if ( forceType == kControlContentCGImageRef )
         {
             info->contentType = kControlContentCGImageRef ;

-            info->u.imageRef = (CGImageRef) bmap->CGImageCreate() ;
+            info->u.imageRef = (CGImageRef) bmap->CreateCGImage() ;

         }
         else
         {
         }
         else
         {


@@ -132,7 +191,7 @@ CGImageRef wxMacCreateCGImageFromBitmap( const wxBitmap& bitmap )
     wxBitmapRefData * bmap = bitmap.GetBitmapData() ;
     if ( bmap == NULL )
         return NULL ;
     wxBitmapRefData * bmap = bitmap.GetBitmapData() ;
     if ( bmap == NULL )
         return NULL ;

-    return (CGImageRef) bmap->CGImageCreate();
+    return (CGImageRef) bmap->CreateCGImage();

 }
 
 void wxMacReleaseBitmapButton( ControlButtonContentInfo*info )
 }
 
 void wxMacReleaseBitmapButton( ControlButtonContentInfo*info )


@@ -149,12 +208,10 @@ void wxMacReleaseBitmapButton( ControlButtonContentInfo*info )
     {
         // owned by the bitmap, no release here
     }
     {
         // owned by the bitmap, no release here
     }

-#if defined( __WXMAC_OSX__ ) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2

     else if ( info->contentType == kControlContentCGImageRef )
     {
         CGImageRelease( info->u.imageRef ) ;
     }
     else if ( info->contentType == kControlContentCGImageRef )
     {
         CGImageRelease( info->u.imageRef ) ;
     }

-#endif

     else
     {
         wxFAIL_MSG(wxT("Unexpected bitmap type") ) ;
     else
     {
         wxFAIL_MSG(wxT("Unexpected bitmap type") ) ;


@@ -173,18 +230,11 @@ void wxBitmapRefData::Init()
     m_bytesPerRow = 0;
     m_ok = false ;
     m_bitmapMask = NULL ;
     m_bytesPerRow = 0;
     m_ok = false ;
     m_bitmapMask = NULL ;

-
-#ifdef __WXMAC_OSX__

     m_cgImageRef = NULL ;
     m_cgImageRef = NULL ;

-#endif

 
     m_iconRef = NULL ;
     m_pictHandle = NULL ;
     m_hBitmap = NULL ;
 
     m_iconRef = NULL ;
     m_pictHandle = NULL ;
     m_hBitmap = NULL ;

-#if! wxMAC_USE_CORE_GRAPHICS
-    m_hMaskBitmap = NULL;
-    m_maskBytesPerRow = 0 ;
-#endif

 
     m_rawAccessCount = 0 ;
     m_hasAlpha = false;
 
     m_rawAccessCount = 0 ;
     m_hasAlpha = false;


@@ -193,8 +243,8 @@ void wxBitmapRefData::Init()
 wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
 {
     Init();
 wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
 {
     Init();

-    Create(tocopy.m_width, tocopy.m_height, tocopy.m_depth); 
-    
+    Create(tocopy.m_width, tocopy.m_height, tocopy.m_depth);
+

     if (tocopy.m_bitmapMask)
         m_bitmapMask = new wxMask(*tocopy.m_bitmapMask);
     else if (tocopy.m_hasAlpha)
     if (tocopy.m_bitmapMask)
         m_bitmapMask = new wxMask(*tocopy.m_bitmapMask);
     else if (tocopy.m_hasAlpha)


@@ -222,25 +272,21 @@ bool wxBitmapRefData::Create( int w , int h , int d )
     m_width = wxMax(1, w);
     m_height = wxMax(1, h);
     m_depth = d ;
     m_width = wxMax(1, w);
     m_height = wxMax(1, h);
     m_depth = d ;

+    m_hBitmap = NULL ;

 
     m_bytesPerRow = GetBestBytesPerRow( w * 4 ) ;
     size_t size = m_bytesPerRow * h ;
     void* data = m_memBuf.GetWriteBuf( size ) ;
 
     m_bytesPerRow = GetBestBytesPerRow( w * 4 ) ;
     size_t size = m_bytesPerRow * h ;
     void* data = m_memBuf.GetWriteBuf( size ) ;

-    memset( data , 0 , size ) ;
-    m_memBuf.UngetWriteBuf( size ) ;
+    if ( data != NULL )
+    {
+        memset( data , 0 , size ) ;
+        m_memBuf.UngetWriteBuf( size ) ;

 
 

-    m_hBitmap = NULL ;
-#if !wxMAC_USE_CORE_GRAPHICS
-    Rect rect = { 0 , 0 , m_height , m_width } ;
-    verify_noerr( NewGWorldFromPtr( (GWorldPtr*) &m_hBitmap , k32ARGBPixelFormat , &rect , NULL , NULL , 0 ,
-        (char*) data , m_bytesPerRow ) ) ;
-    wxASSERT_MSG( m_hBitmap , wxT("Unable to create GWorld context") ) ;
-#else
-    m_hBitmap = CGBitmapContextCreate((char*) data, m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), kCGImageAlphaNoneSkipFirst );
-    wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
-    CGContextTranslateCTM( m_hBitmap, 0,  m_height );
-    CGContextScaleCTM( m_hBitmap, 1, -1 );
-#endif
+        m_hBitmap = CGBitmapContextCreate((char*) data, m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), kCGImageAlphaNoneSkipFirst );
+        wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
+        CGContextTranslateCTM( m_hBitmap, 0,  m_height );
+        CGContextScaleCTM( m_hBitmap, 1, -1 );
+    } /* data != NULL */

     m_ok = ( m_hBitmap != NULL ) ;
 
     return m_ok ;
     m_ok = ( m_hBitmap != NULL ) ;
 
     return m_ok ;


@@ -252,61 +298,29 @@ void wxBitmapRefData::UseAlpha( bool use )
         return ;
 
     m_hasAlpha = use ;
         return ;
 
     m_hasAlpha = use ;

-#if wxMAC_USE_CORE_GRAPHICS
+

     CGContextRelease( m_hBitmap );
     m_hBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), m_hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst );
     wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
     CGContextTranslateCTM( m_hBitmap, 0,  m_height );
     CGContextScaleCTM( m_hBitmap, 1, -1 );
     CGContextRelease( m_hBitmap );
     m_hBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, wxMacGetGenericRGBColorSpace(), m_hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst );
     wxASSERT_MSG( m_hBitmap , wxT("Unable to create CGBitmapContext context") ) ;
     CGContextTranslateCTM( m_hBitmap, 0,  m_height );
     CGContextScaleCTM( m_hBitmap, 1, -1 );

-#else
-    if ( m_hasAlpha )
-    {
-        wxASSERT( m_hMaskBitmap == NULL ) ;
-
-        int width = GetWidth() ;
-        int height = GetHeight() ;
-        m_maskBytesPerRow = GetBestBytesPerRow( width * kMaskBytesPerPixel );
-        size_t size = height * m_maskBytesPerRow ;
-        unsigned char * data = (unsigned char * ) m_maskMemBuf.GetWriteBuf( size ) ;
-        wxASSERT( data != NULL ) ;
-
-        memset( data , 0 , size ) ;
-        Rect rect = { 0 , 0 , height , width } ;
-
-        verify_noerr( NewGWorldFromPtr( (GWorldPtr*) &m_hMaskBitmap , k32ARGBPixelFormat , &rect , NULL , NULL , 0 ,
-            (char*) data , m_maskBytesPerRow ) ) ;
-        wxASSERT_MSG( m_hMaskBitmap , wxT("Unable to create GWorld context for alpha mask") ) ;
-
-        m_maskMemBuf.UngetWriteBuf(size) ;
-
-
-        UpdateAlphaMask() ;
-    }
-    else
-    {
-        DisposeGWorld( m_hMaskBitmap ) ;
-        m_hMaskBitmap = NULL ;
-        m_maskBytesPerRow = 0 ;
-    }
-#endif

 }
 
 void *wxBitmapRefData::GetRawAccess() const
 {
 }
 
 void *wxBitmapRefData::GetRawAccess() const
 {

-    wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
+    wxCHECK_MSG( IsOk(), NULL , wxT("invalid bitmap") ) ;

     return m_memBuf.GetData() ;
 }
 
 void *wxBitmapRefData::BeginRawAccess()
 {
     return m_memBuf.GetData() ;
 }
 
 void *wxBitmapRefData::BeginRawAccess()
 {

-    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ) ;
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") ) ;

     wxASSERT( m_rawAccessCount == 0 ) ;
     wxASSERT_MSG( m_pictHandle == NULL && m_iconRef == NULL ,
         wxT("Currently, modifing bitmaps that are used in controls already is not supported") ) ;
 
     ++m_rawAccessCount ;
 
     wxASSERT( m_rawAccessCount == 0 ) ;
     wxASSERT_MSG( m_pictHandle == NULL && m_iconRef == NULL ,
         wxT("Currently, modifing bitmaps that are used in controls already is not supported") ) ;
 
     ++m_rawAccessCount ;
 

-#ifdef __WXMAC_OSX__

     // we must destroy an existing cached image, as
     // the bitmap data may change now
     if ( m_cgImageRef )
     // we must destroy an existing cached image, as
     // the bitmap data may change now
     if ( m_cgImageRef )


@@ -314,21 +328,16 @@ void *wxBitmapRefData::BeginRawAccess()
         CGImageRelease( m_cgImageRef ) ;
         m_cgImageRef = NULL ;
     }
         CGImageRelease( m_cgImageRef ) ;
         m_cgImageRef = NULL ;
     }

-#endif

 
     return m_memBuf.GetData() ;
 }
 
 void wxBitmapRefData::EndRawAccess()
 {
 
     return m_memBuf.GetData() ;
 }
 
 void wxBitmapRefData::EndRawAccess()
 {

-    wxCHECK_RET( Ok() , wxT("invalid bitmap") ) ;
+    wxCHECK_RET( IsOk() , wxT("invalid bitmap") ) ;

     wxASSERT( m_rawAccessCount == 1 ) ;
 
     --m_rawAccessCount ;
     wxASSERT( m_rawAccessCount == 1 ) ;
 
     --m_rawAccessCount ;

-
-#if !wxMAC_USE_CORE_GRAPHICS
-    UpdateAlphaMask() ;
-#endif

 }
 
 bool wxBitmapRefData::HasNativeSize()
 }
 
 bool wxBitmapRefData::HasNativeSize()


@@ -346,18 +355,7 @@ IconRef wxBitmapRefData::GetIconRef()
     {
         // Create Icon Family Handle
 
     {
         // Create Icon Family Handle
 

-        IconFamilyHandle iconFamily = NULL ;
-
-        if ( UMAGetSystemVersion() < 0x1040 )
-        {
-            iconFamily = (IconFamilyHandle) NewHandle( 8 ) ;
-            (**iconFamily).resourceType = kIconFamilyType ;
-            (**iconFamily).resourceSize = sizeof(OSType) + sizeof(Size);
-        }
-        else
-        {
-            iconFamily = (IconFamilyHandle) NewHandle( 0 ) ;
-        }
+        IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle( 0 );

 
         int w = GetWidth() ;
         int h = GetHeight() ;
 
         int w = GetWidth() ;
         int h = GetHeight() ;


@@ -369,7 +367,7 @@ IconRef wxBitmapRefData::GetIconRef()
         switch (sz)
         {
             case 128:
         switch (sz)
         {
             case 128:

-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices128PixelDataARGB ;
                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices128PixelDataARGB ;


@@ -383,7 +381,7 @@ IconRef wxBitmapRefData::GetIconRef()
                 break;
 
             case 48:
                 break;
 
             case 48:

-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices48PixelDataARGB ;
                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices48PixelDataARGB ;


@@ -397,7 +395,7 @@ IconRef wxBitmapRefData::GetIconRef()
                 break;
 
             case 32:
                 break;
 
             case 32:

-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices32PixelDataARGB ;
                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices32PixelDataARGB ;


@@ -411,7 +409,7 @@ IconRef wxBitmapRefData::GetIconRef()
                 break;
 
             case 16:
                 break;
 
             case 16:

-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices16PixelDataARGB ;
                 if ( UMAGetSystemVersion() >= 0x1050 )
                 {
                     dataType = kIconServices16PixelDataARGB ;


@@ -430,7 +428,7 @@ IconRef wxBitmapRefData::GetIconRef()
 
         if ( dataType != 0 )
         {
 
         if ( dataType != 0 )
         {

-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

             if (  maskType == 0 && UMAGetSystemVersion() >= 0x1050 )
             {
                 size_t datasize = sz * sz * 4 ;
             if (  maskType == 0 && UMAGetSystemVersion() >= 0x1050 )
             {
                 size_t datasize = sz * sz * 4 ;


@@ -491,30 +489,30 @@ IconRef wxBitmapRefData::GetIconRef()
 #endif
             {
                 // setup the header properly
 #endif
             {
                 // setup the header properly

-                
+

                 Handle data = NULL ;
                 Handle maskdata = NULL ;
                 unsigned char * maskptr = NULL ;
                 unsigned char * ptr = NULL ;
                 size_t datasize, masksize ;
                 Handle data = NULL ;
                 Handle maskdata = NULL ;
                 unsigned char * maskptr = NULL ;
                 unsigned char * ptr = NULL ;
                 size_t datasize, masksize ;

-                
+

                 datasize = sz * sz * 4 ;
                 data = NewHandle( datasize ) ;
                 HLock( data ) ;
                 ptr = (unsigned char*) *data ;
                 memset( ptr , 0, datasize ) ;
                 datasize = sz * sz * 4 ;
                 data = NewHandle( datasize ) ;
                 HLock( data ) ;
                 ptr = (unsigned char*) *data ;
                 memset( ptr , 0, datasize ) ;

-                
+

                 masksize = sz * sz ;
                 maskdata = NewHandle( masksize ) ;
                 HLock( maskdata ) ;
                 maskptr = (unsigned char*) *maskdata ;
                 memset( maskptr , 0 , masksize ) ;
                 masksize = sz * sz ;
                 maskdata = NewHandle( masksize ) ;
                 HLock( maskdata ) ;
                 maskptr = (unsigned char*) *maskdata ;
                 memset( maskptr , 0 , masksize ) ;

-                
+

                 bool hasAlpha = HasAlpha() ;
                 wxMask *mask = m_bitmapMask ;
                 unsigned char * sourcePtr = (unsigned char*) GetRawAccess() ;
                 unsigned char * masksourcePtr = mask ? (unsigned char*) mask->GetRawAccess() : NULL ;
                 bool hasAlpha = HasAlpha() ;
                 wxMask *mask = m_bitmapMask ;
                 unsigned char * sourcePtr = (unsigned char*) GetRawAccess() ;
                 unsigned char * masksourcePtr = mask ? (unsigned char*) mask->GetRawAccess() : NULL ;

-                
+

                 for ( int y = 0 ; y < h ; ++y, sourcePtr += m_bytesPerRow , masksourcePtr += mask ? mask->GetBytesPerRow() : 0 )
                 {
                     unsigned char * source = sourcePtr;
                 for ( int y = 0 ; y < h ; ++y, sourcePtr += m_bytesPerRow , masksourcePtr += mask ? mask->GetBytesPerRow() : 0 )
                 {
                     unsigned char * source = sourcePtr;


@@ -522,41 +520,34 @@ IconRef wxBitmapRefData::GetIconRef()
                     unsigned char * dest = ptr + y * sz * 4 ;
                     unsigned char * maskdest = maskptr + y * sz ;
                     unsigned char a, r, g, b;
                     unsigned char * dest = ptr + y * sz * 4 ;
                     unsigned char * maskdest = maskptr + y * sz ;
                     unsigned char a, r, g, b;

-                    
+

                     for ( int x = 0 ; x < w ; ++x )
                     {
                         a = *source ++ ;
                         r = *source ++ ;
                         g = *source ++ ;
                         b = *source ++ ;
                     for ( int x = 0 ; x < w ; ++x )
                     {
                         a = *source ++ ;
                         r = *source ++ ;
                         g = *source ++ ;
                         b = *source ++ ;

-                        
+

                         *dest++ = 0 ;
                         *dest++ = r ;
                         *dest++ = g ;
                         *dest++ = b ;
                         *dest++ = 0 ;
                         *dest++ = r ;
                         *dest++ = g ;
                         *dest++ = b ;

-                        
+

                         if ( mask )
                         if ( mask )

-                        {

                             *maskdest++ = 0xFF - *masksource++ ;
                             *maskdest++ = 0xFF - *masksource++ ;

-#if !wxMAC_USE_CORE_GRAPHICS
-                            masksource++ ;
-                            masksource++ ;
-                            masksource++ ;
-#endif
-                        }

                         else if ( hasAlpha )
                             *maskdest++ = a ;
                         else
                             *maskdest++ = 0xFF ;
                     }
                 }
                         else if ( hasAlpha )
                             *maskdest++ = a ;
                         else
                             *maskdest++ = 0xFF ;
                     }
                 }

-                
+

                 OSStatus err = SetIconFamilyData( iconFamily, dataType , data ) ;
                 wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
                 OSStatus err = SetIconFamilyData( iconFamily, dataType , data ) ;
                 wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;

-                
+

                 err = SetIconFamilyData( iconFamily, maskType , maskdata ) ;
                 wxASSERT_MSG( err == noErr , wxT("Error when adding mask") ) ;
                 err = SetIconFamilyData( iconFamily, maskType , maskdata ) ;
                 wxASSERT_MSG( err == noErr , wxT("Error when adding mask") ) ;

-                
+

                 HUnlock( data ) ;
                 HUnlock( maskdata ) ;
                 DisposeHandle( data ) ;
                 HUnlock( data ) ;
                 HUnlock( maskdata ) ;
                 DisposeHandle( data ) ;


@@ -574,8 +565,9 @@ IconRef wxBitmapRefData::GetIconRef()
         HLock((Handle) iconFamily);
         OSStatus err = GetIconRefFromIconFamilyPtr( *iconFamily, GetHandleSize((Handle) iconFamily), &m_iconRef );
         HUnlock((Handle) iconFamily);
         HLock((Handle) iconFamily);
         OSStatus err = GetIconRefFromIconFamilyPtr( *iconFamily, GetHandleSize((Handle) iconFamily), &m_iconRef );
         HUnlock((Handle) iconFamily);

-        wxASSERT_MSG( err == noErr , wxT("Error when constructing icon ref") );

         DisposeHandle( (Handle) iconFamily ) ;
         DisposeHandle( (Handle) iconFamily ) ;

+
+        wxCHECK_MSG( err == noErr, NULL, wxT("Error when constructing icon ref") );

     }
 
     return m_iconRef ;
     }
 
     return m_iconRef ;


@@ -585,77 +577,6 @@ PicHandle wxBitmapRefData::GetPictHandle()
 {
     if ( m_pictHandle == NULL )
     {
 {
     if ( m_pictHandle == NULL )
     {

-#if !wxMAC_USE_CORE_GRAPHICS
-        CGrafPtr origPort = NULL ;
-        GDHandle origDev = NULL ;
-        GWorldPtr wp = NULL ;
-        GWorldPtr mask = NULL ;
-        int height = GetHeight() ;
-        int width = GetWidth() ;
-
-        Rect rect = { 0 , 0 , height , width } ;
-        RgnHandle clipRgn = NULL ;
-
-        GetGWorld( &origPort , &origDev ) ;
-        wp = GetHBITMAP( &mask ) ;
-
-        if ( mask )
-        {
-            GWorldPtr monoworld ;
-            clipRgn = NewRgn() ;
-            OSStatus err = NewGWorld( &monoworld , 1 , &rect , NULL , NULL , 0 ) ;
-            verify_noerr(err) ;
-            LockPixels( GetGWorldPixMap( monoworld ) ) ;
-            LockPixels( GetGWorldPixMap( mask ) ) ;
-            SetGWorld( monoworld , NULL ) ;
-
-            RGBColor white = { 0xffff , 0xffff , 0xffff } ;
-            RGBColor black = { 0x0000 , 0x0000 , 0x0000 } ;
-            RGBForeColor( &black ) ;
-            RGBBackColor( &white ) ;
-
-            CopyBits(GetPortBitMapForCopyBits(mask),
-                    GetPortBitMapForCopyBits(monoworld),
-                    &rect,
-                    &rect,
-                    srcCopy, NULL);
-            BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( monoworld ) ) ;
-
-            UnlockPixels( GetGWorldPixMap( monoworld ) ) ;
-            UnlockPixels( GetGWorldPixMap( mask ) ) ;
-            DisposeGWorld( monoworld ) ;
-        }
-
-        SetGWorld( wp , NULL ) ;
-        Rect portRect ;
-        GetPortBounds( wp , &portRect ) ;
-        m_pictHandle = OpenPicture(&portRect);
-
-        if (m_pictHandle)
-        {
-            RGBColor white = { 0xffff , 0xffff , 0xffff } ;
-            RGBColor black = { 0x0000 , 0x0000 , 0x0000 } ;
-
-            RGBForeColor( &black ) ;
-            RGBBackColor( &white ) ;
-
-            if ( clipRgn )
-                SetClip( clipRgn ) ;
-
-            LockPixels( GetGWorldPixMap( wp ) ) ;
-            CopyBits(GetPortBitMapForCopyBits(wp),
-                    GetPortBitMapForCopyBits(wp),
-                    &portRect,
-                    &portRect,
-                    srcCopy,clipRgn);
-            UnlockPixels( GetGWorldPixMap( wp ) ) ;
-            ClosePicture();
-        }
-
-        SetGWorld( origPort , origDev ) ;
-        if ( clipRgn )
-            DisposeRgn( clipRgn ) ;
-#else

 #ifndef __LP64__
         GraphicsExportComponent exporter = 0;
         OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePicture, &exporter);
 #ifndef __LP64__
         GraphicsExportComponent exporter = 0;
         OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePicture, &exporter);


@@ -666,7 +587,7 @@ PicHandle wxBitmapRefData::GetPictHandle()
             {
                 // QT does not correctly export the mask
                 // TODO if we get around to it create a synthetic PICT with the CopyBits and Mask commands
             {
                 // QT does not correctly export the mask
                 // TODO if we get around to it create a synthetic PICT with the CopyBits and Mask commands

-                CGImageRef imageRef = CGImageCreate();
+                CGImageRef imageRef = CreateCGImage();

                 err = GraphicsExportSetInputCGImage( exporter, imageRef );
                 err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
                 err = GraphicsExportDoExport(exporter, NULL);
                 err = GraphicsExportSetInputCGImage( exporter, imageRef );
                 err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
                 err = GraphicsExportDoExport(exporter, NULL);


@@ -682,32 +603,20 @@ PicHandle wxBitmapRefData::GetPictHandle()
             }
             CloseComponent( exporter );
         }
             }
             CloseComponent( exporter );
         }

-#endif

 #endif
     }
 
     return m_pictHandle ;
 }
 
 #endif
     }
 
     return m_pictHandle ;
 }
 

-#ifdef __WXMAC_OSX__
-void wxMacMemoryBufferReleaseProc(void *info, const void *data, size_t WXUNUSED(size))
-{
-    wxMemoryBuffer* membuf = (wxMemoryBuffer*) info ;
-
-    wxASSERT( data == membuf->GetData() ) ;
-
-    delete membuf ;
-}
-
-CGImageRef wxBitmapRefData::CGImageCreate() const
+CGImageRef wxBitmapRefData::CreateCGImage() const

 {
     wxASSERT( m_ok ) ;
     wxASSERT( m_rawAccessCount >= 0 ) ;
     CGImageRef image ;
     if ( m_rawAccessCount > 0 || m_cgImageRef == NULL )
     {
 {
     wxASSERT( m_ok ) ;
     wxASSERT( m_rawAccessCount >= 0 ) ;
     CGImageRef image ;
     if ( m_rawAccessCount > 0 || m_cgImageRef == NULL )
     {

-#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4) && wxMAC_USE_CORE_GRAPHICS
-        if ( UMAGetSystemVersion() >= 0x1040 && m_depth != 1 && m_bitmapMask == NULL )
+        if ( m_depth != 1 && m_bitmapMask == NULL )

         {
             if ( m_bitmapMask )
             {
         {
             if ( m_bitmapMask )
             {


@@ -721,23 +630,21 @@ CGImageRef wxBitmapRefData::CGImageCreate() const
                 image = CGBitmapContextCreateImage( m_hBitmap );
         }
         else
                 image = CGBitmapContextCreateImage( m_hBitmap );
         }
         else

-#endif

         {
             size_t imageSize = m_height * m_bytesPerRow ;
             void * dataBuffer = m_memBuf.GetData() ;
             int w = m_width ;
             int h = m_height ;
             CGImageAlphaInfo alphaInfo = kCGImageAlphaNoneSkipFirst ;
         {
             size_t imageSize = m_height * m_bytesPerRow ;
             void * dataBuffer = m_memBuf.GetData() ;
             int w = m_width ;
             int h = m_height ;
             CGImageAlphaInfo alphaInfo = kCGImageAlphaNoneSkipFirst ;

-            wxMemoryBuffer* membuf = NULL ;
-            
+            wxMemoryBuffer membuf;
+

             if ( m_bitmapMask )
             {
                 alphaInfo = kCGImageAlphaFirst ;
             if ( m_bitmapMask )
             {
                 alphaInfo = kCGImageAlphaFirst ;

-                membuf = new wxMemoryBuffer( imageSize ) ;
-                memcpy( membuf->GetData() , dataBuffer , imageSize ) ;
+                unsigned char *destalphastart = (unsigned char*) membuf.GetWriteBuf( imageSize ) ;
+                memcpy( destalphastart , dataBuffer , imageSize ) ;

                 unsigned char *sourcemaskstart = (unsigned char *) m_bitmapMask->GetRawAccess() ;
                 int maskrowbytes = m_bitmapMask->GetBytesPerRow() ;
                 unsigned char *sourcemaskstart = (unsigned char *) m_bitmapMask->GetRawAccess() ;
                 int maskrowbytes = m_bitmapMask->GetBytesPerRow() ;

-                unsigned char *destalphastart = (unsigned char *) membuf->GetData() ;

                 for ( int y = 0 ; y < h ; ++y , destalphastart += m_bytesPerRow, sourcemaskstart += maskrowbytes)
                 {
                     unsigned char *sourcemask = sourcemaskstart ;
                 for ( int y = 0 ; y < h ; ++y , destalphastart += m_bytesPerRow, sourcemaskstart += maskrowbytes)
                 {
                     unsigned char *sourcemask = sourcemaskstart ;


@@ -747,6 +654,7 @@ CGImageRef wxBitmapRefData::CGImageCreate() const
                         *destalpha = 0xFF - *sourcemask ;
                     }
                 }
                         *destalpha = 0xFF - *sourcemask ;
                     }
                 }

+                membuf.UngetWriteBuf( imageSize );

             }
             else
             {
             }
             else
             {


@@ -758,36 +666,38 @@ CGImageRef wxBitmapRefData::CGImageCreate() const
                     alphaInfo = kCGImageAlphaFirst ;
 #endif
                 }
                     alphaInfo = kCGImageAlphaFirst ;
 #endif
                 }

-                
-                membuf = new wxMemoryBuffer( m_memBuf ) ;
+
+                membuf = m_memBuf;

             }
             }

-            
+

             CGDataProviderRef dataProvider = NULL ;
             if ( m_depth == 1 )
             {
             CGDataProviderRef dataProvider = NULL ;
             if ( m_depth == 1 )
             {

-                wxMemoryBuffer* maskBuf = new wxMemoryBuffer( m_width * m_height );
-                unsigned char * maskBufData = (unsigned char *) maskBuf->GetData();
-                unsigned char * bufData = (unsigned char *) membuf->GetData() ;
+                // TODO CHECK ALIGNMENT
+                wxMemoryBuffer maskBuf;
+                unsigned char * maskBufData = (unsigned char*) maskBuf.GetWriteBuf( m_width * m_height );
+                unsigned char * bufData = (unsigned char *) membuf.GetData() ;

                 // copy one color component
                 // copy one color component

-                for( int i = 0 ; i < m_width * m_height ; ++i )
-                    maskBufData[i] = bufData[i*4+3];
+                size_t i = 0;
+                for( int y = 0 ; y < m_height ; bufData+= m_bytesPerRow, ++y )
+                {
+                    unsigned char *bufDataIter = bufData+3;
+                    for ( int x = 0 ; x < m_width ; bufDataIter += 4, ++x, ++i )
+                    {
+                        maskBufData[i] = *bufDataIter;
+                    }
+                }
+                maskBuf.UngetWriteBuf( m_width * m_height );
+

                 dataProvider =
                 dataProvider =

-                    CGDataProviderCreateWithData(
-                                                 maskBuf , (const void *) maskBufData , m_width * m_height,
-                                                 wxMacMemoryBufferReleaseProc );
-                // as we are now passing the mask buffer to the data provider, we have
-                // to release the membuf ourselves
-                delete membuf ;
-                
+                    wxMacCGDataProviderCreateWithMemoryBuffer( maskBuf );
+

                 image = ::CGImageMaskCreate( w, h, 8, 8, m_width , dataProvider, NULL, false );
             }
             else
             {
                 CGColorSpaceRef colorSpace = wxMacGetGenericRGBColorSpace();
                 image = ::CGImageMaskCreate( w, h, 8, 8, m_width , dataProvider, NULL, false );
             }
             else
             {
                 CGColorSpaceRef colorSpace = wxMacGetGenericRGBColorSpace();

-                dataProvider =
-                    CGDataProviderCreateWithData(
-                                                 membuf , (const void *)membuf->GetData() , imageSize,
-                                                 wxMacMemoryBufferReleaseProc );
+                dataProvider = wxMacCGDataProviderCreateWithMemoryBuffer( membuf );

                 image =
                     ::CGImageCreate(
                                     w, h, 8 , 32 , m_bytesPerRow , colorSpace, alphaInfo ,
                 image =
                     ::CGImageCreate(
                                     w, h, 8 , 32 , m_bytesPerRow , colorSpace, alphaInfo ,


@@ -811,75 +721,21 @@ CGImageRef wxBitmapRefData::CGImageCreate() const
 
     return image ;
 }
 
     return image ;
 }

-#endif

 
 

-#if wxMAC_USE_CORE_GRAPHICS 

 CGContextRef wxBitmapRefData::GetBitmapContext() const
 {
     return m_hBitmap;
 }
 CGContextRef wxBitmapRefData::GetBitmapContext() const
 {
     return m_hBitmap;
 }

-#else
-GWorldPtr wxBitmapRefData::GetHBITMAP(GWorldPtr* mask) const
-{
-    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
-    if ( mask )
-    {
-        *mask = NULL ;
-        if ( m_bitmapMask )
-        {
-            *mask = (GWorldPtr) m_bitmapMask->GetHBITMAP() ;
-        }
-        else if ( m_hasAlpha )
-        {
-            if ( m_rawAccessCount > 0 )
-                UpdateAlphaMask() ;
-            *mask = m_hMaskBitmap ;
-        }
-    }
-
-    return m_hBitmap ;
-}
-#endif
-
-#if !wxMAC_USE_CORE_GRAPHICS 
-void wxBitmapRefData::UpdateAlphaMask() const
-{
-    if ( m_hasAlpha )
-    {
-        unsigned char *sourcemask = (unsigned char *) GetRawAccess() ;
-        unsigned char *destalphabase = (unsigned char *) m_maskMemBuf.GetData() ;
-
-        int h = GetHeight() ;
-        int w = GetWidth() ;
-
-        for ( int y = 0 ; y < h ; ++y , destalphabase += m_maskBytesPerRow )
-        {
-            unsigned char* destalpha = destalphabase ;
-
-            for ( int x = 0 ; x < w ; ++x , sourcemask += 4 )
-            {
-                // we must have 24 bit depth for non quartz smooth alpha
-                *destalpha++ = 255 ;
-                *destalpha++ = 255  - *sourcemask ;
-                *destalpha++ = 255  - *sourcemask ;
-                *destalpha++ = 255  - *sourcemask ;
-            }
-        }
-    }
-}
-#endif

 
 void wxBitmapRefData::Free()
 {
     wxASSERT_MSG( m_rawAccessCount == 0 , wxT("Bitmap still selected when destroyed") ) ;
 
 
 void wxBitmapRefData::Free()
 {
     wxASSERT_MSG( m_rawAccessCount == 0 , wxT("Bitmap still selected when destroyed") ) ;
 

-#ifdef __WXMAC_OSX__

     if ( m_cgImageRef )
     {
         CGImageRelease( m_cgImageRef ) ;
         m_cgImageRef = NULL ;
     }
     if ( m_cgImageRef )
     {
         CGImageRelease( m_cgImageRef ) ;
         m_cgImageRef = NULL ;
     }

-#endif

 
     if ( m_iconRef )
     {
 
     if ( m_iconRef )
     {


@@ -897,21 +753,10 @@ void wxBitmapRefData::Free()
 
     if ( m_hBitmap )
     {
 
     if ( m_hBitmap )
     {

-#if !wxMAC_USE_CORE_GRAPHICS
-        DisposeGWorld( MAC_WXHBITMAP(m_hBitmap) ) ;
-#else

         CGContextRelease(m_hBitmap);
         CGContextRelease(m_hBitmap);

-#endif

         m_hBitmap = NULL ;
     }
 
         m_hBitmap = NULL ;
     }
 

-#if !wxMAC_USE_CORE_GRAPHICS
-    if ( m_hMaskBitmap )
-    {
-        DisposeGWorld( MAC_WXHBITMAP(m_hMaskBitmap) ) ;
-        m_hMaskBitmap = NULL ;
-    }
-#endif

     if (m_bitmapMask)
     {
         delete m_bitmapMask;
     if (m_bitmapMask)
     {
         delete m_bitmapMask;


@@ -1001,7 +846,7 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
                     *destination++ = ( (*source++) * a + 127 ) / 255;
                     *destination++ = ( (*source++) * a + 127 ) / 255;
                     *destination++ = ( (*source++) * a + 127 ) / 255;
                     *destination++ = ( (*source++) * a + 127 ) / 255;
                     *destination++ = ( (*source++) * a + 127 ) / 255;
                     *destination++ = ( (*source++) * a + 127 ) / 255;

-#else                    
+#else

                     *destination++ = *source++ ;
                     *destination++ = *source++ ;
                     *destination++ = *source++ ;
                     *destination++ = *source++ ;
                     *destination++ = *source++ ;
                     *destination++ = *source++ ;


@@ -1039,51 +884,56 @@ wxBitmap::~wxBitmap()
 
 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
 {
 
 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
 {

-    m_refData = new wxBitmapRefData( the_width , the_height , no_bits ) ;
+    wxBitmapRefData* bitmapRefData;

 
 

-    if ( no_bits == 1 )
-    {
-        int linesize = ( the_width / (sizeof(unsigned char) * 8)) ;
-        if ( the_width % (sizeof(unsigned char) * 8) )
-            linesize += sizeof(unsigned char);
+    m_refData = bitmapRefData = new wxBitmapRefData( the_width , the_height , no_bits ) ;

 
 

-        unsigned char* linestart = (unsigned char*) bits ;
-        unsigned char* destptr = (unsigned char*) BeginRawAccess() ;
-
-        for ( int y = 0 ; y < the_height ; ++y , linestart += linesize, destptr += M_BITMAPDATA->GetBytesPerRow() )
+    if (bitmapRefData->IsOk())
+    {
+        if ( no_bits == 1 )

         {
         {

-            unsigned char* destination = destptr;
-            int index, bit, mask;
+            int linesize = ( the_width / (sizeof(unsigned char) * 8)) ;
+            if ( the_width % (sizeof(unsigned char) * 8) )
+                linesize += sizeof(unsigned char);

 
 

-            for ( int x = 0 ; x < the_width ; ++x )
+            unsigned char* linestart = (unsigned char*) bits ;
+            unsigned char* destptr = (unsigned char*) BeginRawAccess() ;
+
+            for ( int y = 0 ; y < the_height ; ++y , linestart += linesize, destptr += M_BITMAPDATA->GetBytesPerRow() )

             {
             {

-                index = x / 8 ;
-                bit = x % 8 ;
-                mask = 1 << bit ;
+                unsigned char* destination = destptr;
+                int index, bit, mask;

 
 

-                if ( linestart[index] & mask )
-                {
-                    *destination++ = 0xFF ;
-                    *destination++ = 0 ;
-                    *destination++ = 0 ;
-                    *destination++ = 0 ;
-                }
-                else
+                for ( int x = 0 ; x < the_width ; ++x )

                 {
                 {

-                    *destination++ = 0xFF ;
-                    *destination++ = 0xFF ;
-                    *destination++ = 0xFF ;
-                    *destination++ = 0xFF ;
+                    index = x / 8 ;
+                    bit = x % 8 ;
+                    mask = 1 << bit ;
+
+                    if ( linestart[index] & mask )
+                    {
+                        *destination++ = 0xFF ;
+                        *destination++ = 0 ;
+                        *destination++ = 0 ;
+                        *destination++ = 0 ;
+                    }
+                    else
+                    {
+                        *destination++ = 0xFF ;
+                        *destination++ = 0xFF ;
+                        *destination++ = 0xFF ;
+                        *destination++ = 0xFF ;
+                    }

                 }
             }
                 }
             }

-        }

 
 

-        EndRawAccess() ;
-    }
-    else
-    {
-        wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
-    }
+            EndRawAccess() ;
+        }
+        else
+        {
+            wxFAIL_MSG(wxT("multicolor BITMAPs not yet implemented"));
+        }
+    } /* bitmapRefData->IsOk() */

 }
 
 wxBitmap::wxBitmap(int w, int h, int d)
 }
 
 wxBitmap::wxBitmap(int w, int h, int d)


@@ -1101,12 +951,12 @@ wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
     LoadFile(filename, type);
 }
 
     LoadFile(filename, type);
 }
 

-wxObjectRefData* wxBitmap::CreateRefData() const
+wxGDIRefData* wxBitmap::CreateGDIRefData() const

 {
     return new wxBitmapRefData;
 }
 
 {
     return new wxBitmapRefData;
 }
 

-wxObjectRefData* wxBitmap::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const

 {
     return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
 }
 {
     return new wxBitmapRefData(*wx_static_cast(const wxBitmapRefData *, data));
 }


@@ -1132,14 +982,26 @@ void wxBitmap::EndRawAccess()
     M_BITMAPDATA->EndRawAccess() ;
 }
 
     M_BITMAPDATA->EndRawAccess() ;
 }
 

-#ifdef __WXMAC_OSX__
-WXCGIMAGEREF wxBitmap::CGImageCreate() const
+CGImageRef wxBitmap::CreateCGImage() const

 {
     wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
 
 {
     wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
 

-    return M_BITMAPDATA->CGImageCreate() ;
+    return M_BITMAPDATA->CreateCGImage() ;
+}
+
+IconRef wxBitmap::GetIconRef() const
+{
+    wxCHECK_MSG( Ok(), NULL , wxT("invalid bitmap") ) ;
+
+    return M_BITMAPDATA->GetIconRef() ;
+}
+
+IconRef wxBitmap::CreateIconRef() const
+{
+    IconRef icon = GetIconRef();
+    verify_noerr( AcquireIconRef(icon) );
+    return icon;

 }
 }

-#endif

 
 wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
 {
 
 wxBitmap wxBitmap::GetSubBitmap(const wxRect &rect) const
 {


@@ -1212,7 +1074,7 @@ bool wxBitmap::Create(int w, int h, int d)
 
     m_refData = new wxBitmapRefData( w , h , d );
 
 
     m_refData = new wxBitmapRefData( w , h , d );
 

-    return M_BITMAPDATA->Ok() ;
+    return M_BITMAPDATA->IsOk() ;

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


@@ -1268,68 +1130,73 @@ bool wxBitmap::Create(const void* data, wxBitmapType type, int width, int height
 wxBitmap::wxBitmap(const wxImage& image, int depth)
 {
     wxCHECK_RET( image.Ok(), wxT("invalid image") );
 wxBitmap::wxBitmap(const wxImage& image, int depth)
 {
     wxCHECK_RET( image.Ok(), wxT("invalid image") );

-    
+

     // width and height of the device-dependent bitmap
     int width = image.GetWidth();
     int height = image.GetHeight();
     // width and height of the device-dependent bitmap
     int width = image.GetWidth();
     int height = image.GetHeight();

+
+    wxBitmapRefData* bitmapRefData;

     
     

-    m_refData = new wxBitmapRefData( width , height , depth ) ;
-    
-    // Create picture
-    
-    bool hasAlpha = false ;
-    
-    if ( image.HasMask() )
-    {
-        // takes precedence, don't mix with alpha info
-    }
-    else
-    {
-        hasAlpha = image.HasAlpha() ;
-    }
-    
-    if ( hasAlpha )
-        UseAlpha() ;
-    
-    unsigned char* destinationstart = (unsigned char*) BeginRawAccess() ;
-    register unsigned char* data = image.GetData();
-    if ( destinationstart != NULL && data != NULL )
+    m_refData = bitmapRefData = new wxBitmapRefData( width , height , depth ) ;
+
+    if ( bitmapRefData->IsOk())

     {
     {

-        const unsigned char *alpha = hasAlpha ? image.GetAlpha() : NULL ;
-        for (int y = 0; y < height; destinationstart += M_BITMAPDATA->GetBytesPerRow(), y++)
+        // Create picture
+
+        bool hasAlpha = false ;
+
+        if ( image.HasMask() )
+        {
+            // takes precedence, don't mix with alpha info
+        }
+        else
+        {
+            hasAlpha = image.HasAlpha() ;
+        }
+
+        if ( hasAlpha )
+            UseAlpha() ;
+
+        unsigned char* destinationstart = (unsigned char*) BeginRawAccess() ;
+        register unsigned char* data = image.GetData();
+        if ( destinationstart != NULL && data != NULL )

         {
         {

-            unsigned char * destination = destinationstart;
-            for (int x = 0; x < width; x++)
+            const unsigned char *alpha = hasAlpha ? image.GetAlpha() : NULL ;
+            for (int y = 0; y < height; destinationstart += M_BITMAPDATA->GetBytesPerRow(), y++)

             {
             {

-                if ( hasAlpha )
+                unsigned char * destination = destinationstart;
+                for (int x = 0; x < width; x++)

                 {
                 {

-                    const unsigned char a = *alpha++;
-                    *destination++ = a ;
-                    
-#if wxMAC_USE_PREMULTIPLIED_ALPHA
-                    *destination++ = ((*data++) * a + 127) / 255 ;
-                    *destination++ = ((*data++) * a + 127) / 255 ;
-                    *destination++ = ((*data++) * a + 127) / 255 ;
-#else
-                    *destination++ = *data++ ;
-                    *destination++ = *data++ ;
-                    *destination++ = *data++ ;
-#endif
-                }
-                else
-                {
-                    *destination++ = 0xFF ;
-                    *destination++ = *data++ ;
-                    *destination++ = *data++ ;
-                    *destination++ = *data++ ;
+                    if ( hasAlpha )
+                    {
+                        const unsigned char a = *alpha++;
+                        *destination++ = a ;
+
+    #if wxMAC_USE_PREMULTIPLIED_ALPHA
+                        *destination++ = ((*data++) * a + 127) / 255 ;
+                        *destination++ = ((*data++) * a + 127) / 255 ;
+                        *destination++ = ((*data++) * a + 127) / 255 ;
+    #else
+                        *destination++ = *data++ ;
+                        *destination++ = *data++ ;
+                        *destination++ = *data++ ;
+    #endif
+                    }
+                    else
+                    {
+                        *destination++ = 0xFF ;
+                        *destination++ = *data++ ;
+                        *destination++ = *data++ ;
+                        *destination++ = *data++ ;
+                    }

                 }
             }
                 }
             }

+
+            EndRawAccess() ;

         }
         }

-        
-        EndRawAccess() ;
-    }
-    if ( image.HasMask() )
-        SetMask( new wxMask( *this , wxColour( image.GetMaskRed() , image.GetMaskGreen() , image.GetMaskBlue() ) ) ) ;
+        if ( image.HasMask() )
+            SetMask( new wxMask( *this , wxColour( image.GetMaskRed() , image.GetMaskGreen() , image.GetMaskBlue() ) ) ) ;
+    } /* bitmapRefData->IsOk() */

 }
 
 wxImage wxBitmap::ConvertToImage() const
 }
 
 wxImage wxBitmap::ConvertToImage() const


@@ -1411,11 +1278,6 @@ wxImage wxBitmap::ConvertToImage() const
                 }
                 else if ( r == MASK_RED && g == MASK_GREEN && b == MASK_BLUE )
                     b = MASK_BLUE_REPLACEMENT ;
                 }
                 else if ( r == MASK_RED && g == MASK_GREEN && b == MASK_BLUE )
                     b = MASK_BLUE_REPLACEMENT ;

-#if !wxMAC_USE_CORE_GRAPHICS
-                maskp++ ;
-                maskp++ ;
-                maskp++ ;
-#endif

             }
             else if ( hasAlpha )
             {
             }
             else if ( hasAlpha )
             {


@@ -1471,11 +1333,6 @@ bool wxBitmap::SaveFile( const wxString& filename,
     return success;
 }
 
     return success;
 }
 

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

 int wxBitmap::GetHeight() const
 {
    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 int wxBitmap::GetHeight() const
 {
    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );


@@ -1561,11 +1418,9 @@ void wxBitmap::SetMask(wxMask *mask)
 
 WXHBITMAP wxBitmap::GetHBITMAP(WXHBITMAP* mask) const
 {
 
 WXHBITMAP wxBitmap::GetHBITMAP(WXHBITMAP* mask) const
 {

-#if !wxMAC_USE_CORE_GRAPHICS
-    return WXHBITMAP(M_BITMAPDATA->GetHBITMAP((GWorldPtr*)mask));
-#else
+    wxUnusedVar(mask);
+

     return WXHBITMAP(M_BITMAPDATA->GetBitmapContext());
     return WXHBITMAP(M_BITMAPDATA->GetBitmapContext());

-#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1620,11 +1475,7 @@ wxMask::~wxMask()
 {
     if ( m_maskBitmap )
     {
 {
     if ( m_maskBitmap )
     {

-#if wxMAC_USE_CORE_GRAPHICS

         CGContextRelease( (CGContextRef) m_maskBitmap );
         CGContextRelease( (CGContextRef) m_maskBitmap );

-#else
-        DisposeGWorld( (GWorldPtr)m_maskBitmap ) ;
-#endif

         m_maskBitmap = NULL ;
     }
 }
         m_maskBitmap = NULL ;
     }
 }


@@ -1647,32 +1498,19 @@ void wxMask::RealizeNative()
 {
     if ( m_maskBitmap )
     {
 {
     if ( m_maskBitmap )
     {

-#if wxMAC_USE_CORE_GRAPHICS

         CGContextRelease( (CGContextRef) m_maskBitmap );
         CGContextRelease( (CGContextRef) m_maskBitmap );

-#else
-       DisposeGWorld( (GWorldPtr)m_maskBitmap ) ;
-#endif

        m_maskBitmap = NULL ;
     }
 
        m_maskBitmap = NULL ;
     }
 

-#if wxMAC_USE_CORE_GRAPHICS

     CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceGray();
     // from MouseTracking sample :
     CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceGray();
     // from MouseTracking sample :

-    // Ironically, due to a bug in CGImageCreateWithMask, you cannot use 
+    // Ironically, due to a bug in CGImageCreateWithMask, you cannot use

     // CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) at this point!
     // CGColorSpaceCreateWithName(kCGColorSpaceGenericGray) at this point!

-    
-    m_maskBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, colorspace, 
+
+    m_maskBitmap = CGBitmapContextCreate((char*) m_memBuf.GetData(), m_width, m_height, 8, m_bytesPerRow, colorspace,

         kCGImageAlphaNone );
     CGColorSpaceRelease( colorspace );
     wxASSERT_MSG( m_maskBitmap , wxT("Unable to create CGBitmapContext context") ) ;
         kCGImageAlphaNone );
     CGColorSpaceRelease( colorspace );
     wxASSERT_MSG( m_maskBitmap , wxT("Unable to create CGBitmapContext context") ) ;

-#else
-    Rect rect = { 0 , 0 , m_height , m_width } ;
-
-    OSStatus err = NewGWorldFromPtr(
-        (GWorldPtr*) &m_maskBitmap , k32ARGBPixelFormat , &rect , NULL , NULL , 0 ,
-        (char*) m_memBuf.GetData() , m_bytesPerRow ) ;
-    verify_noerr( err ) ;
-#endif

 }
 
 // Create a mask from a mono bitmap (copies the bitmap).
 }
 
 // Create a mask from a mono bitmap (copies the bitmap).


@@ -1718,23 +1556,9 @@ bool wxMask::Create(const wxBitmap& bitmap)
             b = *srcdata++ ;
 
             if ( ( r + g + b ) > 0x10 )
             b = *srcdata++ ;
 
             if ( ( r + g + b ) > 0x10 )

-            {

                 *destdata++ = 0xFF ;
                 *destdata++ = 0xFF ;

-#if !wxMAC_USE_CORE_GRAPHICS
-                *destdata++ = 0xFF ;
-                *destdata++ = 0xFF ;
-                *destdata++ = 0xFF ;
-#endif
-            }

             else
             else

-            {
-                *destdata++ = 0x00 ;
-#if !wxMAC_USE_CORE_GRAPHICS
-                *destdata++ = 0x00 ;

                 *destdata++ = 0x00 ;
                 *destdata++ = 0x00 ;

-                *destdata++ = 0x00 ;
-#endif
-            }

         }
     }
 
         }
     }
 


@@ -1774,23 +1598,9 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
             b = *srcdata++ ;
 
             if ( colour == wxColour( r , g , b ) )
             b = *srcdata++ ;
 
             if ( colour == wxColour( r , g , b ) )

-            {

                 *destdata++ = 0xFF ;
                 *destdata++ = 0xFF ;

-#if !wxMAC_USE_CORE_GRAPHICS
-                *destdata++ = 0xFF ;
-                *destdata++ = 0xFF ;
-                *destdata++ = 0xFF ;
-#endif
-            }

             else
             else

-            {
-                *destdata++ = 0x00 ;
-#if !wxMAC_USE_CORE_GRAPHICS
-                *destdata++ = 0x00 ;

                 *destdata++ = 0x00 ;
                 *destdata++ = 0x00 ;

-                *destdata++ = 0x00 ;
-#endif
-            }

         }
     }
 
         }
     }
 


@@ -1815,6 +1625,8 @@ IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
 // Standard Handlers
 // ----------------------------------------------------------------------------
 
 // Standard Handlers
 // ----------------------------------------------------------------------------
 

+#ifndef __LP64__
+

 class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
 {
     DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)
 class WXDLLEXPORT wxPICTResourceHandler: public wxBitmapHandler
 {
     DECLARE_DYNAMIC_CLASS(wxPICTResourceHandler)


@@ -1862,10 +1674,13 @@ bool wxPICTResourceHandler::LoadFile(wxBitmap *bitmap,
 
     return false ;
 }
 
     return false ;
 }

+#endif

 
 void wxBitmap::InitStandardHandlers()
 {
 
 void wxBitmap::InitStandardHandlers()
 {

+#ifndef __LP64__

     AddHandler( new wxPICTResourceHandler ) ;
     AddHandler( new wxPICTResourceHandler ) ;

+#endif

     AddHandler( new wxICONResourceHandler ) ;
 }
 
     AddHandler( new wxICONResourceHandler ) ;
 }