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     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