]> git.saurik.com Git - wxWidgets.git/blobdiff - src/osx/carbon/utilscocoa.mm
Explicitly set "C" locale for the tests using decimal point.
[wxWidgets.git] / src / osx / carbon / utilscocoa.mm
index bf7392e89239256ca1dfe6620ec62a90520b7da1..49fc2247d066943a578cbb173037f6bd6b11986a 100644 (file)
 
 #include "wx/fontutil.h"
 
 
 #include "wx/fontutil.h"
 
+#if wxOSX_USE_COCOA
+#include "wx/cocoa/string.h"
+#endif
+
 #ifdef __WXMAC__
 
 #if wxOSX_USE_CARBON
 #ifdef __WXMAC__
 
 #if wxOSX_USE_CARBON
@@ -46,27 +50,37 @@ wxMacAutoreleasePool::~wxMacAutoreleasePool()
 
 #endif
 
 
 #endif
 
-#if wxOSX_USE_COCOA_OR_IPHONE
+#if wxOSX_USE_COCOA
 
 
-CGContextRef wxOSXGetContextFromCurrentNSContext()
+CGContextRef wxOSXGetContextFromCurrentContext()
 {
     CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext]
                                           graphicsPort];
     return context;
 }
 
 {
     CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext]
                                           graphicsPort];
     return context;
 }
 
-bool wxOSXLockFocus( WXWidget view) 
+bool wxOSXLockFocus( WXWidget view)
 {
     return [view lockFocusIfCanDraw];
 }
 
 {
     return [view lockFocusIfCanDraw];
 }
 
-void wxOSXUnlockFocus( WXWidget view) 
+void wxOSXUnlockFocus( WXWidget view)
 {
     [view unlockFocus];
 }
 
 #endif
 
 {
     [view unlockFocus];
 }
 
 #endif
 
+#if wxOSX_USE_IPHONE
+
+CGContextRef wxOSXGetContextFromCurrentContext()
+{
+    CGContextRef context = UIGraphicsGetCurrentContext();
+    return context;
+}
+
+#endif
+
 // ----------------------------------------------------------------------------
 // NSObject Utils
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // NSObject Utils
 // ----------------------------------------------------------------------------
@@ -92,10 +106,52 @@ void* wxMacCocoaRetain( void* obj )
 // ----------------------------------------------------------------------------
 
 #if wxOSX_USE_COCOA
 // ----------------------------------------------------------------------------
 
 #if wxOSX_USE_COCOA
+wxFont::wxFont(WX_NSFont nsfont)
+{
+    [nsfont retain];
+    wxNativeFontInfo info;
+    SetNativeInfoFromNSFont(nsfont, &info);
+    Create(info);
+}
+
+void wxFont::SetNativeInfoFromNSFont(WX_NSFont theFont, wxNativeFontInfo* info)
+{   
+    if ( info->m_faceName.empty())
+    {
+        //Get more information about the user's chosen font
+        NSFontTraitMask theTraits = [[NSFontManager sharedFontManager] traitsOfFont:theFont];
+        int theFontWeight = [[NSFontManager sharedFontManager] weightOfFont:theFont];
 
 
-WX_NSFont wxFont::CreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info)
+        wxFontFamily fontFamily = wxFONTFAMILY_DEFAULT;
+        //Set the wx font to the appropriate data
+        if(theTraits & NSFixedPitchFontMask)
+            fontFamily = wxFONTFAMILY_TELETYPE;
+
+        wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
+        wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
+        bool underlined = false;
+
+        int size = (int) ([theFont pointSize]+0.5);
+        if ( theFontWeight >= 9 )
+            fontweight = wxFONTWEIGHT_BOLD ;
+        else if ( theFontWeight < 5 )
+            fontweight = wxFONTWEIGHT_LIGHT;
+        else
+            fontweight = wxFONTWEIGHT_NORMAL ;
+            
+        if ( theTraits & NSItalicFontMask )
+            fontstyle = wxFONTSTYLE_ITALIC ;
+
+        info->Init(size,fontFamily,fontstyle,fontweight,underlined,
+            wxStringWithNSString([theFont familyName]), wxFONTENCODING_DEFAULT);
+
+    }
+}
+
+WX_NSFont wxFont::OSXCreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info)
 {
 {
-    NSFont* nsfont;
+    NSFont* nsfont = nil;
     switch( font )
     {
         case wxOSX_SYSTEM_FONT_NORMAL:
     switch( font )
     {
         case wxOSX_SYSTEM_FONT_NORMAL:
@@ -111,15 +167,15 @@ WX_NSFont wxFont::CreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info)
             nsfont = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]];
             break;
         case wxOSX_SYSTEM_FONT_MINI:
             nsfont = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]];
             break;
         case wxOSX_SYSTEM_FONT_MINI:
