src/osx/carbon/utilscocoa.mm

   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     return wxBitmap( [NSImage imageNamed:cfname.AsNSString()] );
 392 }
 393
 394 //  From "Cocoa Drawing Guide:Working with Images"
 395 WX_NSImage  wxOSXGetNSImageFromCGImage( CGImageRef image, double scaleFactor )
 396 {
 397     NSRect      imageRect    = NSMakeRect(0.0, 0.0, 0.0, 0.0);
 398
 399     // Get the image dimensions.
 400     imageRect.size.height = CGImageGetHeight(image)/scaleFactor;
 401     imageRect.size.width = CGImageGetWidth(image)/scaleFactor;
 402
 403     // Create a new image to receive the Quartz image data.
 404     NSImage  *newImage = [[NSImage alloc] initWithSize:imageRect.size];
 405     [newImage lockFocus];
 406
 407     // Get the Quartz context and draw.
 408     CGContextRef  imageContext = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
 409     CGContextDrawImage( imageContext, *(CGRect*)&imageRect, image );
 410     [newImage unlockFocus];
 411
 412     /*
 413         // Create a bitmap rep from the image...
 414         NSBitmapImageRep *bitmapRep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];
 415         // Create an NSImage and add the bitmap rep to it...
 416         NSImage *image = [[NSImage alloc] init];
 417         [image addRepresentation:bitmapRep];
 418         [bitmapRep release];
 419     */
 420     [newImage autorelease];
 421     return( newImage );
 422 }
 423
 424 CGContextRef WXDLLIMPEXP_CORE wxOSXCreateBitmapContextFromNSImage( WX_NSImage nsimage)
 425 {
 426     // based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html
 427
 428     CGContextRef hbitmap = NULL;
 429     if (nsimage != nil)
 430     {
 431         CGFloat scale = [[NSScreen mainScreen] backingScaleFactor];
 432
 433         NSSize imageSize = [nsimage size];
 434
 435         hbitmap = CGBitmapContextCreate(NULL, imageSize.width*scale, imageSize.height*scale, 8, 0, wxMacGetGenericRGBColorSpace(), kCGImageAlphaPremultipliedFirst);
 436         CGContextScaleCTM( hbitmap, scale, scale );
 437
 438         NSGraphicsContext *nsGraphicsContext = [NSGraphicsContext graphicsContextWithGraphicsPort:hbitmap flipped:NO];
 439         [NSGraphicsContext saveGraphicsState];
 440         [NSGraphicsContext setCurrentContext:nsGraphicsContext];
 441         [[NSColor whiteColor] setFill];
 442         NSRectFill(NSMakeRect(0.0, 0.0, imageSize.width, imageSize.height));
 443         [nsimage drawAtPoint:NSZeroPoint fromRect:NSZeroRect operation:NSCompositeCopy fraction:1.0];
 444         [NSGraphicsContext setCurrentContext:nsGraphicsContext];
 445     }
 446     return hbitmap;
 447 }
 448
 449 CGImageRef wxOSXCreateCGImageFromNSImage( WX_NSImage nsimage, double *scaleptr )
 450 {
 451     // based on http://www.mail-archive.com/cocoa-dev@lists.apple.com/msg18065.html
 452
 453     CGImageRef image = NULL;
 454     if (nsimage != nil)
 455     {
 456         CGContextRef context = wxOSXCreateBitmapContextFromNSImage(nsimage);
 457         if ( scaleptr )
 458         {
 459             // determine content scale
 460             CGRect userrect = CGRectMake(0, 0, 10, 10);
 461             CGRect devicerect;
 462             devicerect = CGContextConvertRectToDeviceSpace(context, userrect);
 463             *scaleptr = devicerect.size.height / userrect.size.height;
 464         }
 465         image = CGBitmapContextCreateImage(context);
 466         CFRelease(context);
 467     }
 468     return image;
 469  }
 470
 471 // ----------------------------------------------------------------------------
 472 // NSCursor Utils
 473 // ----------------------------------------------------------------------------
 474
 475 // copied from cursor.mm
 476
 477 static NSCursor* wxGetStockCursor( short sIndex )
 478 {
 479     ClassicCursor* pCursor = &gMacCursors[sIndex];
 480
 481     //Classic mac cursors are 1bps 16x16 black and white with a
 482     //identical mask that is 1 for on and 0 for off
 483     NSImage *theImage = [[NSImage alloc] initWithSize:NSMakeSize(16.0,16.0)];
 484
 485     //NSCursor takes an NSImage takes a number of Representations - here
 486     //we need only one for the raw data
 487     NSBitmapImageRep *theRep = [[NSBitmapImageRep alloc]
 488         initWithBitmapDataPlanes: NULL  // Tell Cocoa to allocate the planes for us.
 489         pixelsWide: 16      // All classic cursors are 16x16
 490         pixelsHigh: 16
 491         bitsPerSample: 1    // All classic cursors are bitmaps with bitmasks
 492         samplesPerPixel: 2  // Sample 0:image 1:mask
 493         hasAlpha: YES       // Identify last sample as a mask
 494         isPlanar: YES       // Use a separate array for each sample
 495         colorSpaceName: NSCalibratedWhiteColorSpace // 0.0=black 1.0=white
 496         bytesPerRow: 2      // Rows in each plane are on 2-byte boundaries (no pad)
 497         bitsPerPixel: 1];   // same as bitsPerSample since data is planar
 498
 499     // Ensure that Cocoa allocated 2 and only 2 of the 5 possible planes
 500     unsigned char *planes[5];
 501     [theRep getBitmapDataPlanes:planes];
 502     wxASSERT(planes[0] != NULL);
 503     wxASSERT(planes[1] != NULL);
 504     wxASSERT(planes[2] == NULL);
 505     wxASSERT(planes[3] == NULL);
 506     wxASSERT(planes[4] == NULL);
 507
 508     // NOTE1: The Cursor's bits field is white=0 black=1.. thus the bitwise-not
 509     // Why not use NSCalibratedBlackColorSpace?  Because that reverses the
 510     // sense of the alpha (mask) plane.
 511     // NOTE2: The mask data is 0=off 1=on
 512     // NOTE3: Cocoa asks for "premultiplied" color planes.  Since we have a
 513     // 1-bit color plane and a 1-bit alpha plane we can just do a bitwise-and
 514     // on the two.  The original cursor bitmaps have 0 (white actually) for
 515     // any masked-off pixels.  Therefore every masked-off pixel would be wrong
 516     // since we bit-flip all of the picture bits.  In practice, Cocoa doesn't
 517     // seem to care, but we are following the documentation.
 518
 519     // Fill in the color (black/white) plane
 520     for(int i=0; i<16; ++i)
 521     {
 522         planes[0][2*i  ] = (~pCursor->bits[i] & pCursor->mask[i]) >> 8 & 0xff;
 523         planes[0][2*i+1] = (~pCursor->bits[i] & pCursor->mask[i]) & 0xff;
 524     }
 525     // Fill in the alpha (i.e. mask) plane
 526     for(int i=0; i<16; ++i)
 527     {
 528         planes[1][2*i  ] = pCursor->mask[i] >> 8 & 0xff;
 529         planes[1][2*i+1] = pCursor->mask[i] & 0xff;
 530     }
 531
 532     //add the representation (data) to the image
 533     [theImage addRepresentation:theRep];
 534
 535     //create the new cursor
 536     NSCursor* theCursor =  [[NSCursor alloc]  initWithImage:theImage
 537                                     hotSpot:NSMakePoint(pCursor->hotspot[1], pCursor->hotspot[0])
 538                             ];
 539
 540     //do the usual cleanups
 541     [theRep release];
 542     [theImage release];
 543
 544     //return the new cursor
 545     return theCursor;
 546 }
 547
 548 WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type )
 549 {
 550     WX_NSCursor cursor = nil;
 551     switch (cursor_type)
 552     {
 553     case wxCURSOR_COPY_ARROW:
 554         cursor = [[NSCursor arrowCursor] retain];
 555         break;
 556
 557     case wxCURSOR_WATCH:
 558     case wxCURSOR_WAIT:
 559         // an arrow should be displayed by the system when things are running
 560         // according to the HIG
 561         // cursor = [[NSCursor arrowCursor] retain];
 562         // but for crossplatform compatibility we display a watch cursor
 563         cursor = wxGetStockCursor(kwxCursorWatch);
 564         break;
 565
 566     case wxCURSOR_IBEAM:
 567         cursor = [[NSCursor IBeamCursor] retain];
 568         break;
 569
 570     case wxCURSOR_CROSS:
 571         cursor = [[NSCursor crosshairCursor] retain];
 572         break;
 573
 574     case wxCURSOR_SIZENWSE:
 575         cursor = wxGetStockCursor(kwxCursorSizeNWSE);
 576         break;
 577
 578     case wxCURSOR_SIZENESW:
 579         cursor = wxGetStockCursor(kwxCursorSizeNESW);
 580         break;
 581
 582     case wxCURSOR_SIZEWE:
 583         cursor = [[NSCursor resizeLeftRightCursor] retain];
 584         break;
 585
 586     case wxCURSOR_SIZENS:
 587         cursor = [[NSCursor resizeUpDownCursor] retain];
 588         break;
 589
 590     case wxCURSOR_SIZING:
 591         cursor = wxGetStockCursor(kwxCursorSize);
 592         break;
 593
 594     case wxCURSOR_HAND:
 595         cursor = [[NSCursor pointingHandCursor] retain];
 596         break;
 597
 598     case wxCURSOR_BULLSEYE:
 599         cursor = wxGetStockCursor(kwxCursorBullseye);
 600         break;
 601
 602     case wxCURSOR_PENCIL:
 603         cursor = wxGetStockCursor(kwxCursorPencil);
 604         break;
 605
 606     case wxCURSOR_MAGNIFIER:
 607         cursor = wxGetStockCursor(kwxCursorMagnifier);
 608         break;
 609
 610     case wxCURSOR_NO_ENTRY:
 611         cursor = wxGetStockCursor(kwxCursorNoEntry);
 612         break;
 613
 614     case wxCURSOR_PAINT_BRUSH:
 615         cursor = wxGetStockCursor(kwxCursorPaintBrush);
 616         break;
 617
 618     case wxCURSOR_POINT_LEFT:
 619         cursor = wxGetStockCursor(kwxCursorPointLeft);
 620         break;
 621
 622     case wxCURSOR_POINT_RIGHT:
 623         cursor = wxGetStockCursor(kwxCursorPointRight);
 624         break;
 625
 626     case wxCURSOR_QUESTION_ARROW:
 627         cursor = wxGetStockCursor(kwxCursorQuestionArrow);
 628         break;
 629
 630     case wxCURSOR_BLANK:
 631         cursor = wxGetStockCursor(kwxCursorBlank);
 632         break;
 633
 634     case wxCURSOR_RIGHT_ARROW:
 635         cursor = wxGetStockCursor(kwxCursorRightArrow);
 636         break;
 637
 638     case wxCURSOR_SPRAYCAN:
 639         cursor = wxGetStockCursor(kwxCursorRoller);
 640         break;
 641
 642     case wxCURSOR_OPEN_HAND:
 643         cursor = [[NSCursor openHandCursor] retain];
 644         break;
 645
 646     case wxCURSOR_CLOSED_HAND:
 647         cursor = [[NSCursor closedHandCursor] retain];
 648         break;
 649
 650     case wxCURSOR_CHAR:
 651     case wxCURSOR_ARROW:
 652     case wxCURSOR_LEFT_BUTTON:
 653     case wxCURSOR_RIGHT_BUTTON:
 654     case wxCURSOR_MIDDLE_BUTTON:
 655     default:
 656         cursor = [[NSCursor arrowCursor] retain];
 657         break;
 658     }
 659     return cursor;
 660 }
 661
 662 //  C-based style wrapper routines around NSCursor
 663 WX_NSCursor  wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY )
 664 {
 665     static BOOL    firstTime  = YES;
 666
 667     if ( firstTime )
 668     {
 669         //  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
 670         [[[NSWindow alloc] init] release];
 671         firstTime = NO;
 672     }
 673
 674     NSImage    *nsImage  = wxOSXGetNSImageFromCGImage( cgImageRef );
 675     NSCursor  *cursor    = [[NSCursor alloc] initWithImage:nsImage hotSpot:NSMakePoint( hotSpotX, hotSpotY )];
 676
 677     return cursor;
 678 }
 679
 680 void  wxMacCocoaSetCursor( WX_NSCursor cursor )
 681 {
 682     [cursor set];
 683 }
 684
 685 void  wxMacCocoaHideCursor()
 686 {
 687     [NSCursor hide];
 688 }
 689
 690 void  wxMacCocoaShowCursor()
 691 {
 692     [NSCursor unhide];
 693 }
 694
 695 #endif
 696