src/osx/carbon/utilscocoa.mm

/////////////////////////////////////////////////////////////////////////////
// Name:        src/osx/carbon/utilscocoa.mm
// Purpose:     various cocoa mixin utility functions
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#ifndef WX_PRECOMP
#include "wx/object.h"
#endif

#if wxOSX_USE_COCOA_OR_CARBON
#include <Cocoa/Cocoa.h>
#else
#import <UIKit/UIKit.h>
#endif

#ifdef __WXMAC__
#include "wx/osx/private.h"
#endif

#include "wx/fontutil.h"

#if wxOSX_USE_COCOA
#include "wx/cocoa/string.h"
#endif

#ifdef __WXMAC__

#if wxOSX_USE_CARBON
bool wxMacInitCocoa()
{
    bool cocoaLoaded = NSApplicationLoad();
    wxASSERT_MSG(cocoaLoaded,wxT("Couldn't load Cocoa in Carbon Environment")) ;
    return cocoaLoaded;
}
#endif

wxMacAutoreleasePool::wxMacAutoreleasePool()
{
    m_pool = [[NSAutoreleasePool alloc] init];
}

wxMacAutoreleasePool::~wxMacAutoreleasePool()
{
    [(NSAutoreleasePool*)m_pool release];
}

#endif

#if wxOSX_USE_COCOA

CGContextRef wxOSXGetContextFromCurrentContext()
{
    CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext]
                                          graphicsPort];
    return context;
}

bool wxOSXLockFocus( WXWidget view)
{
    return [view lockFocusIfCanDraw];
}

void wxOSXUnlockFocus( WXWidget view)
{
    [view unlockFocus];
}

#endif

#if wxOSX_USE_IPHONE

CGContextRef wxOSXGetContextFromCurrentContext()
{
    CGContextRef context = UIGraphicsGetCurrentContext();
    return context;
}

#endif

// ----------------------------------------------------------------------------
// NSObject Utils
// ----------------------------------------------------------------------------

void wxMacCocoaRelease( void* obj )
{
    [(NSObject*)obj release];
}

void wxMacCocoaAutorelease( void* obj )
{
    [(NSObject*)obj autorelease];
}

void* wxMacCocoaRetain( void* obj )
{
    [(NSObject*)obj retain];
    return obj;
}

// ----------------------------------------------------------------------------
// NSFont Utils
// ----------------------------------------------------------------------------

#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];

        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 = nil;
    switch( font )
    {
        case wxOSX_SYSTEM_FONT_NORMAL:
            nsfont = [NSFont systemFontOfSize:[NSFont systemFontSize]];
            break;
        case wxOSX_SYSTEM_FONT_BOLD:
            nsfont = [NSFont boldSystemFontOfSize:[NSFont systemFontSize]];
            break;
        case wxOSX_SYSTEM_FONT_SMALL:
            nsfont = [NSFont systemFontOfSize:[NSFont smallSystemFontSize]];
            break;
        case wxOSX_SYSTEM_FONT_SMALL_BOLD:
            nsfont = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]];
            break;
        case wxOSX_SYSTEM_FONT_MINI:
            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:
            nsfont = [NSFont labelFontOfSize:[NSFont labelFontSize]];
            break;
       case wxOSX_SYSTEM_FONT_VIEWS:
            nsfont = [NSFont controlContentFontOfSize:0];
            break;
        default:
            break;
    }
    [nsfont retain];
    SetNativeInfoFromNSFont(nsfont, info);
    return nsfont;
}

static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
static const NSAffineTransformStruct kSlantNSTransformStruct = { 1, 0, static_cast<CGFloat>(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;

        int size = (int) ([uifont pointSize]+0.5);
        /*
        NSFontSymbolicTraits traits = [desc symbolicTraits];

        if ( traits & NSFontBoldTrait )
            fontweight = wxFONTWEIGHT_BOLD ;
        else
            fontweight = wxFONTWEIGHT_NORMAL ;
        if ( traits & NSFontItalicTrait )
            fontstyle = wxFONTSTYLE_ITALIC ;
        */
        wxCFStringRef fontname( wxCFRetain([uifont familyName]) );
        info->Init(size,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
            fontname.AsString(), wxFONTENCODING_DEFAULT);

    }
    return uifont;
}

WX_UIFont wxFont::OSXCreateUIFont(const wxNativeFontInfo* info)
{
    UIFont* uiFont;
    uiFont = [UIFont fontWithName:wxCFStringRef(info->m_faceName).AsNSString() size:info->m_pointSize];
    wxMacCocoaRetain(uiFont);
    return uiFont;
}

#endif

// ----------------------------------------------------------------------------
// NSWindow Utils
// ----------------------------------------------------------------------------

#if wxOSX_USE_COCOA

WXWindow wxOSXGetMainWindow()
{
    return [NSApp mainWindow];
}