-            nsfont = [NSFont systemFontOfSize:[NSFont systemFontSize]];
+            nsfont = [NSFont systemFontOfSize:
+                [NSFont systemFontSizeForControlSize:NSMiniControlSize]];
             break;
        case wxOSX_SYSTEM_FONT_MINI_BOLD:
             nsfont = [NSFont boldSystemFontOfSize:
                 [NSFont systemFontSizeForControlSize:NSMiniControlSize]];
             break;
         case wxOSX_SYSTEM_FONT_LABELS:
             break;
        case wxOSX_SYSTEM_FONT_MINI_BOLD:
             nsfont = [NSFont boldSystemFontOfSize:
                 [NSFont systemFontSizeForControlSize:NSMiniControlSize]];
             break;
         case wxOSX_SYSTEM_FONT_LABELS:
-            nsfont = [NSFont labelFontOfSize:
-                [NSFont systemFontSizeForControlSize:NSMiniControlSize]];
+            nsfont = [NSFont labelFontOfSize:[NSFont labelFontSize]];
             break;
        case wxOSX_SYSTEM_FONT_VIEWS:
             nsfont = [NSFont controlContentFontOfSize:0];
             break;
        case wxOSX_SYSTEM_FONT_VIEWS:
             nsfont = [NSFont controlContentFontOfSize:0];
@@ -128,84 +184,197 @@ WX_NSFont wxFont::CreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info)
             break;
     }
     [nsfont retain];
             break;
     }
     [nsfont retain];
