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