#endif
// ----------------------------------------------------------------------------
// NSImage Utils
// ----------------------------------------------------------------------------

#if wxOSX_USE_IPHONE

WX_UIImage  wxOSXGetUIImageFromCGImage( CGImageRef image )
{
    UIImage  *newImage = [UIImage imageWithCGImage:image];
    [newImage autorelease];
    return( newImage );
}

wxBitmap wxOSXCreateSystemBitmap(const wxString& name, const wxString &client, const wxSize& size)
{
#if 1
    // unfortunately this only accesses images in the app bundle, not the system wide globals
    wxCFStringRef cfname(name);
    return wxBitmap( [[UIImage imageNamed:cfname.AsNSString()] CGImage] );
#else
    return wxBitmap();
#endif
}

#endif

#if wxOSX_USE_COCOA

wxBitmap wxOSXCreateSystemBitmap(const wxString& name, const wxString &WXUNUSED(client), const wxSize& WXUNUSED(size))
{
    wxCFStringRef cfname(name);
    wxCFRef<CGImageRef> image( wxOSXCreateCGImageFromNSImage([NSImage imageNamed:cfname.AsNSString()]) );
    return wxBitmap( image );
}

//  From "Cocoa Drawing Guide:Working with Images"
WX_NSImage  wxOSXGetNSImageFromCGImage( CGImageRef image )
{
    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);

    // Create a new image to receive the Quartz image data.
    NSImage  *newImage = [[NSImage alloc] initWithSize:imageRect.size];
    [newImage lockFocus];

    // 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 an NSImage and add the bitmap rep to it...
        NSImage *image = [[NSImage alloc] init];
        [image addRepresentation:bitmapRep];
        [bitmapRep release];
    */
    [newImage autorelease];
    return( newImage );
}

CGImageRef wxOSXCreateCGImageFromNSImage( WX_NSImage nsimage )
{
    // based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html

    CGImageRef image = NULL;
    if (nsimage != nil)
    {
        NSSize imageSize = [nsimage size];
        CGContextRef context = CGBitmapContextCreate(NULL, imageSize.width, imageSize.height, 8, 0, wxMacGetGenericRGBColorSpace(), 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];
        image = CGBitmapContextCreateImage(context);
        CFRelease(context);
    }
    return image;
 }

// ----------------------------------------------------------------------------
// NSCursor Utils
// ----------------------------------------------------------------------------

// copied from cursor.mm

static NSCursor* wxGetStockCursor( short sIndex )
{
    ClassicCursor* pCursor = &gMacCursors[sIndex];

    //Classic mac cursors are 1bps 16x16 black and white with a
    //identical mask that is 1 for on and 0 for off
    NSImage *theImage = [[NSImage alloc] initWithSize:NSMakeSize(16.0,16.0)];

    //NSCursor takes an NSImage takes a number of Representations - here
    //we need only one for the raw data
    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)
    {
        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
    [theImage addRepresentation:theRep];

    //create the new cursor
    NSCursor* theCursor =  [[NSCursor alloc]  initWithImage:theImage
                                    hotSpot:NSMakePoint(pCursor->hotspot[1], pCursor->hotspot[0])
                            ];

    //do the usual cleanups
    [theRep release];
    [theImage release];

    //return the new cursor
    return theCursor;
}

WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type )
{
    WX_NSCursor cursor = nil;
    switch (cursor_type)
    {
    case wxCURSOR_COPY_ARROW:
        cursor = [[NSCursor arrowCursor] retain];
        break;

    case wxCURSOR_WATCH:
    case wxCURSOR_WAIT:
        // an arrow should be displayed by the system when things are running
        // according to the HIG
        // cursor = [[NSCursor arrowCursor] retain];
        // but for crossplatform compatibility we display a watch cursor
        cursor = wxGetStockCursor(kwxCursorWatch);
        break;

    case wxCURSOR_IBEAM:
        cursor = [[NSCursor IBeamCursor] retain];
        break;

    case wxCURSOR_CROSS:
        cursor = [[NSCursor crosshairCursor] retain];
        break;

    case wxCURSOR_SIZENWSE:
        cursor = wxGetStockCursor(kwxCursorSizeNWSE);
        break;

    case wxCURSOR_SIZENESW:
        cursor = wxGetStockCursor(kwxCursorSizeNESW);
        break;

    case wxCURSOR_SIZEWE:
        cursor = [[NSCursor resizeLeftRightCursor] retain];
        break;

    case wxCURSOR_SIZENS:
        cursor = [[NSCursor resizeUpDownCursor] retain];
        break;

    case wxCURSOR_SIZING:
        cursor = wxGetStockCursor(kwxCursorSize);
        break;

    case wxCURSOR_HAND:
        cursor = [[NSCursor pointingHandCursor] retain];
        break;

    case wxCURSOR_BULLSEYE:
        cursor = wxGetStockCursor(kwxCursorBullseye);
        break;

    case wxCURSOR_PENCIL:
        cursor = wxGetStockCursor(kwxCursorPencil);
        break;

    case wxCURSOR_MAGNIFIER:
        cursor = wxGetStockCursor(kwxCursorMagnifier);
        break;

    case wxCURSOR_NO_ENTRY:
        cursor = wxGetStockCursor(kwxCursorNoEntry);
        break;

    case wxCURSOR_PAINT_BRUSH:
        cursor = wxGetStockCursor(kwxCursorPaintBrush);
        break;

    case wxCURSOR_POINT_LEFT:
        cursor = wxGetStockCursor(kwxCursorPointLeft);
        break;

    case wxCURSOR_POINT_RIGHT:
        cursor = wxGetStockCursor(kwxCursorPointRight);
        break;

    case wxCURSOR_QUESTION_ARROW:
        cursor = wxGetStockCursor(kwxCursorQuestionArrow);
        break;

    case wxCURSOR_BLANK:
        cursor = wxGetStockCursor(kwxCursorBlank);
        break;

    case wxCURSOR_RIGHT_ARROW:
        cursor = wxGetStockCursor(kwxCursorRightArrow);
        break;

    case wxCURSOR_SPRAYCAN:
        cursor = wxGetStockCursor(kwxCursorRoller);
        break;

    case wxCURSOR_OPEN_HAND:
        cursor = [[NSCursor openHandCursor] retain];
        break;

    case wxCURSOR_CLOSED_HAND:
        cursor = [[NSCursor closedHandCursor] retain];
        break;

    case wxCURSOR_CHAR:
    case wxCURSOR_ARROW:
    case wxCURSOR_LEFT_BUTTON:
    case wxCURSOR_RIGHT_BUTTON:
    case wxCURSOR_MIDDLE_BUTTON:
    default:
        cursor = [[NSCursor arrowCursor] retain];
        break;
    }
    return cursor;
}

//  C-based style wrapper routines around NSCursor
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;
    }

    NSImage    *nsImage  = wxOSXGetNSImageFromCGImage( cgImageRef );
    NSCursor  *cursor    = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )];

    return cursor;
}

void  wxMacCocoaSetCursor( WX_NSCursor cursor )
{
    [cursor set];
}

void  wxMacCocoaHideCursor()
{
    [NSCursor hide];
}