-    NSFontDescriptor*desc = [[nsfont fontDescriptor] retain];
+    SetNativeInfoFromNSFont(nsfont, info);
+    return nsfont;
+}
+
+static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
+static const NSAffineTransformStruct kSlantNSTransformStruct = { 1, 0, tan(DegToRad(11)), 1, 0, 0  };
+
+WX_NSFont wxFont::OSXCreateNSFont(const wxNativeFontInfo* info)
+{
+    NSFont* nsFont;
+    int weight = 5;
+    NSFontTraitMask traits = 0;
+    if (info->m_weight == wxFONTWEIGHT_BOLD)
+    {
+        traits |= NSBoldFontMask;
+        weight = 9;
+    }
+    else if (info->m_weight == wxFONTWEIGHT_LIGHT)
+        weight = 3;
+
+    if (info->m_style == wxFONTSTYLE_ITALIC || info->m_style == wxFONTSTYLE_SLANT)
+        traits |= NSItalicFontMask;
+    
+    nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString() 
+        traits:traits weight:weight size:info->m_pointSize];
+    
+    if ( nsFont == nil )
+    {
+        NSFontTraitMask remainingTraits = traits;
+        nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString() 
+                                                            traits:0 weight:5 size:info->m_pointSize];
+        if ( nsFont == nil )
+        {
+            if ( info->m_weight == wxFONTWEIGHT_BOLD )
+            {
+                nsFont = [NSFont boldSystemFontOfSize:info->m_pointSize];
+                remainingTraits &= ~NSBoldFontMask;
+            }
+            else
+                nsFont = [NSFont systemFontOfSize:info->m_pointSize];
+        }
+        
+        // fallback - if in doubt, let go of the bold attribute
+        if ( nsFont && (remainingTraits & NSItalicFontMask) )
+        {
+            NSFont* nsFontWithTraits = nil;
+            if ( remainingTraits & NSBoldFontMask)
+            {
+                nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSBoldFontMask];
+                if ( nsFontWithTraits == nil )
+                {
+                    nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSItalicFontMask];
+                    if ( nsFontWithTraits != nil )
+                        remainingTraits &= ~NSItalicFontMask;
+                }
+                else
+                {
+                    remainingTraits &= ~NSBoldFontMask;
+                }
+            }
+            // the code below causes crashes, because fontDescriptorWithMatrix is not returning a valid font descriptor
+            // it adds a NSCTFontMatrixAttribute as well which cannot be disposed of correctly by the autorelease pool
+            // so at the moment we have to disable this and cannot synthesize italic fonts if they are not available on the system
+#if 0
+            if ( remainingTraits & NSItalicFontMask )
+            {
+                if ( nsFontWithTraits == nil )
+                    nsFontWithTraits = nsFont;
+                
+                NSAffineTransform* transform = [NSAffineTransform transform];
+                [transform setTransformStruct:kSlantNSTransformStruct];
+                [transform scaleBy:info->m_pointSize];
+                NSFontDescriptor* italicDesc = [[nsFontWithTraits fontDescriptor] fontDescriptorWithMatrix:transform];
+                if ( italicDesc != nil )
+                {
+                    NSFont* f = [NSFont fontWithDescriptor:italicDesc size:(CGFloat)(info->m_pointSize)];
+                    if ( f != nil )
+                        nsFontWithTraits = f;
+                }
+            }
+#endif
+            if ( nsFontWithTraits != nil )
+                nsFont = nsFontWithTraits;
+        }
+    }
+            
+    wxASSERT_MSG(nsFont != nil,wxT("Couldn't create nsFont")) ;
+    wxMacCocoaRetain(nsFont);
+    return nsFont;
+}
+
+#endif
+
+#if wxOSX_USE_IPHONE
+
+WX_UIFont wxFont::OSXCreateUIFont(wxOSXSystemFont font, wxNativeFontInfo* info)
+{
+    UIFont* uifont;
+    switch( font )
+    {
+        case wxOSX_SYSTEM_FONT_NORMAL:
+            uifont = [UIFont systemFontOfSize:[UIFont systemFontSize]];
+            break;
+        case wxOSX_SYSTEM_FONT_BOLD:
+            uifont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]];
+            break;
+        case wxOSX_SYSTEM_FONT_MINI:
+        case wxOSX_SYSTEM_FONT_SMALL:
+            uifont = [UIFont systemFontOfSize:[UIFont smallSystemFontSize]];
+            break;
+        case wxOSX_SYSTEM_FONT_MINI_BOLD:
+        case wxOSX_SYSTEM_FONT_SMALL_BOLD:
+            uifont = [UIFont boldSystemFontOfSize:[UIFont smallSystemFontSize]];
+            break;
+        case wxOSX_SYSTEM_FONT_VIEWS:
+        case wxOSX_SYSTEM_FONT_LABELS:
+            uifont = [UIFont systemFontOfSize:[UIFont labelFontSize]];
+            break;
+        default:
+            break;
+    }
+    [uifont retain];
     if ( info->m_faceName.empty())
     {
         wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
         wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
         bool underlined = false;
     if ( info->m_faceName.empty())
     {
         wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
         wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
         bool underlined = false;
-        
-        int size = (int) ([desc pointSize]+0.5);
+
+        int size = (int) ([uifont pointSize]+0.5);
+        /*
         NSFontSymbolicTraits traits = [desc symbolicTraits];
         NSFontSymbolicTraits traits = [desc symbolicTraits];
-            
+
         if ( traits & NSFontBoldTrait )
             fontweight = wxFONTWEIGHT_BOLD ;
         else
             fontweight = wxFONTWEIGHT_NORMAL ;
         if ( traits & NSFontItalicTrait )
             fontstyle = wxFONTSTYLE_ITALIC ;
         if ( traits & NSFontBoldTrait )
             fontweight = wxFONTWEIGHT_BOLD ;
         else
             fontweight = wxFONTWEIGHT_NORMAL ;
         if ( traits & NSFontItalicTrait )
             fontstyle = wxFONTSTYLE_ITALIC ;
-             
-        wxCFStringRef fontname( [desc postscriptName] );
+        */
+        wxCFStringRef fontname( wxCFRetain([uifont familyName]) );
         info->Init(size,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
             fontname.AsString(), wxFONTENCODING_DEFAULT);
         info->Init(size,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
             fontname.AsString(), wxFONTENCODING_DEFAULT);
-        
-    }
-    info->m_nsFontDescriptor = desc;
-    return nsfont;
-}
-
-void wxNativeFontInfo::ValidateNSFontDescriptor()
-{
-    NSFontDescriptor* desc  = [NSFontDescriptor fontDescriptorWithName:wxCFStringRef(m_faceName).AsNSString() size:m_pointSize];
-    NSFontSymbolicTraits traits = 0;
 
 
-    if (m_weight == wxFONTWEIGHT_BOLD)
-        traits |= NSFontBoldTrait;
-    if (m_style == wxFONTSTYLE_ITALIC || m_style == wxFONTSTYLE_SLANT)
-        traits |= NSFontItalicTrait;
-
-    if ( traits != 0 )
-    {
-        desc = [desc fontDescriptorWithSymbolicTraits:traits];
     }
     }
