src/mac/carbon/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        utils.cpp
   3 // Purpose:     Various utilities
   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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 // Note: this is done in utilscmn.cpp now.
  14 // #pragma implementation "utils.h"
  15 #endif
  16
  17 #include "wx/wxprec.h"
  18
  19 #include "wx/utils.h"
  20 #include "wx/app.h"
  21 #include "wx/apptrait.h"
  22
  23 #if wxUSE_GUI
  24     #include "wx/mac/uma.h"
  25     #include "wx/font.h"
  26     #include "wx/toplevel.h"
  27 #else
  28     #include "wx/intl.h"
  29 #endif
  30
  31 #include <ctype.h>
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <stdarg.h>
  37
  38 #include "MoreFilesX.h"
  39
  40 #ifndef __DARWIN__
  41 #include <Threads.h>
  42 #include <Sound.h>
  43 #endif
  44
  45 #if wxUSE_GUI
  46 #if TARGET_API_MAC_OSX
  47 #include <CoreServices/CoreServices.h>
  48 #else
  49 #include <DriverServices.h>
  50 #include <Multiprocessing.h>
  51 #endif
  52
  53 #include <ATSUnicode.h>
  54 #include <TextCommon.h>
  55 #include <TextEncodingConverter.h>
  56 #endif // wxUSE_GUI
  57
  58 #include  "wx/mac/private.h"  // includes mac headers
  59
  60 #if defined(__MWERKS__) && wxUSE_UNICODE
  61     #include <wtime.h>
  62 #endif
  63
  64 // ---------------------------------------------------------------------------
  65 // code used in both base and GUI compilation
  66 // ---------------------------------------------------------------------------
  67
  68 // our OS version is the same in non GUI and GUI cases
  69 static int DoGetOSVersion(int *majorVsn, int *minorVsn)
  70 {
  71     long theSystem ;
  72
  73     // are there x-platform conventions ?
  74
  75     Gestalt(gestaltSystemVersion, &theSystem) ;
  76     if (minorVsn != NULL) {
  77         *minorVsn = (theSystem & 0xFF ) ;
  78     }
  79     if (majorVsn != NULL) {
  80         *majorVsn = (theSystem >> 8 ) ;
  81     }
  82 #ifdef __DARWIN__
  83     return wxMAC_DARWIN;
  84 #else
  85     return wxMAC;
  86 #endif
  87 }
  88
  89
  90 #if wxUSE_BASE
  91
  92 // ----------------------------------------------------------------------------
  93 // debugging support
  94 // ----------------------------------------------------------------------------
  95
  96 #if defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
  97
  98 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
  99
 100 #ifndef __MetroNubUtils__
 101 #include "MetroNubUtils.h"
 102 #endif
 103
 104 #ifndef __GESTALT__
 105 #include <Gestalt.h>
 106 #endif
 107
 108 #if TARGET_API_MAC_CARBON
 109
 110     #include <CodeFragments.h>
 111
 112     extern "C" long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
 113
 114     ProcPtr gCallUniversalProc_Proc = NULL;
 115
 116 #endif
 117
 118 static MetroNubUserEntryBlock*    gMetroNubEntry = NULL;
 119
 120 static long fRunOnce = false;
 121
 122 /* ---------------------------------------------------------------------------
 123         IsMetroNubInstalled
 124    --------------------------------------------------------------------------- */
 125
 126 Boolean IsMetroNubInstalled()
 127 {
 128     if (!fRunOnce)
 129     {
 130         long result, value;
 131
 132         fRunOnce = true;
 133         gMetroNubEntry = NULL;
 134
 135         if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
 136         {
 137             /* look for MetroNub's Gestalt selector */
 138             if (Gestalt(kMetroNubUserSignature, &result) == noErr)
 139             {
 140
 141             #if TARGET_API_MAC_CARBON
 142                 if (gCallUniversalProc_Proc == NULL)
 143                 {
 144                     CFragConnectionID   connectionID;
 145                     Ptr                 mainAddress;
 146                     Str255              errorString;
 147                     ProcPtr             symbolAddress;
 148                     OSErr               err;
 149                     CFragSymbolClass    symbolClass;
 150
 151                     symbolAddress = NULL;
 152                     err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
 153                                            &connectionID, &mainAddress, errorString);
 154
 155                     if (err != noErr)
 156                     {
 157                         gCallUniversalProc_Proc = NULL;
 158                         goto end;
 159                     }
 160
 161                     err = FindSymbol(connectionID, "\pCallUniversalProc",
 162                                     (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
 163
 164                     if (err != noErr)
 165                     {
 166                         gCallUniversalProc_Proc = NULL;
 167                         goto end;
 168                     }
 169                 }
 170             #endif
 171
 172                 {
 173                     MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
 174
 175                     /* make sure the version of the API is compatible */
 176                     if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
 177                         kMetroNubUserAPIVersion <= block->apiHiVersion)
 178                         gMetroNubEntry = block;        /* success! */
 179                 }
 180
 181             }
 182         }
 183     }
 184
 185 end:
 186
 187 #if TARGET_API_MAC_CARBON
 188     return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
 189 #else
 190     return (gMetroNubEntry != NULL);
 191 #endif
 192 }
 193
 194 /* ---------------------------------------------------------------------------
 195         IsMWDebuggerRunning                                            [v1 API]
 196    --------------------------------------------------------------------------- */
 197
 198 Boolean IsMWDebuggerRunning()
 199 {
 200     if (IsMetroNubInstalled())
 201         return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
 202     else
 203         return false;
 204 }
 205
 206 /* ---------------------------------------------------------------------------
 207         AmIBeingMWDebugged                                            [v1 API]
 208    --------------------------------------------------------------------------- */
 209
 210 Boolean AmIBeingMWDebugged()
 211 {
 212     if (IsMetroNubInstalled())
 213         return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
 214     else
 215         return false;
 216 }
 217
 218 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 219 {
 220     return IsMWDebuggerRunning() && AmIBeingMWDebugged();
 221 }
 222
 223 #else
 224
 225 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 226 {
 227     return false;
 228 }
 229
 230 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
 231
 232
 233 #ifndef __DARWIN__
 234 // defined in unix/utilsunx.cpp for Mac OS X
 235
 236 // get full hostname (with domain name if possible)
 237 bool wxGetFullHostName(wxChar *buf, int maxSize)
 238 {
 239     return wxGetHostName(buf, maxSize);
 240 }
 241
 242 // Get hostname only (without domain name)
 243 bool wxGetHostName(wxChar *buf, int maxSize)
 244 {
 245     // Gets Chooser name of user by examining a System resource.
 246
 247     const short kComputerNameID = -16413;
 248
 249     short oldResFile = CurResFile() ;
 250     UseResFile(0);
 251     StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
 252     UseResFile(oldResFile);
 253
 254     if (chooserName && *chooserName)
 255     {
 256         HLock( (Handle) chooserName ) ;
 257         wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
 258         HUnlock( (Handle) chooserName ) ;
 259         ReleaseResource( (Handle) chooserName ) ;
 260         wxStrncpy( buf , name , maxSize - 1 ) ;
 261     }
 262     else
 263         buf[0] = 0 ;
 264
 265     return true;
 266 }
 267
 268 // Get user ID e.g. jacs
 269 bool wxGetUserId(wxChar *buf, int maxSize)
 270 {
 271   return wxGetUserName( buf , maxSize ) ;
 272 }
 273
 274 const wxChar* wxGetHomeDir(wxString *pstr)
 275 {
 276     *pstr = wxMacFindFolder(  (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
 277     return pstr->c_str() ;
 278 }
 279
 280 // Get user name e.g. Stefan Csomor
 281 bool wxGetUserName(wxChar *buf, int maxSize)
 282 {
 283     // Gets Chooser name of user by examining a System resource.
 284
 285     const short kChooserNameID = -16096;
 286
 287     short oldResFile = CurResFile() ;
 288     UseResFile(0);
 289     StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
 290     UseResFile(oldResFile);
 291
 292     if (chooserName && *chooserName)
 293     {
 294         HLock( (Handle) chooserName ) ;
 295         wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
 296         HUnlock( (Handle) chooserName ) ;
 297         ReleaseResource( (Handle) chooserName ) ;
 298         wxStrncpy( buf , name , maxSize - 1 ) ;
 299     }
 300     else
 301         buf[0] = 0 ;
 302
 303     return true;
 304 }
 305
 306 int wxKill(long pid, wxSignal sig , wxKillError *rc, int flags)
 307 {
 308     // TODO
 309     return 0;
 310 }
 311
 312 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
 313 {
 314     // TODO : under classic there is no environement support, under X yes
 315     return false ;
 316 }
 317
 318 // set the env var name to the given value, return true on success
 319 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
 320 {
 321     // TODO : under classic there is no environement support, under X yes
 322     return false ;
 323 }
 324
 325 //
 326 // Execute a program in an Interactive Shell
 327 //
 328 bool wxShell(const wxString& command)
 329 {
 330     // TODO
 331     return false;
 332 }
 333
 334 // Shutdown or reboot the PC
 335 bool wxShutdown(wxShutdownFlags wFlags)
 336 {
 337     // TODO
 338     return false;
 339 }
 340
 341 wxPowerType wxGetPowerType()
 342 {
 343     // TODO
 344     return wxPOWER_UNKNOWN;
 345 }
 346
 347 wxBatteryState wxGetBatteryState()
 348 {
 349     // TODO
 350     return wxBATTERY_UNKNOWN_STATE;
 351 }
 352
 353 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 354 wxMemorySize wxGetFreeMemory()
 355 {
 356     return (wxMemorySize)FreeMem() ;
 357 }
 358
 359 #ifndef __DARWIN__
 360
 361 void wxMicroSleep(unsigned long microseconds)
 362 {
 363     AbsoluteTime wakeup = AddDurationToAbsolute( microseconds * durationMicrosecond , UpTime());
 364     MPDelayUntil( & wakeup);
 365 }
 366
 367 void wxMilliSleep(unsigned long milliseconds)
 368 {
 369     AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime());
 370     MPDelayUntil( & wakeup);
 371 }
 372
 373 void wxSleep(int nSecs)
 374 {
 375     wxMilliSleep(1000*nSecs);
 376 }
 377
 378 #endif
 379
 380 // Consume all events until no more left
 381 void wxFlushEvents()
 382 {
 383 }
 384
 385 #endif // !__DARWIN__
 386
 387 // Emit a beeeeeep
 388 void wxBell()
 389 {
 390     SysBeep(30);
 391 }
 392
 393 wxToolkitInfo& wxConsoleAppTraits::GetToolkitInfo()
 394 {
 395     static wxToolkitInfo info;
 396     info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
 397     info.name = _T("wxBase");
 398     return info;
 399 }
 400
 401 #endif // wxUSE_BASE
 402
 403 #if wxUSE_GUI
 404
 405 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
 406 {
 407     static wxToolkitInfo info;
 408     info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
 409     info.shortName = _T("mac");
 410     info.name = _T("wxMac");
 411 #ifdef __WXUNIVERSAL__
 412     info.shortName << _T("univ");
 413     info.name << _T("/wxUniversal");
 414 #endif
 415     return info;
 416 }
 417
 418 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 419 #if wxUSE_RESOURCES
 420 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
 421 {
 422     // TODO
 423     return false;
 424 }
 425
 426 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 427 {
 428     wxString buf;
 429     buf.Printf(wxT("%.4f"), value);
 430
 431     return wxWriteResource(section, entry, buf, file);
 432 }
 433
 434 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 435 {
 436     wxString buf;
 437     buf.Printf(wxT("%ld"), value);
 438
 439     return wxWriteResource(section, entry, buf, file);
 440 }
 441
 442 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 443 {
 444     wxString buf;
 445     buf.Printf(wxT("%d"), value);
 446
 447     return wxWriteResource(section, entry, buf, file);
 448 }
 449
 450 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
 451 {
 452     // TODO
 453     return false;
 454 }
 455
 456 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
 457 {
 458     char *s = NULL;
 459     bool succ = wxGetResource(section, entry, (char **)&s, file);
 460     if (succ)
 461     {
 462         *value = (float)strtod(s, NULL);
 463         delete[] s;
 464         return true;
 465     }
 466     else return false;
 467 }
 468
 469 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
 470 {
 471     char *s = NULL;
 472     bool succ = wxGetResource(section, entry, (char **)&s, file);
 473     if (succ)
 474     {
 475         *value = strtol(s, NULL, 10);
 476         delete[] s;
 477         return true;
 478     }
 479     else return false;
 480 }
 481
 482 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 483 {
 484     char *s = NULL;
 485     bool succ = wxGetResource(section, entry, (char **)&s, file);
 486     if (succ)
 487     {
 488         *value = (int)strtol(s, NULL, 10);
 489         delete[] s;
 490         return true;
 491     }
 492     else return false;
 493 }
 494 #endif // wxUSE_RESOURCES
 495
 496 int gs_wxBusyCursorCount = 0;
 497 extern wxCursor    gMacCurrentCursor ;
 498 wxCursor        gMacStoredActiveCursor ;
 499
 500 // Set the cursor to the busy cursor for all windows
 501 void wxBeginBusyCursor(wxCursor *cursor)
 502 {
 503     if (gs_wxBusyCursorCount++ == 0)
 504     {
 505         gMacStoredActiveCursor = gMacCurrentCursor ;
 506         cursor->MacInstall() ;
 507     }
 508     //else: nothing to do, already set
 509 }
 510
 511 // Restore cursor to normal
 512 void wxEndBusyCursor()
 513 {
 514     wxCHECK_RET( gs_wxBusyCursorCount > 0,
 515         wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
 516
 517     if (--gs_wxBusyCursorCount == 0)
 518     {
 519         gMacStoredActiveCursor.MacInstall() ;
 520         gMacStoredActiveCursor = wxNullCursor ;
 521     }
 522 }
 523
 524 // true if we're between the above two calls
 525 bool wxIsBusy()
 526 {
 527     return (gs_wxBusyCursorCount > 0);
 528 }
 529
 530 #endif // wxUSE_GUI
 531
 532 #if wxUSE_BASE
 533
 534 wxString wxMacFindFolder( short        vol,
 535               OSType       folderType,
 536               Boolean      createFolder)
 537 {
 538     FSRef fsRef ;
 539     wxString strDir ;
 540
 541     if ( FSFindFolder( vol, folderType, createFolder, &fsRef) == noErr)
 542         strDir = wxMacFSRefToPath( &fsRef ) + wxFILE_SEP_PATH ;
 543
 544     return strDir ;
 545 }
 546
 547 #endif // wxUSE_BASE
 548
 549 #if wxUSE_GUI
 550
 551 // Check whether this window wants to process messages, e.g. Stop button
 552 // in long calculations.
 553 bool wxCheckForInterrupt(wxWindow *wnd)
 554 {
 555     // TODO
 556     return false;
 557 }
 558
 559 void wxGetMousePosition( int* x, int* y )
 560 {
 561     Point pt ;
 562
 563     GetMouse( &pt ) ;
 564     LocalToGlobal( &pt ) ;
 565     *x = pt.h ;
 566     *y = pt.v ;
 567 };
 568
 569 // Return true if we have a colour display
 570 bool wxColourDisplay()
 571 {
 572     return true;
 573 }
 574
 575 // Returns depth of screen
 576 int wxDisplayDepth()
 577 {
 578     Rect globRect ;
 579     SetRect(&globRect, -32760, -32760, 32760, 32760);
 580     GDHandle    theMaxDevice;
 581
 582     int theDepth = 8;
 583     theMaxDevice = GetMaxDevice(&globRect);
 584     if (theMaxDevice != nil)
 585         theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
 586
 587     return theDepth ;
 588 }
 589
 590 // Get size of display
 591 void wxDisplaySize(int *width, int *height)
 592 {
 593     BitMap screenBits;
 594     GetQDGlobalsScreenBits( &screenBits );
 595
 596     if (width != NULL) {
 597         *width = screenBits.bounds.right - screenBits.bounds.left  ;
 598     }
 599     if (height != NULL) {
 600         *height = screenBits.bounds.bottom - screenBits.bounds.top ;
 601     }
 602 }
 603
 604 void wxDisplaySizeMM(int *width, int *height)
 605 {
 606     wxDisplaySize(width, height);
 607     // on mac 72 is fixed (at least now ;-)
 608     float cvPt2Mm = 25.4 / 72;
 609
 610     if (width != NULL) {
 611         *width = int( *width * cvPt2Mm );
 612     }
 613     if (height != NULL) {
 614         *height = int( *height * cvPt2Mm );
 615     }
 616 }
 617
 618 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 619 {
 620     Rect r ;
 621     GetAvailableWindowPositioningBounds( GetMainDevice() , &r ) ;
 622     if ( x )
 623         *x = r.left ;
 624     if ( y )
 625         *y = r.top ;
 626     if ( width )
 627         *width = r.right - r.left ;
 628     if ( height )
 629         *height = r.bottom - r.top ;
 630 }
 631
 632 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 633 {
 634     return wxGenericFindWindowAtPoint(pt);
 635 }
 636
 637 #endif // wxUSE_GUI
 638
 639 #if wxUSE_BASE
 640
 641 wxString wxGetOsDescription()
 642 {
 643 #ifdef WXWIN_OS_DESCRIPTION
 644     // use configure generated description if available
 645     return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
 646 #else
 647     return wxT("MacOS") ; //TODO:define further
 648 #endif
 649 }
 650
 651 #ifndef __DARWIN__
 652 wxChar *wxGetUserHome (const wxString& user)
 653 {
 654     // TODO
 655     return NULL;
 656 }
 657
 658 bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 659 {
 660     if ( path.empty() )
 661         return false;
 662
 663     wxString p = path ;
 664     if (p[0u] == ':' ) {
 665       p = wxGetCwd() + p ;
 666     }
 667
 668     int pos = p.Find(':') ;
 669     if ( pos != wxNOT_FOUND ) {
 670       p = p.Mid(1,pos) ;
 671     }
 672
 673     p = p + wxT(":") ;
 674
 675     OSErr err = noErr ;
 676
 677     FSRef fsRef ;
 678     err = wxMacPathToFSRef( p , &fsRef ) ;
 679     if ( noErr == err )
 680     {
 681         FSVolumeRefNum vRefNum ;
 682         err = FSGetVRefNum( &fsRef , &vRefNum ) ;
 683         if ( noErr == err )
 684         {
 685             UInt64 freeBytes , totalBytes ;
 686             err = FSGetVInfo( vRefNum , NULL , &freeBytes , &totalBytes ) ;
 687             if ( noErr == err )
 688             {
 689                 if ( pTotal )
 690                     *pTotal = wxLongLong( totalBytes ) ;
 691                 if ( pFree )
 692                     *pFree = wxLongLong( freeBytes ) ;
 693             }
 694         }
 695     }
 696
 697     return err == noErr ;
 698 }
 699 #endif // !__DARWIN__
 700
 701 //---------------------------------------------------------------------------
 702 // wxMac Specific utility functions
 703 //---------------------------------------------------------------------------
 704
 705 void wxMacStringToPascal( const wxString&from , StringPtr to )
 706 {
 707     wxCharBuffer buf = from.mb_str( wxConvLocal ) ;
 708     int len = strlen(buf) ;
 709
 710     if ( len > 255 )
 711         len = 255 ;
 712     to[0] = len ;
 713     memcpy( (char*) &to[1] , buf , len ) ;
 714 }
 715
 716 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
 717 {
 718     return wxString( (char*) &from[1] , wxConvLocal , from[0] ) ;
 719 }
 720
 721
 722 // ----------------------------------------------------------------------------
 723 // Common Event Support
 724 // ----------------------------------------------------------------------------
 725
 726
 727 extern ProcessSerialNumber gAppProcess ;
 728
 729 void wxMacWakeUp()
 730 {
 731     ProcessSerialNumber psn ;
 732     Boolean isSame ;
 733     psn.highLongOfPSN = 0 ;
 734     psn.lowLongOfPSN = kCurrentProcess ;
 735     SameProcess( &gAppProcess , &psn , &isSame ) ;
 736     if ( isSame )
 737     {
 738 #if TARGET_CARBON
 739         static wxMacCarbonEvent s_wakeupEvent ;
 740         OSStatus err = noErr ;
 741         if ( !s_wakeupEvent.IsValid() )
 742         {
 743            err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
 744                         kEventAttributeNone ) ;
 745         }
 746         if ( err == noErr )
 747         {
 748             if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
 749                 return ;
 750             s_wakeupEvent.SetTime(0) ;
 751             err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
 752                                   kEventPriorityHigh);
 753         }
 754 #else
 755         PostEvent( nullEvent , 0 ) ;
 756 #endif
 757     }
 758     else
 759     {
 760         WakeUpProcess( &gAppProcess ) ;
 761     }
 762 }
 763
 764 #endif // wxUSE_BASE
 765
 766 #if wxUSE_GUI
 767
 768 // ----------------------------------------------------------------------------
 769 // Native Struct Conversions
 770 // ----------------------------------------------------------------------------
 771
 772
 773 void wxMacRectToNative( const wxRect *wx , Rect *n )
 774 {
 775     n->left = wx->x ;
 776     n->top = wx->y ;
 777     n->right = wx->x + wx->width ;
 778     n->bottom = wx->y + wx->height ;
 779 }
 780
 781 void wxMacNativeToRect( const Rect *n , wxRect* wx )
 782 {
 783     wx->x = n->left ;
 784     wx->y = n->top ;
 785     wx->width = n->right - n->left ;
 786     wx->height = n->bottom - n->top ;
 787 }
 788
 789 void wxMacPointToNative( const wxPoint* wx , Point *n )
 790 {
 791     n->h = wx->x ;
 792     n->v = wx->y ;
 793 }
 794
 795 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
 796 {
 797     wx->x = n->h ;
 798     wx->y = n->v ;
 799 }
 800
 801 // ----------------------------------------------------------------------------
 802 // Carbon Event Support
 803 // ----------------------------------------------------------------------------
 804
 805
 806 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
 807 {
 808     return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData ) ;
 809 }
 810
 811 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
 812 {
 813     return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData ) ;
 814 }
 815
 816 // ----------------------------------------------------------------------------
 817 // Control Access Support
 818 // ----------------------------------------------------------------------------
 819
 820 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
 821 {
 822     Init() ;
 823     m_peer = peer ;
 824     m_isRootControl = isRootControl ;
 825     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
 826 }
 827
 828 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
 829 {
 830     Init() ;
 831     m_peer = peer ;
 832     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
 833     m_controlRef = control ;
 834 }
 835
 836 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
 837 {
 838     Init() ;
 839     m_peer = peer ;
 840     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
 841     m_controlRef = (ControlRef) control ;
 842 }
 843
 844 wxMacControl::~wxMacControl()
 845 {
 846 }
 847
 848 void wxMacControl::Init()
 849 {
 850     m_peer = NULL ;
 851     m_controlRef = NULL ;
 852     m_needsFocusRect = false ;
 853     m_isCompositing = false ;
 854     m_isRootControl = false ;
 855 }
 856
 857 void wxMacControl::Dispose()
 858 {
 859     ::DisposeControl( m_controlRef ) ;
 860     m_controlRef = NULL ;
 861 }
 862
 863 void wxMacControl::SetReference( SInt32 data )
 864 {
 865     SetControlReference( m_controlRef , data ) ;
 866 }
 867
 868 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
 869 {
 870     return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize ) ;
 871 }
 872
 873 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
 874 {
 875     return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize ) ;
 876 }
 877
 878 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
 879 {
 880     return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData ) ;
 881 }
 882
 883 OSStatus wxMacControl::SendEvent(  EventRef event , OptionBits inOptions )
 884 {
 885 #if TARGET_API_MAC_OSX
 886     return SendEventToEventTargetWithOptions( event,
 887         HIObjectGetEventTarget(  (HIObjectRef) m_controlRef ), inOptions );
 888 #else
 889     #pragma unused(inOptions)
 890     return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) ) ;
 891 #endif
 892 }
 893
 894 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
 895 {
 896     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess ) ;
 897     event.SetParameter<HICommand>(kEventParamDirectObject,command) ;
 898     return SendEvent( event , inOptions ) ;
 899 }
 900
 901 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions  )
 902 {
 903     HICommand command ;
 904     memset( &command, 0 , sizeof(command) ) ;
 905     command.commandID = commandID ;
 906     return SendHICommand( command , inOptions ) ;
 907 }
 908
 909 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
 910 {
 911     HiliteControl( m_controlRef , part ) ;
 912     unsigned long finalTicks ;
 913     Delay( ticks , &finalTicks ) ;
 914     HiliteControl( m_controlRef , kControlNoPart ) ;
 915 }
 916
 917 SInt32 wxMacControl::GetValue() const
 918 {
 919     return ::GetControl32BitValue( m_controlRef ) ;
 920 }
 921
 922 SInt32 wxMacControl::GetMaximum() const
 923 {
 924     return ::GetControl32BitMaximum( m_controlRef ) ;
 925 }
 926
 927 SInt32 wxMacControl::GetMinimum() const
 928 {
 929     return ::GetControl32BitMinimum( m_controlRef ) ;
 930 }
 931
 932 void wxMacControl::SetValue( SInt32 v )
 933 {
 934     ::SetControl32BitValue( m_controlRef , v ) ;
 935 }
 936
 937 void wxMacControl::SetMinimum( SInt32 v )
 938 {
 939     ::SetControl32BitMinimum( m_controlRef , v ) ;
 940 }
 941
 942 void wxMacControl::SetMaximum( SInt32 v )
 943 {
 944     ::SetControl32BitMaximum( m_controlRef , v ) ;
 945 }
 946
 947 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
 948 {
 949     ::SetControl32BitMinimum( m_controlRef , minimum ) ;
 950     ::SetControl32BitMaximum( m_controlRef , maximum ) ;
 951     ::SetControl32BitValue( m_controlRef , value ) ;
 952 }
 953
 954 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
 955 {
 956     return SetKeyboardFocus(  GetControlOwner( m_controlRef )  ,
 957         m_controlRef , focusPart ) ;
 958 }
 959
 960 bool wxMacControl::HasFocus() const
 961 {
 962     ControlRef control ;
 963     GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
 964     return control == m_controlRef ;
 965 }
 966
 967 void wxMacControl::SetNeedsFocusRect( bool needs )
 968 {
 969     m_needsFocusRect = needs ;
 970 }
 971
 972 bool wxMacControl::NeedsFocusRect() const
 973 {
 974     return m_needsFocusRect ;
 975 }
 976
 977 void wxMacControl::VisibilityChanged(bool shown)
 978 {
 979 }
 980
 981 void wxMacControl::SuperChangedPosition()
 982 {
 983 }
 984
 985 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
 986 {
 987     m_font = font ;
 988     ControlFontStyleRec fontStyle;
 989     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 990     {
 991         switch( font.MacGetThemeFontID() )
 992         {
 993             case kThemeSmallSystemFont :    fontStyle.font = kControlFontSmallSystemFont ;  break ;
 994             case 109 /*mini font */ :       fontStyle.font = -5 ;                           break ;
 995             case kThemeSystemFont :         fontStyle.font = kControlFontBigSystemFont ;    break ;
 996             default :                       fontStyle.font = kControlFontBigSystemFont ;    break ;
 997         }
 998         fontStyle.flags = kControlUseFontMask ;
 999     }
1000     else
1001     {
1002         fontStyle.font = font.MacGetFontNum() ;
1003         fontStyle.style = font.MacGetFontStyle() ;
1004         fontStyle.size = font.MacGetFontSize() ;
1005         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask ;
1006     }
1007
1008     fontStyle.just = teJustLeft ;
1009     fontStyle.flags |= kControlUseJustMask ;
1010     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1011         fontStyle.just = teJustCenter ;
1012     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1013         fontStyle.just = teJustRight ;
1014
1015
1016     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1017     // won't get grayed out by the system anymore
1018
1019     if ( foreground != *wxBLACK )
1020     {
1021         fontStyle.foreColor = MAC_WXCOLORREF(foreground.GetPixel() ) ;
1022         fontStyle.flags |= kControlUseForeColorMask ;
1023     }
1024
1025     ::SetControlFontStyle( m_controlRef , &fontStyle );
1026 }
1027
1028 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1029 {
1030     // TODO
1031     // setting up a color proc is not recommended anymore
1032 }
1033
1034 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1035 {
1036     ::SetControl32BitMinimum( m_controlRef , minimum ) ;
1037     ::SetControl32BitMaximum( m_controlRef , maximum ) ;
1038 }
1039
1040 short wxMacControl::HandleKey(  SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1041 {
1042     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers ) ;
1043 }
1044
1045 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1046 {
1047     SetControlAction( m_controlRef , actionProc ) ;
1048 }
1049
1050 void wxMacControl::SetViewSize( SInt32 viewSize )
1051 {
1052     SetControlViewSize(m_controlRef , viewSize ) ;
1053 }
1054
1055 SInt32 wxMacControl::GetViewSize() const
1056 {
1057     return GetControlViewSize( m_controlRef ) ;
1058 }
1059
1060 bool wxMacControl::IsVisible() const
1061 {
1062     return IsControlVisible( m_controlRef ) ;
1063 }
1064
1065 void wxMacControl::SetVisibility( bool visible , bool redraw )
1066 {
1067     SetControlVisibility( m_controlRef , visible , redraw ) ;
1068 }
1069
1070 bool wxMacControl::IsEnabled() const
1071 {
1072 #if TARGET_API_MAC_OSX
1073     return IsControlEnabled( m_controlRef ) ;
1074 #else
1075     return IsControlActive( m_controlRef ) ;
1076 #endif
1077 }
1078
1079 bool wxMacControl::IsActive() const
1080 {
1081     return IsControlActive( m_controlRef ) ;
1082 }
1083
1084 void wxMacControl::Enable( bool enable )
1085 {
1086 #if TARGET_API_MAC_OSX
1087     if ( enable )
1088         EnableControl( m_controlRef ) ;
1089     else
1090         DisableControl( m_controlRef ) ;
1091 #else
1092     if ( enable )
1093         ActivateControl( m_controlRef ) ;
1094     else
1095         DeactivateControl( m_controlRef ) ;
1096 #endif
1097 }
1098
1099 void wxMacControl::SetDrawingEnabled( bool enable )
1100 {
1101 #if TARGET_API_MAC_OSX
1102     HIViewSetDrawingEnabled( m_controlRef , enable ) ;
1103 #endif
1104 }
1105
1106 #if TARGET_API_MAC_OSX
1107 bool wxMacControl::GetNeedsDisplay() const
1108 {
1109 #if TARGET_API_MAC_OSX
1110     return HIViewGetNeedsDisplay( m_controlRef ) ;
1111 #else
1112     return false ;
1113 #endif
1114 }
1115 #endif
1116
1117 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1118 {
1119     if ( !IsVisible() )
1120         return ;
1121
1122 #if TARGET_API_MAC_OSX
1123     if ( m_isCompositing )
1124     {
1125         HIViewSetNeedsDisplayInRegion( m_controlRef , where , true ) ;
1126     }
1127     else
1128 #endif
1129     {
1130         Rect controlBounds ;
1131         GetControlBounds( m_controlRef, &controlBounds ) ;
1132         RgnHandle update = NewRgn() ;
1133         CopyRgn( where , update ) ;
1134         OffsetRgn( update , controlBounds.left , controlBounds.top ) ;
1135         InvalWindowRgn( GetControlOwner( m_controlRef) , update ) ;
1136     }
1137 }
1138
1139 void wxMacControl::SetNeedsDisplay( Rect* where )
1140 {
1141     if ( !IsVisible() )
1142         return ;
1143
1144 #if TARGET_API_MAC_OSX
1145     if ( m_isCompositing )
1146     {
1147         if ( where != NULL )
1148         {
1149             RgnHandle update = NewRgn() ;
1150             RectRgn( update , where ) ;
1151             HIViewSetNeedsDisplayInRegion( m_controlRef , update , true ) ;
1152             DisposeRgn( update ) ;
1153         }
1154         else
1155             HIViewSetNeedsDisplay( m_controlRef , true ) ;
1156     }
1157     else
1158 #endif
1159     {
1160         Rect controlBounds ;
1161         GetControlBounds( m_controlRef, &controlBounds ) ;
1162         if ( where )
1163         {
1164             Rect whereLocal = *where ;
1165             OffsetRect( &whereLocal , controlBounds.left , controlBounds.top ) ;
1166             SectRect( &controlBounds , &whereLocal, &controlBounds ) ;
1167         }
1168         InvalWindowRect( GetControlOwner( m_controlRef) , &controlBounds ) ;
1169     }
1170 }
1171
1172 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1173 {
1174 #if TARGET_API_MAC_OSX
1175     if ( from->m_peer->MacGetTopLevelWindow()->MacUsesCompositing() )
1176     {
1177         HIPoint hiPoint ;
1178         hiPoint.x = pt->x ;
1179         hiPoint.y = pt->y ;
1180         HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  ) ;
1181         pt->x = (int)hiPoint.x ;
1182         pt->y = (int)hiPoint.y ;
1183     }
1184     else
1185 #endif
1186     {
1187         Rect fromRect ;
1188         Rect toRect ;
1189         GetControlBounds( from->m_controlRef , &fromRect ) ;
1190         GetControlBounds( to->m_controlRef , &toRect ) ;
1191         if ( from->m_isRootControl )
1192             fromRect.left = fromRect.top = 0 ;
1193         if ( to->m_isRootControl )
1194             toRect.left = toRect.top = 0 ;
1195
1196         pt->x = pt->x + fromRect.left - toRect.left ;
1197         pt->y = pt->y + fromRect.top - toRect.top ;
1198     }
1199 }
1200
1201 void wxMacControl::SetRect( Rect *r )
1202 {
1203 #if TARGET_API_MAC_OSX
1204     if ( m_isCompositing )
1205     {
1206         //A HIRect is actually a CGRect on OSX - which consists of two structures -
1207         //CGPoint and CGSize, which have two floats each
1208         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } } ;
1209         HIViewSetFrame ( m_controlRef , &hir ) ;
1210         // eventuall we might have to do a SetVisibility( false , true ) ;
1211         // before and a SetVisibility( true , true ) ; after
1212     }
1213     else
1214 #endif
1215     {
1216         bool vis = IsVisible() ;
1217         if ( vis )
1218         {
1219             Rect former ;
1220             GetControlBounds( m_controlRef , &former ) ;
1221             InvalWindowRect( GetControlOwner( m_controlRef ) , &former ) ;
1222         }
1223
1224         Rect controlBounds = *r ;
1225
1226         wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1227         if( parent->m_isRootControl == false )
1228         {
1229             Rect superRect ;
1230             GetControlBounds( parent->m_controlRef , &superRect ) ;
1231             OffsetRect( &controlBounds , superRect.left , superRect.top ) ;
1232         }
1233
1234         SetControlBounds( m_controlRef , &controlBounds ) ;
1235         if ( vis )
1236         {
1237             InvalWindowRect( GetControlOwner( m_controlRef ) , &controlBounds ) ;
1238         }
1239     }
1240 }
1241
1242 void wxMacControl::GetRect( Rect *r )
1243 {
1244     GetControlBounds( m_controlRef , r ) ;
1245     if ( m_isCompositing == false )
1246     {
1247         // correct the case of the root control
1248         if ( m_isRootControl )
1249         {
1250             WindowRef wr = GetControlOwner( m_controlRef ) ;
1251             GetWindowBounds( wr , kWindowContentRgn , r ) ;
1252             r->right -= r->left ;
1253             r->bottom -= r->top ;
1254             r->left = 0 ;
1255             r->top = 0 ;
1256         }
1257         else
1258         {
1259             wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1260             if( parent->m_isRootControl == false )
1261             {
1262                 Rect superRect ;
1263                 GetControlBounds( parent->m_controlRef , &superRect ) ;
1264                 OffsetRect( r , -superRect.left , -superRect.top ) ;
1265             }
1266         }
1267     }
1268 }
1269
1270 void wxMacControl::GetRectInWindowCoords( Rect *r )
1271 {
1272     UMAGetControlBoundsInWindowCoords( m_controlRef , r ) ;
1273 }
1274
1275 void wxMacControl::GetBestRect( Rect *r )
1276 {
1277     short   baselineoffset ;
1278     GetBestControlRect( m_controlRef , r , &baselineoffset ) ;
1279 }
1280
1281 void wxMacControl::SetTitle( const wxString &title )
1282 {
1283     wxFontEncoding encoding;
1284
1285     if ( m_font.Ok() )
1286         encoding = m_font.GetEncoding();
1287     else
1288         encoding = wxFont::GetDefaultEncoding();
1289
1290     UMASetControlTitle(  m_controlRef , title , encoding ) ;
1291 }
1292
1293 void wxMacControl::GetFeatures( UInt32 * features )
1294 {
1295     GetControlFeatures( m_controlRef , features ) ;
1296 }
1297
1298 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1299 {
1300     OSStatus err = GetControlRegion( m_controlRef , partCode , region ) ;
1301     if ( m_isCompositing == false )
1302     {
1303         if ( !m_isRootControl )
1304         {
1305             Rect r ;
1306             GetControlBounds(m_controlRef, &r ) ;
1307             if ( !EmptyRgn( region ) )
1308                 OffsetRgn( region , -r.left , -r.top ) ;
1309         }
1310     }
1311     return err ;
1312 }
1313
1314 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1315 {
1316 #if TARGET_API_MAC_OSX
1317     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1318        (other != NULL) ? other->m_controlRef : NULL) ;
1319 #else
1320     return 0 ;
1321 #endif
1322 }
1323
1324
1325 #if TARGET_API_MAC_OSX
1326 // SetNeedsDisplay would not invalidate the children
1327 static void InvalidateControlAndChildren( HIViewRef control )
1328 {
1329     HIViewSetNeedsDisplay( control , true ) ;
1330     UInt16 childrenCount = 0 ;
1331     OSStatus err = CountSubControls( control , &childrenCount ) ;
1332     if ( err == errControlIsNotEmbedder )
1333         return ;
1334     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") ) ;
1335
1336     for ( UInt16 i = childrenCount ; i >=1  ; --i )
1337     {
1338         HIViewRef child ;
1339         err = GetIndexedSubControl( control , i , & child ) ;
1340         if ( err == errControlIsNotEmbedder )
1341             return ;
1342         InvalidateControlAndChildren( child ) ;
1343     }
1344 }
1345 #endif
1346
1347 void wxMacControl::InvalidateWithChildren()
1348 {
1349 #if TARGET_API_MAC_OSX
1350     InvalidateControlAndChildren( m_controlRef ) ;
1351 #endif
1352 }
1353
1354 void wxMacControl::ScrollRect( const wxRect &r , int dx , int dy )
1355 {
1356 #if TARGET_API_MAC_OSX
1357     HIRect scrollarea = CGRectMake( r.x , r.y , r.width , r.height) ;
1358     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy ) ;
1359 #endif
1360 }
1361
1362
1363 // SetNeedsDisplay would not invalidate the children
1364
1365 //
1366 // Databrowser
1367 //
1368
1369 OSStatus wxMacControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1370 {
1371     return SetDataBrowserSelectionFlags( m_controlRef , options ) ;
1372 }
1373
1374 OSStatus wxMacControl::AddListViewColumn( DataBrowserListViewColumnDesc *columnDesc,
1375         DataBrowserTableViewColumnIndex position )
1376 {
1377     return AddDataBrowserListViewColumn( m_controlRef , columnDesc, position ) ;
1378 }
1379
1380 OSStatus wxMacControl::AutoSizeListViewColumns()
1381 {
1382     return AutoSizeDataBrowserListViewColumns(m_controlRef) ;
1383 }
1384
1385 OSStatus wxMacControl::SetHasScrollBars( bool horiz , bool vert )
1386 {
1387     return SetDataBrowserHasScrollBars( m_controlRef , horiz , vert ) ;
1388 }
1389
1390 OSStatus wxMacControl::SetTableViewHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1391 {
1392     return SetDataBrowserTableViewHiliteStyle( m_controlRef , hiliteStyle ) ;
1393 }
1394
1395 OSStatus wxMacControl::SetListViewHeaderBtnHeight(UInt16 height)
1396 {
1397     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef ,height ) ;
1398 }
1399
1400 OSStatus wxMacControl::SetCallbacks(const DataBrowserCallbacks *  callbacks)
1401 {
1402     return SetDataBrowserCallbacks( m_controlRef , callbacks ) ;
1403 }
1404
1405 OSStatus wxMacControl::UpdateItems( DataBrowserItemID container, UInt32 numItems,
1406         const DataBrowserItemID* items,
1407         DataBrowserPropertyID preSortProperty,
1408         DataBrowserPropertyID propertyID )
1409 {
1410     return UpdateDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty, propertyID ) ;
1411 }
1412
1413 bool wxMacControl::IsItemSelected( DataBrowserItemID item )
1414 {
1415     return IsDataBrowserItemSelected( m_controlRef , item ) ;
1416 }
1417
1418 OSStatus wxMacControl::AddItems( DataBrowserItemID container, UInt32 numItems,
1419             const DataBrowserItemID* items,
1420             DataBrowserPropertyID preSortProperty )
1421 {
1422     return AddDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1423 }
1424
1425 OSStatus wxMacControl::RemoveItems( DataBrowserItemID container, UInt32 numItems,
1426             const DataBrowserItemID* items,
1427             DataBrowserPropertyID preSortProperty )
1428 {
1429     return RemoveDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1430 }
1431
1432 OSStatus wxMacControl::RevealItem( DataBrowserItemID item,
1433             DataBrowserPropertyID propertyID,
1434             DataBrowserRevealOptions options )
1435 {
1436     return RevealDataBrowserItem( m_controlRef , item , propertyID , options ) ;
1437 }
1438
1439 OSStatus wxMacControl::SetSelectedItems(UInt32 numItems,
1440             const DataBrowserItemID * items,
1441             DataBrowserSetOption operation )
1442 {
1443     return SetDataBrowserSelectedItems( m_controlRef , numItems , items, operation ) ;
1444 }
1445
1446 OSStatus wxMacControl::GetSelectionAnchor( DataBrowserItemID * first, DataBrowserItemID * last )
1447 {
1448     return GetDataBrowserSelectionAnchor( m_controlRef , first , last ) ;
1449 }
1450
1451 //
1452 // Tab Control
1453 //
1454
1455 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1456 {
1457     return ::SetTabEnabled( m_controlRef , tabNo , enable ) ;
1458 }
1459
1460 //
1461 // Quartz Support
1462 //
1463
1464 #ifdef __WXMAC_OSX__
1465 // snippets from Sketch Sample from Apple :
1466
1467 #define kGenericRGBProfilePathStr       "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
1468 /*
1469     This function locates, opens, and returns the profile reference for the calibrated
1470     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
1471     with the profile reference this function returns.
1472 */
1473 CMProfileRef wxMacOpenGenericProfile(void)
1474 {
1475     static CMProfileRef cachedRGBProfileRef = NULL;
1476
1477     // we only create the profile reference once
1478     if (cachedRGBProfileRef == NULL)
1479     {
1480                 CMProfileLocation       loc;
1481
1482                 loc.locType = cmPathBasedProfile;
1483                 strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
1484
1485                 verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
1486     }
1487
1488     if (cachedRGBProfileRef)
1489     {
1490                 // clone the profile reference so that the caller has their own reference, not our cached one
1491                 CMCloneProfileRef(cachedRGBProfileRef);
1492     }
1493
1494     return cachedRGBProfileRef;
1495 }
1496
1497 /*
1498     Return the generic RGB color space. This is a 'get' function and the caller should
1499     not release the returned value unless the caller retains it first. Usually callers
1500     of this routine will immediately use the returned colorspace with CoreGraphics
1501     so they typically do not need to retain it themselves.
1502
1503     This function creates the generic RGB color space once and hangs onto it so it can
1504     return it whenever this function is called.
1505 */
1506
1507 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1508 {
1509     static CGColorSpaceRef genericRGBColorSpace = NULL;
1510
1511         if (genericRGBColorSpace == NULL)
1512         {
1513                 CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
1514
1515                 if (genericRGBProfile)
1516                 {
1517                         genericRGBColorSpace = CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile);
1518                         wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") ) ;
1519
1520                         // we opened the profile so it is up to us to close it
1521                         CMCloseProfile(genericRGBProfile);
1522                 }
1523         }
1524     return genericRGBColorSpace;
1525 }
1526 #endif
1527
1528 #endif // wxUSE_GUI
1529