void  wxMacCocoaShowCursor()
{
    [NSCursor unhide];
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/osx/carbon/utilscocoa.mm
	3	// Purpose: various cocoa mixin utility functions
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 1998-01-01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Stefan Csomor
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#include "wx/wxprec.h"
	13
	14	#ifndef WX_PRECOMP
	15	#include "wx/object.h"
	16	#endif
	17
	18	#if wxOSX_USE_COCOA_OR_CARBON
	19	#include <Cocoa/Cocoa.h>
	20	#else
	21	#import <UIKit/UIKit.h>
	22	#endif
	23
	24	#ifdef __WXMAC__
	25	#include "wx/osx/private.h"
	26	#endif
	27
	28	#include "wx/fontutil.h"
	29
	30	#if wxOSX_USE_COCOA
	31	#include "wx/cocoa/string.h"
	32	#endif
	33
	34	#ifdef __WXMAC__
	35
	36	#if wxOSX_USE_CARBON
	37	bool wxMacInitCocoa()
	38	{
	39	bool cocoaLoaded = NSApplicationLoad();
	40	wxASSERT_MSG(cocoaLoaded,wxT("Couldn't load Cocoa in Carbon Environment")) ;
	41	return cocoaLoaded;
	42	}
	43	#endif
	44
	45	wxMacAutoreleasePool::wxMacAutoreleasePool()
	46	{
	47	m_pool = [[NSAutoreleasePool alloc] init];
	48	}
	49
	50	wxMacAutoreleasePool::~wxMacAutoreleasePool()
	51	{
	52	[(NSAutoreleasePool*)m_pool release];
	53	}
	54
	55	#endif
	56
	57	#if wxOSX_USE_COCOA
	58
	59	CGContextRef wxOSXGetContextFromCurrentContext()
	60	{
	61	CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext]
	62	graphicsPort];
	63	return context;
	64	}
	65
	66	bool wxOSXLockFocus( WXWidget view)
	67	{
	68	return [view lockFocusIfCanDraw];
	69	}
	70
	71	void wxOSXUnlockFocus( WXWidget view)
	72	{
	73	[view unlockFocus];
	74	}
	75
	76	#endif
	77
	78	#if wxOSX_USE_IPHONE
	79
	80	CGContextRef wxOSXGetContextFromCurrentContext()
	81	{
	82	CGContextRef context = UIGraphicsGetCurrentContext();
	83	return context;
	84	}
	85
	86	#endif
	87
	88	// ----------------------------------------------------------------------------
	89	// NSObject Utils
	90	// ----------------------------------------------------------------------------
	91
	92	void wxMacCocoaRelease( void* obj )
	93	{
	94	[(NSObject*)obj release];
	95	}
	96
	97	void wxMacCocoaAutorelease( void* obj )
	98	{
	99	[(NSObject*)obj autorelease];
	100	}
	101
	102	void* wxMacCocoaRetain( void* obj )
	103	{
	104	[(NSObject*)obj retain];
	105	return obj;
	106	}
	107
	108	// ----------------------------------------------------------------------------
	109	// NSFont Utils
	110	// ----------------------------------------------------------------------------
	111
	112	#if wxOSX_USE_COCOA
	113	wxFont::wxFont(WX_NSFont nsfont)
	114	{
	115	[nsfont retain];
	116	wxNativeFontInfo info;
	117	SetNativeInfoFromNSFont(nsfont, &info);
	118	Create(info);
	119	}
	120
	121	void wxFont::SetNativeInfoFromNSFont(WX_NSFont theFont, wxNativeFontInfo* info)
	122	{
	123	if ( info->m_faceName.empty())
	124	{
	125	//Get more information about the user's chosen font
	126	NSFontTraitMask theTraits = [[NSFontManager sharedFontManager] traitsOfFont:theFont];
	127	int theFontWeight = [[NSFontManager sharedFontManager] weightOfFont:theFont];
	128
	129	wxFontFamily fontFamily = wxFONTFAMILY_DEFAULT;
	130	//Set the wx font to the appropriate data
	131	if(theTraits & NSFixedPitchFontMask)
	132	fontFamily = wxFONTFAMILY_TELETYPE;
	133
	134	wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
	135	wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
	136	bool underlined = false;
	137
	138	int size = (int) ([theFont pointSize]+0.5);
	139
	140	if ( theFontWeight >= 9 )
	141	fontweight = wxFONTWEIGHT_BOLD ;
	142	else if ( theFontWeight < 5 )
	143	fontweight = wxFONTWEIGHT_LIGHT;
	144	else
	145	fontweight = wxFONTWEIGHT_NORMAL ;
	146
	147	if ( theTraits & NSItalicFontMask )
	148	fontstyle = wxFONTSTYLE_ITALIC ;
	149
	150	info->Init(size,fontFamily,fontstyle,fontweight,underlined,
	151	wxStringWithNSString([theFont familyName]), wxFONTENCODING_DEFAULT);
	152
	153	}
	154	}
	155
	156	WX_NSFont wxFont::OSXCreateNSFont(wxOSXSystemFont font, wxNativeFontInfo* info)
	157	{
	158	NSFont* nsfont = nil;
	159	switch( font )
	160	{
	161	case wxOSX_SYSTEM_FONT_NORMAL:
	162	nsfont = [NSFont systemFontOfSize:[NSFont systemFontSize]];
	163	break;
	164	case wxOSX_SYSTEM_FONT_BOLD:
	165	nsfont = [NSFont boldSystemFontOfSize:[NSFont systemFontSize]];
	166	break;
	167	case wxOSX_SYSTEM_FONT_SMALL:
	168	nsfont = [NSFont systemFontOfSize:[NSFont smallSystemFontSize]];
	169	break;
	170	case wxOSX_SYSTEM_FONT_SMALL_BOLD:
	171	nsfont = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]];
	172	break;
	173	case wxOSX_SYSTEM_FONT_MINI:
	174	nsfont = [NSFont systemFontOfSize:
	175	[NSFont systemFontSizeForControlSize:NSMiniControlSize]];
	176	break;
	177	case wxOSX_SYSTEM_FONT_MINI_BOLD:
	178	nsfont = [NSFont boldSystemFontOfSize:
	179	[NSFont systemFontSizeForControlSize:NSMiniControlSize]];
	180	break;
	181	case wxOSX_SYSTEM_FONT_LABELS:
	182	nsfont = [NSFont labelFontOfSize:[NSFont labelFontSize]];
	183	break;
	184	case wxOSX_SYSTEM_FONT_VIEWS:
	185	nsfont = [NSFont controlContentFontOfSize:0];
	186	break;
	187	default:
	188	break;
	189	}
	190	[nsfont retain];
	191	SetNativeInfoFromNSFont(nsfont, info);
	192	return nsfont;
	193	}
	194
	195	static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
	196	static const NSAffineTransformStruct kSlantNSTransformStruct = { 1, 0, static_cast<CGFloat>(tan(DegToRad(11))), 1, 0, 0 };
	197
	198	WX_NSFont wxFont::OSXCreateNSFont(const wxNativeFontInfo* info)
	199	{
	200	NSFont* nsFont;
	201	int weight = 5;
	202	NSFontTraitMask traits = 0;
	203	if (info->m_weight == wxFONTWEIGHT_BOLD)
	204	{
	205	traits \|= NSBoldFontMask;
	206	weight = 9;
	207	}
	208	else if (info->m_weight == wxFONTWEIGHT_LIGHT)
	209	weight = 3;
	210
	211	if (info->m_style == wxFONTSTYLE_ITALIC \|\| info->m_style == wxFONTSTYLE_SLANT)
	212	traits \|= NSItalicFontMask;
	213
	214	nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString()
	215	traits:traits weight:weight size:info->m_pointSize];
	216
	217	if ( nsFont == nil )
	218	{
	219	NSFontTraitMask remainingTraits = traits;
	220	nsFont = [[NSFontManager sharedFontManager] fontWithFamily:wxCFStringRef(info->m_faceName).AsNSString()
	221	traits:0 weight:5 size:info->m_pointSize];
	222	if ( nsFont == nil )
	223	{
	224	if ( info->m_weight == wxFONTWEIGHT_BOLD )
	225	{
	226	nsFont = [NSFont boldSystemFontOfSize:info->m_pointSize];
	227	remainingTraits &= ~NSBoldFontMask;
	228	}
	229	else
	230	nsFont = [NSFont systemFontOfSize:info->m_pointSize];
	231	}
	232
	233	// fallback - if in doubt, let go of the bold attribute
	234	if ( nsFont && (remainingTraits & NSItalicFontMask) )
	235	{
	236	NSFont* nsFontWithTraits = nil;
	237	if ( remainingTraits & NSBoldFontMask)
	238	{
	239	nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSBoldFontMask];
	240	if ( nsFontWithTraits == nil )
	241	{
	242	nsFontWithTraits = [[NSFontManager sharedFontManager] convertFont:nsFont toHaveTrait:NSItalicFontMask];
	243	if ( nsFontWithTraits != nil )
	244	remainingTraits &= ~NSItalicFontMask;
	245	}
	246	else
	247	{
	248	remainingTraits &= ~NSBoldFontMask;
	249	}
	250	}
	251	// the code below causes crashes, because fontDescriptorWithMatrix is not returning a valid font descriptor
	252	// it adds a NSCTFontMatrixAttribute as well which cannot be disposed of correctly by the autorelease pool
	253	// so at the moment we have to disable this and cannot synthesize italic fonts if they are not available on the system
	254	#if 0
	255	if ( remainingTraits & NSItalicFontMask )
	256	{
	257	if ( nsFontWithTraits == nil )
	258	nsFontWithTraits = nsFont;
	259
	260	NSAffineTransform* transform = [NSAffineTransform transform];
	261	[transform setTransformStruct:kSlantNSTransformStruct];
	262	[transform scaleBy:info->m_pointSize];
	263	NSFontDescriptor* italicDesc = [[nsFontWithTraits fontDescriptor] fontDescriptorWithMatrix:transform];
	264	if ( italicDesc != nil )
	265	{
	266	NSFont* f = [NSFont fontWithDescriptor:italicDesc size:(CGFloat)(info->m_pointSize)];
	267	if ( f != nil )
	268	nsFontWithTraits = f;
	269	}
	270	}
	271	#endif
	272	if ( nsFontWithTraits != nil )
	273	nsFont = nsFontWithTraits;
	274	}
	275	}
	276
	277	wxASSERT_MSG(nsFont != nil,wxT("Couldn't create nsFont")) ;
	278	wxMacCocoaRetain(nsFont);
	279	return nsFont;
	280	}
	281
	282	#endif
	283
	284	#if wxOSX_USE_IPHONE
	285
	286	WX_UIFont wxFont::OSXCreateUIFont(wxOSXSystemFont font, wxNativeFontInfo* info)
	287	{
	288	UIFont* uifont;
	289	switch( font )
	290	{
	291	case wxOSX_SYSTEM_FONT_NORMAL:
	292	uifont = [UIFont systemFontOfSize:[UIFont systemFontSize]];
	293	break;
	294	case wxOSX_SYSTEM_FONT_BOLD:
	295	uifont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]];
	296	break;
	297	case wxOSX_SYSTEM_FONT_MINI:
	298	case wxOSX_SYSTEM_FONT_SMALL:
	299	uifont = [UIFont systemFontOfSize:[UIFont smallSystemFontSize]];
	300	break;
	301	case wxOSX_SYSTEM_FONT_MINI_BOLD:
	302	case wxOSX_SYSTEM_FONT_SMALL_BOLD:
	303	uifont = [UIFont boldSystemFontOfSize:[UIFont smallSystemFontSize]];
	304	break;
	305	case wxOSX_SYSTEM_FONT_VIEWS:
	306	case wxOSX_SYSTEM_FONT_LABELS:
	307	uifont = [UIFont systemFontOfSize:[UIFont labelFontSize]];
	308	break;
	309	default:
	310	break;
	311	}
	312	[uifont retain];
	313	if ( info->m_faceName.empty())
	314	{
	315	wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
	316	wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
	317	bool underlined = false;
	318
	319	int size = (int) ([uifont pointSize]+0.5);
	320	/*
	321	NSFontSymbolicTraits traits = [desc symbolicTraits];
	322
	323	if ( traits & NSFontBoldTrait )
	324	fontweight = wxFONTWEIGHT_BOLD ;
	325	else
	326	fontweight = wxFONTWEIGHT_NORMAL ;
	327	if ( traits & NSFontItalicTrait )
	328	fontstyle = wxFONTSTYLE_ITALIC ;
	329	*/
	330	wxCFStringRef fontname( wxCFRetain([uifont familyName]) );
	331	info->Init(size,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
	332	fontname.AsString(), wxFONTENCODING_DEFAULT);
	333
	334	}
	335	return uifont;
	336	}
	337
	338	WX_UIFont wxFont::OSXCreateUIFont(const wxNativeFontInfo* info)
	339	{
	340	UIFont* uiFont;
	341	uiFont = [UIFont fontWithName:wxCFStringRef(info->m_faceName).AsNSString() size:info->m_pointSize];
	342	wxMacCocoaRetain(uiFont);
	343	return uiFont;
	344	}
	345
	346	#endif
	347
	348	// ----------------------------------------------------------------------------
	349	// NSWindow Utils
	350	// ----------------------------------------------------------------------------
	351
	352	#if wxOSX_USE_COCOA
	353
	354	WXWindow wxOSXGetMainWindow()
	355	{
	356	return [NSApp mainWindow];
	357	}
	358
	359	#endif
	360	// ----------------------------------------------------------------------------
	361	// NSImage Utils
	362	// ----------------------------------------------------------------------------
	363
	364	#if wxOSX_USE_IPHONE
	365
	366	WX_UIImage wxOSXGetUIImageFromCGImage( CGImageRef image )
	367	{
	368	UIImage *newImage = [UIImage imageWithCGImage:image];
	369	[newImage autorelease];
	370	return( newImage );
	371	}
	372
	373	wxBitmap wxOSXCreateSystemBitmap(const wxString& name, const wxString &client, const wxSize& size)
	374	{
	375	#if 1
	376	// unfortunately this only accesses images in the app bundle, not the system wide globals
	377	wxCFStringRef cfname(name);
	378	return wxBitmap( [[UIImage imageNamed:cfname.AsNSString()] CGImage] );
	379	#else
	380	return wxBitmap();
	381	#endif
	382	}
	383
	384	#endif
	385
	386	#if wxOSX_USE_COCOA
	387
	388	wxBitmap wxOSXCreateSystemBitmap(const wxString& name, const wxString &WXUNUSED(client), const wxSize& WXUNUSED(size))
	389	{
	390	wxCFStringRef cfname(name);
	391	wxCFRef<CGImageRef> image( wxOSXCreateCGImageFromNSImage([NSImage imageNamed:cfname.AsNSString()]) );
	392	return wxBitmap( image );
	393	}
	394
	395	// From "Cocoa Drawing Guide:Working with Images"
	396	WX_NSImage wxOSXGetNSImageFromCGImage( CGImageRef image )
	397	{
	398	NSRect imageRect = NSMakeRect(0.0, 0.0, 0.0, 0.0);
	399
	400	// Get the image dimensions.
	401	imageRect.size.height = CGImageGetHeight(image);
	402	imageRect.size.width = CGImageGetWidth(image);
	403
	404	// Create a new image to receive the Quartz image data.
	405	NSImage *newImage = [[NSImage alloc] initWithSize:imageRect.size];
	406	[newImage lockFocus];
	407
	408	// Get the Quartz context and draw.
	409	CGContextRef imageContext = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
	410	CGContextDrawImage( imageContext, (CGRect)&imageRect, image );
	411	[newImage unlockFocus];
	412
	413	/*
	414	// Create a bitmap rep from the image...
	415	NSBitmapImageRep *bitmapRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];
	416	// Create an NSImage and add the bitmap rep to it...
	417	NSImage *image = [[NSImage alloc] init];
	418	[image addRepresentation:bitmapRep];
	419	[bitmapRep release];
	420	*/
	421	[newImage autorelease];
	422	return( newImage );
	423	}
	424
	425	CGImageRef wxOSXCreateCGImageFromNSImage( WX_NSImage nsimage )
	426	{
	427	// based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html
	428
	429	CGImageRef image = NULL;
	430	if (nsimage != nil)
	431	{
	432	NSSize imageSize = [nsimage size];
	433	CGContextRef context = CGBitmapContextCreate(NULL, imageSize.width, imageSize.height, 8, 0, wxMacGetGenericRGBColorSpace(), kCGImageAlphaPremultipliedFirst);
	434	NSGraphicsContext *nsGraphicsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:context flipped:NO];
	435	[NSGraphicsContext saveGraphicsState];
	436	[NSGraphicsContext setCurrentContext:nsGraphicsContext];
	437	[[NSColor whiteColor] setFill];
	438	NSRectFill(NSMakeRect(0.0, 0.0, imageSize.width, imageSize.height));
	439	[nsimage drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeCopy fraction:1.0];
	440	[NSGraphicsContext setCurrentContext:nsGraphicsContext];
	441	image = CGBitmapContextCreateImage(context);
	442	CFRelease(context);
	443	}
	444	return image;
	445	}
	446
	447	// ----------------------------------------------------------------------------
	448	// NSCursor Utils
	449	// ----------------------------------------------------------------------------
	450
	451	// copied from cursor.mm
	452
	453	static NSCursor* wxGetStockCursor( short sIndex )
	454	{
	455	ClassicCursor* pCursor = &gMacCursors[sIndex];
	456
	457	//Classic mac cursors are 1bps 16x16 black and white with a
	458	//identical mask that is 1 for on and 0 for off
	459	NSImage *theImage = [[NSImage alloc] initWithSize:NSMakeSize(16.0,16.0)];
	460
	461	//NSCursor takes an NSImage takes a number of Representations - here
	462	//we need only one for the raw data
	463	NSBitmapImageRep *theRep = [[NSBitmapImageRep alloc]
	464	initWithBitmapDataPlanes: NULL // Tell Cocoa to allocate the planes for us.
	465	pixelsWide: 16 // All classic cursors are 16x16
	466	pixelsHigh: 16
	467	bitsPerSample: 1 // All classic cursors are bitmaps with bitmasks
	468	samplesPerPixel: 2 // Sample 0:image 1:mask
	469	hasAlpha: YES // Identify last sample as a mask
	470	isPlanar: YES // Use a separate array for each sample
	471	colorSpaceName: NSCalibratedWhiteColorSpace // 0.0=black 1.0=white
	472	bytesPerRow: 2 // Rows in each plane are on 2-byte boundaries (no pad)
	473	bitsPerPixel: 1]; // same as bitsPerSample since data is planar
	474
	475	// Ensure that Cocoa allocated 2 and only 2 of the 5 possible planes
	476	unsigned char *planes[5];
	477	[theRep getBitmapDataPlanes:planes];
	478	wxASSERT(planes[0] != NULL);
	479	wxASSERT(planes[1] != NULL);
	480	wxASSERT(planes[2] == NULL);
	481	wxASSERT(planes[3] == NULL);
	482	wxASSERT(planes[4] == NULL);
	483
	484	// NOTE1: The Cursor's bits field is white=0 black=1.. thus the bitwise-not
	485	// Why not use NSCalibratedBlackColorSpace? Because that reverses the
	486	// sense of the alpha (mask) plane.
	487	// NOTE2: The mask data is 0=off 1=on
	488	// NOTE3: Cocoa asks for "premultiplied" color planes. Since we have a
	489	// 1-bit color plane and a 1-bit alpha plane we can just do a bitwise-and
	490	// on the two. The original cursor bitmaps have 0 (white actually) for
	491	// any masked-off pixels. Therefore every masked-off pixel would be wrong
	492	// since we bit-flip all of the picture bits. In practice, Cocoa doesn't
	493	// seem to care, but we are following the documentation.
	494
	495	// Fill in the color (black/white) plane
	496	for(int i=0; i<16; ++i)
	497	{
	498	planes[0][2*i ] = (~pCursor->bits[i] & pCursor->mask[i]) >> 8 & 0xff;
	499	planes[0][2*i+1] = (~pCursor->bits[i] & pCursor->mask[i]) & 0xff;
	500	}
	501	// Fill in the alpha (i.e. mask) plane
	502	for(int i=0; i<16; ++i)
	503	{
	504	planes[1][2*i ] = pCursor->mask[i] >> 8 & 0xff;
	505	planes[1][2*i+1] = pCursor->mask[i] & 0xff;
	506	}
	507
	508	//add the representation (data) to the image
	509	[theImage addRepresentation:theRep];
	510
	511	//create the new cursor
	512	NSCursor* theCursor = [[NSCursor alloc] initWithImage:theImage
	513	hotSpot:NSMakePoint(pCursor->hotspot[1], pCursor->hotspot[0])
	514	];
	515
	516	//do the usual cleanups
	517	[theRep release];
	518	[theImage release];
	519
	520	//return the new cursor
	521	return theCursor;
	522	}
	523
	524	WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type )
	525	{
	526	WX_NSCursor cursor = nil;
	527	switch (cursor_type)
	528	{
	529	case wxCURSOR_COPY_ARROW:
	530	cursor = [[NSCursor arrowCursor] retain];
	531	break;
	532
	533	case wxCURSOR_WATCH:
	534	case wxCURSOR_WAIT:
	535	// an arrow should be displayed by the system when things are running
	536	// according to the HIG
	537	// cursor = [[NSCursor arrowCursor] retain];
	538	// but for crossplatform compatibility we display a watch cursor
	539	cursor = wxGetStockCursor(kwxCursorWatch);
	540	break;
	541
	542	case wxCURSOR_IBEAM:
	543	cursor = [[NSCursor IBeamCursor] retain];
	544	break;
	545
	546	case wxCURSOR_CROSS:
	547	cursor = [[NSCursor crosshairCursor] retain];
	548	break;
	549
	550	case wxCURSOR_SIZENWSE:
	551	cursor = wxGetStockCursor(kwxCursorSizeNWSE);
	552	break;
	553
	554	case wxCURSOR_SIZENESW:
	555	cursor = wxGetStockCursor(kwxCursorSizeNESW);
	556	break;
	557
	558	case wxCURSOR_SIZEWE:
	559	cursor = [[NSCursor resizeLeftRightCursor] retain];
	560	break;
	561
	562	case wxCURSOR_SIZENS:
	563	cursor = [[NSCursor resizeUpDownCursor] retain];
	564	break;
	565
	566	case wxCURSOR_SIZING:
	567	cursor = wxGetStockCursor(kwxCursorSize);
	568	break;
	569
	570	case wxCURSOR_HAND:
	571	cursor = [[NSCursor pointingHandCursor] retain];
	572	break;
	573
	574	case wxCURSOR_BULLSEYE:
	575	cursor = wxGetStockCursor(kwxCursorBullseye);
	576	break;
	577
	578	case wxCURSOR_PENCIL:
	579	cursor = wxGetStockCursor(kwxCursorPencil);
	580	break;
	581
	582	case wxCURSOR_MAGNIFIER:
	583	cursor = wxGetStockCursor(kwxCursorMagnifier);
	584	break;
	585
	586	case wxCURSOR_NO_ENTRY:
	587	cursor = wxGetStockCursor(kwxCursorNoEntry);
	588	break;
	589
	590	case wxCURSOR_PAINT_BRUSH:
	591	cursor = wxGetStockCursor(kwxCursorPaintBrush);
	592	break;
	593
	594	case wxCURSOR_POINT_LEFT:
	595	cursor = wxGetStockCursor(kwxCursorPointLeft);
	596	break;
	597
	598	case wxCURSOR_POINT_RIGHT:
	599	cursor = wxGetStockCursor(kwxCursorPointRight);
	600	break;
	601
	602	case wxCURSOR_QUESTION_ARROW:
	603	cursor = wxGetStockCursor(kwxCursorQuestionArrow);
	604	break;
	605
	606	case wxCURSOR_BLANK:
	607	cursor = wxGetStockCursor(kwxCursorBlank);
	608	break;
	609
	610	case wxCURSOR_RIGHT_ARROW:
	611	cursor = wxGetStockCursor(kwxCursorRightArrow);
	612	break;
	613
	614	case wxCURSOR_SPRAYCAN:
	615	cursor = wxGetStockCursor(kwxCursorRoller);
	616	break;
	617
	618	case wxCURSOR_OPEN_HAND:
	619	cursor = [[NSCursor openHandCursor] retain];
	620	break;
	621
	622	case wxCURSOR_CLOSED_HAND:
	623	cursor = [[NSCursor closedHandCursor] retain];
	624	break;
	625
	626	case wxCURSOR_CHAR:
	627	case wxCURSOR_ARROW:
	628	case wxCURSOR_LEFT_BUTTON:
	629	case wxCURSOR_RIGHT_BUTTON:
	630	case wxCURSOR_MIDDLE_BUTTON:
	631	default:
	632	cursor = [[NSCursor arrowCursor] retain];
	633	break;
	634	}
	635	return cursor;
	636	}
	637
	638	// C-based style wrapper routines around NSCursor
	639	WX_NSCursor wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY )
	640	{
	641	static BOOL firstTime = YES;
	642
	643	if ( firstTime )
	644	{
	645	// 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
	646	[[[NSWindow alloc] init] release];
	647	firstTime = NO;
	648	}
	649
	650	NSImage *nsImage = wxOSXGetNSImageFromCGImage( cgImageRef );
	651	NSCursor *cursor = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )];
	652
	653	return cursor;
	654	}
	655
	656	void wxMacCocoaSetCursor( WX_NSCursor cursor )
	657	{
	658	[cursor set];
	659	}
	660
	661	void wxMacCocoaHideCursor()
	662	{
	663	[NSCursor hide];
	664	}
	665
	666	void wxMacCocoaShowCursor()
	667	{
	668	[NSCursor unhide];
	669	}
	670
	671	#endif
	672