-    wxMacCocoaRetain(desc);
-    m_nsFontDescriptor = desc;
+    return uifont;
 }
 
 }
 
-WX_NSFont wxFont::CreateNSFont(const wxNativeFontInfo* info)
+WX_UIFont wxFont::OSXCreateUIFont(const wxNativeFontInfo* info)
 {
 {
-    NSFont* nsFont;
-    nsFont = [NSFont fontWithDescriptor:info->m_nsFontDescriptor size:info->m_pointSize];
-    wxMacCocoaRetain(nsFont);
-    return nsFont;
+    UIFont* uiFont;
+    uiFont = [UIFont fontWithName:wxCFStringRef(info->m_faceName).AsNSString() size:info->m_pointSize];
+    wxMacCocoaRetain(uiFont);
+    return uiFont;
 }
 
 #endif
 }
 
 #endif
-
 // ----------------------------------------------------------------------------
 // NSImage Utils
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // NSImage Utils
 // ----------------------------------------------------------------------------
 
+#if wxOSX_USE_IPHONE
+
+WX_UIImage  wxOSXGetUIImageFromCGImage( CGImageRef image )
+{
+    UIImage  *newImage = [UIImage imageWithCGImage:image];
+    [newImage autorelease];
+    return( newImage );
+}
+
+#endif
+
 #if wxOSX_USE_COCOA
 
 //  From "Cocoa Drawing Guide:Working with Images"
 #if wxOSX_USE_COCOA
 
 //  From "Cocoa Drawing Guide:Working with Images"
