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