-WX_NSImage  wxOSXCreateNSImageFromCGImage( CGImageRef image )
+WX_NSImage  wxOSXGetNSImageFromCGImage( CGImageRef image )
 {
     NSRect      imageRect    = NSMakeRect(0.0, 0.0, 0.0, 0.0);
 {
     NSRect      imageRect    = NSMakeRect(0.0, 0.0, 0.0, 0.0);
-    
+
     // Get the image dimensions.
     imageRect.size.height = CGImageGetHeight(image);
     imageRect.size.width = CGImageGetWidth(image);
     // Get the image dimensions.
     imageRect.size.height = CGImageGetHeight(image);
     imageRect.size.width = CGImageGetWidth(image);
-    
+
     // Create a new image to receive the Quartz image data.
     // Create a new image to receive the Quartz image data.
-    NSImage  *newImage = [[NSImage alloc] initWithSize:imageRect.size]; 
+    NSImage  *newImage = [[NSImage alloc] initWithSize:imageRect.size];
     [newImage lockFocus];
     [newImage lockFocus];
-    
+
     // Get the Quartz context and draw.
     CGContextRef  imageContext = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
     CGContextDrawImage( imageContext, *(CGRect*)&imageRect, image );
     [newImage unlockFocus];
     // Get the Quartz context and draw.
     CGContextRef  imageContext = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
     CGContextDrawImage( imageContext, *(CGRect*)&imageRect, image );
     [newImage unlockFocus];
-    
+
     /*
         // Create a bitmap rep from the image...
         NSBitmapImageRep *bitmapRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];
     /*
         // Create a bitmap rep from the image...
         NSBitmapImageRep *bitmapRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];
@@ -218,6 +387,25 @@ WX_NSImage  wxOSXCreateNSImageFromCGImage( CGImageRef image )
     return( newImage );
 }
 
     return( newImage );
 }
 
+CGImageRef wxOSXCreateCGImageFromNSImage( WX_NSImage nsimage )
+{
+    // based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html
+    
+    NSSize imageSize = [nsimage size];
+    CGColorSpaceRef genericRGB = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); 
+    CGContextRef context = CGBitmapContextCreate(NULL, imageSize.width, imageSize.height, 8, 0, genericRGB, kCGImageAlphaPremultipliedFirst); 
+    NSGraphicsContext *nsGraphicsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
+    [NSGraphicsContext saveGraphicsState];
+    [NSGraphicsContext setCurrentContext:nsGraphicsContext];
+    [[NSColor whiteColor] setFill];
+    NSRectFill(NSMakeRect(0.0, 0.0, imageSize.width, imageSize.height));
+    [nsimage drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeCopy fraction:1.0];
+    [NSGraphicsContext setCurrentContext:nsGraphicsContext];
+    CGImageRef image = CGBitmapContextCreateImage(context);
+    CFRelease(context);
+    return image;
+ }
+
 // ----------------------------------------------------------------------------
 // NSCursor Utils
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // NSCursor Utils
 // ----------------------------------------------------------------------------
@@ -234,40 +422,49 @@ static NSCursor* wxGetStockCursor( short sIndex )
 
     //NSCursor takes an NSImage takes a number of Representations - here
     //we need only one for the raw data
 
     //NSCursor takes an NSImage takes a number of Representations - here
     //we need only one for the raw data
-    NSBitmapImageRep *theRep =
-    [[NSBitmapImageRep alloc]
-      initWithBitmapDataPlanes:nil  // Allocate the buffer for us :)
-      pixelsWide:16
-      pixelsHigh:16
-      bitsPerSample:1
-      samplesPerPixel:2
-      hasAlpha:YES                  // Well, more like a mask...
-      isPlanar:NO
-      colorSpaceName:NSCalibratedWhiteColorSpace // Normal B/W - 0 black 1 white
-      bytesPerRow:0     // I don't care - figure it out for me :)
-      bitsPerPixel:2];  // bitsPerSample * samplesPerPixel
-
-    //unsigned int is better to put data in then a void*
-    //note that working with bitfields would be a lot better here -
-    //but since it breaks some compilers...
-    wxUint32 *data = (wxUint32 *)[theRep bitmapData];
-
-    //traverse through the bitmap data
-    for (int i = 0; i < 16; ++i)
+    NSBitmapImageRep *theRep = [[NSBitmapImageRep alloc]
+        initWithBitmapDataPlanes: NULL  // Tell Cocoa to allocate the planes for us.
+        pixelsWide: 16      // All classic cursors are 16x16
+        pixelsHigh: 16
+        bitsPerSample: 1    // All classic cursors are bitmaps with bitmasks
+        samplesPerPixel: 2  // Sample 0:image 1:mask
+        hasAlpha: YES       // Identify last sample as a mask
+        isPlanar: YES       // Use a separate array for each sample
+        colorSpaceName: NSCalibratedWhiteColorSpace // 0.0=black 1.0=white
+        bytesPerRow: 2      // Rows in each plane are on 2-byte boundaries (no pad)
+        bitsPerPixel: 1];   // same as bitsPerSample since data is planar
+
+    // Ensure that Cocoa allocated 2 and only 2 of the 5 possible planes
+    unsigned char *planes[5];
+    [theRep getBitmapDataPlanes:planes];
+    wxASSERT(planes[0] != NULL);
+    wxASSERT(planes[1] != NULL);
+    wxASSERT(planes[2] == NULL);
+    wxASSERT(planes[3] == NULL);
+    wxASSERT(planes[4] == NULL);
+
+    // NOTE1: The Cursor's bits field is white=0 black=1.. thus the bitwise-not
+    // Why not use NSCalibratedBlackColorSpace?  Because that reverses the
+    // sense of the alpha (mask) plane.
+    // NOTE2: The mask data is 0=off 1=on
+    // NOTE3: Cocoa asks for "premultiplied" color planes.  Since we have a
+    // 1-bit color plane and a 1-bit alpha plane we can just do a bitwise-and
+    // on the two.  The original cursor bitmaps have 0 (white actually) for
+    // any masked-off pixels.  Therefore every masked-off pixel would be wrong
+    // since we bit-flip all of the picture bits.  In practice, Cocoa doesn't
+    // seem to care, but we are following the documentation.
+
+    // Fill in the color (black/white) plane
+    for(int i=0; i<16; ++i)
     {
     {
-        //bit alpha bit alpha ... :D
-
-        //Notice the = instead of |= -
-        //this is to avoid doing a memset earlier
-        data[i] = 0;
-
-        //do the rest of those bits and alphas :)
-        for (int shift = 0; shift < 32; ++shift)
-        {
-            const int bit = 1 << (shift >> 1);
-            data[i] |= ( !!( (pCursor->mask[i] & bit) ) ) << shift;
-            data[i] |= ( !( (pCursor->bits[i] & bit) ) ) << ++shift;
-        }
+        planes[0][2*i  ] = (~pCursor->bits[i] & pCursor->mask[i]) >> 8 & 0xff;
+        planes[0][2*i+1] = (~pCursor->bits[i] & pCursor->mask[i]) & 0xff;
+    }
+    // Fill in the alpha (i.e. mask) plane
+    for(int i=0; i<16; ++i)
+    {
+        planes[1][2*i  ] = pCursor->mask[i] >> 8 & 0xff;
+        planes[1][2*i+1] = pCursor->mask[i] & 0xff;
     }
 
     //add the representation (data) to the image
     }
 
     //add the representation (data) to the image
@@ -332,7 +529,7 @@ WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type )
     case wxCURSOR_HAND:
         cursor = [[NSCursor pointingHandCursor] retain];
         break;
     case wxCURSOR_HAND:
         cursor = [[NSCursor pointingHandCursor] retain];
         break;
-        
+
     case wxCURSOR_BULLSEYE:
         cursor = wxGetStockCursor(kwxCursorBullseye);
         break;
     case wxCURSOR_BULLSEYE:
         cursor = wxGetStockCursor(kwxCursorBullseye);
         break;
@@ -401,19 +598,17 @@ WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type )
 WX_NSCursor  wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY )
 {
     static BOOL    firstTime  = YES;
 WX_NSCursor  wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY )
 {
     static BOOL    firstTime  = YES;
-    
+
     if ( firstTime )
     {
         //  Must first call [[[NSWindow alloc] init] release] to get the NSWindow machinery set up so that NSCursor can use a window to cache the cursor image
         [[[NSWindow alloc] init] release];
         firstTime = NO;
     }
     if ( firstTime )
     {
         //  Must first call [[[NSWindow alloc] init] release] to get the NSWindow machinery set up so that NSCursor can use a window to cache the cursor image
         [[[NSWindow alloc] init] release];
         firstTime = NO;
     }
-    
-    NSImage    *nsImage  = wxOSXCreateNSImageFromCGImage( cgImageRef );
+
+    NSImage    *nsImage  = wxOSXGetNSImageFromCGImage( cgImageRef );
     NSCursor  *cursor    = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )];
     NSCursor  *cursor    = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )];
-    
-    [nsImage release];
-    
+
     return cursor;
 }
 
     return cursor;
 }