src/mac/carbon/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/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 #include "wx/wxprec.h"
  13
  14 #include "wx/utils.h"
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/intl.h"
  18     #include "wx/app.h"
  19     #if wxUSE_GUI
  20         #include "wx/toplevel.h"
  21         #include "wx/font.h"
  22     #endif
  23 #endif
  24
  25 #include "wx/apptrait.h"
  26
  27 #if wxUSE_GUI
  28     #include "wx/mac/uma.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 #ifdef __DARWIN__
  54     #include <Carbon/Carbon.h>
  55 #else
  56     #include <ATSUnicode.h>
  57     #include <TextCommon.h>
  58     #include <TextEncodingConverter.h>
  59 #endif
  60 #endif // wxUSE_GUI
  61
  62 #include "wx/mac/private.h"
  63
  64 #if defined(__MWERKS__) && wxUSE_UNICODE
  65 #if __MWERKS__ < 0x4100 || !defined(__DARWIN__)
  66     #include <wtime.h>
  67 #endif
  68 #endif
  69
  70 // ---------------------------------------------------------------------------
  71 // code used in both base and GUI compilation
  72 // ---------------------------------------------------------------------------
  73
  74 // our OS version is the same in non GUI and GUI cases
  75 static int DoGetOSVersion(int *majorVsn, int *minorVsn)
  76 {
  77     long theSystem;
  78
  79     // are there x-platform conventions ?
  80
  81     Gestalt(gestaltSystemVersion, &theSystem);
  82     if (minorVsn != NULL)
  83         *minorVsn = (theSystem & 0xFF);
  84
  85     if (majorVsn != NULL)
  86         *majorVsn = (theSystem >> 8);
  87
  88 #ifdef __DARWIN__
  89     return wxMAC_DARWIN;
  90 #else
  91     return wxMAC;
  92 #endif
  93 }
  94
  95
  96 #if wxUSE_BASE
  97
  98 // ----------------------------------------------------------------------------
  99 // debugging support
 100 // ----------------------------------------------------------------------------
 101
 102 #if defined(__WXDEBUG__) && defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
 103
 104 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
 105
 106 #ifndef __MetroNubUtils__
 107 #include "MetroNubUtils.h"
 108 #endif
 109
 110 #ifndef __GESTALT__
 111 #include <Gestalt.h>
 112 #endif
 113
 114 #if TARGET_API_MAC_CARBON
 115
 116 #include <CodeFragments.h>
 117
 118 extern "C" long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
 119
 120 ProcPtr gCallUniversalProc_Proc = NULL;
 121
 122 #endif
 123
 124 static MetroNubUserEntryBlock*    gMetroNubEntry = NULL;
 125
 126 static long fRunOnce = false;
 127
 128
 129 Boolean IsMetroNubInstalled()
 130 {
 131     if (!fRunOnce)
 132     {
 133         long result, value;
 134
 135         fRunOnce = true;
 136         gMetroNubEntry = NULL;
 137
 138         if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
 139         {
 140             // look for MetroNub's Gestalt selector
 141             if (Gestalt(kMetroNubUserSignature, &result) == noErr)
 142             {
 143 #if TARGET_API_MAC_CARBON
 144                 if (gCallUniversalProc_Proc == NULL)
 145                 {
 146                     CFragConnectionID   connectionID;
 147                     Ptr                 mainAddress;
 148                     Str255              errorString;
 149                     ProcPtr             symbolAddress;
 150                     OSErr               err;
 151                     CFragSymbolClass    symbolClass;
 152
 153                     symbolAddress = NULL;
 154                     err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
 155                                            &connectionID, &mainAddress, errorString);
 156
 157                     if (err != noErr)
 158                     {
 159                         gCallUniversalProc_Proc = NULL;
 160                         goto end;
 161                     }
 162
 163                     err = FindSymbol(connectionID, "\pCallUniversalProc",
 164                                     (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
 165
 166                     if (err != noErr)
 167                     {
 168                         gCallUniversalProc_Proc = NULL;
 169                         goto end;
 170                     }
 171                 }
 172 #endif
 173
 174                 {
 175                     MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
 176
 177                     // make sure the version of the API is compatible
 178                     if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
 179                         kMetroNubUserAPIVersion <= block->apiHiVersion)
 180                     {
 181                         // success!
 182                         gMetroNubEntry = block;
 183                     }
 184                 }
 185             }
 186         }
 187     }
 188
 189 end:
 190
 191 #if TARGET_API_MAC_CARBON
 192     return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
 193 #else
 194     return (gMetroNubEntry != NULL);
 195 #endif
 196 }
 197
 198 Boolean IsMWDebuggerRunning()
 199 {
 200     if (IsMetroNubInstalled())
 201         return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
 202
 203     return false;
 204 }
 205
 206 Boolean AmIBeingMWDebugged()
 207 {
 208     if (IsMetroNubInstalled())
 209         return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
 210
 211     return false;
 212 }
 213
 214 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 215 {
 216     return IsMWDebuggerRunning() && AmIBeingMWDebugged();
 217 }
 218
 219 #else
 220
 221 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 222 {
 223     return false;
 224 }
 225
 226 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
 227
 228
 229 #ifndef __DARWIN__
 230 // defined in unix/utilsunx.cpp for Mac OS X
 231
 232 // get full hostname (with domain name if possible)
 233 bool wxGetFullHostName(wxChar *buf, int maxSize)
 234 {
 235     return wxGetHostName(buf, maxSize);
 236 }
 237
 238 // Get user ID e.g. jacs
 239 bool wxGetUserId(wxChar *buf, int maxSize)
 240 {
 241     return wxGetUserName( buf , maxSize );
 242 }
 243
 244 const wxChar* wxGetHomeDir(wxString *pstr)
 245 {
 246     *pstr = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder );
 247     return pstr->c_str();
 248 }
 249
 250 // Get hostname only (without domain name)
 251 bool wxGetHostName(wxChar *buf, int maxSize)
 252 {
 253     // Gets Chooser name of user by examining a System resource.
 254     buf[0] = 0;
 255
 256     const short kComputerNameID = -16413;
 257
 258     short oldResFile = CurResFile();
 259     UseResFile(0);
 260     StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
 261     UseResFile(oldResFile);
 262
 263     if (chooserName && *chooserName)
 264     {
 265         HLock( (Handle) chooserName );
 266         wxString name = wxMacMakeStringFromPascal( *chooserName );
 267         HUnlock( (Handle) chooserName );
 268         ReleaseResource( (Handle) chooserName );
 269         wxStrncpy( buf , name , maxSize - 1 );
 270     }
 271
 272     return true;
 273 }
 274
 275 // Get user name e.g. Stefan Csomor
 276 bool wxGetUserName(wxChar *buf, int maxSize)
 277 {
 278     // Gets Chooser name of user by examining a System resource.
 279     buf[0] = 0;
 280
 281     const short kChooserNameID = -16096;
 282
 283     short oldResFile = CurResFile();
 284     UseResFile(0);
 285     StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
 286     UseResFile(oldResFile);
 287
 288     if (chooserName && *chooserName)
 289     {
 290         HLock( (Handle) chooserName );
 291         wxString name = wxMacMakeStringFromPascal( *chooserName );
 292         HUnlock( (Handle) chooserName );
 293         ReleaseResource( (Handle) chooserName );
 294         wxStrncpy( buf , name , maxSize - 1 );
 295     }
 296
 297     return true;
 298 }
 299
 300 int wxKill(long pid, wxSignal sig , wxKillError *rc, int flags)
 301 {
 302     // TODO
 303     return 0;
 304 }
 305
 306 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
 307 {
 308     // TODO : under classic there is no environement support, under X yes
 309     return false;
 310 }
 311
 312 // set the env var name to the given value, return true on success
 313 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
 314 {
 315     // TODO : under classic there is no environement support, under X yes
 316     return false;
 317 }
 318
 319 // Execute a program in an Interactive Shell
 320 bool wxShell(const wxString& command)
 321 {
 322     // TODO
 323     return false;
 324 }
 325
 326 // Shutdown or reboot the PC
 327 bool wxShutdown(wxShutdownFlags wFlags)
 328 {
 329     // TODO
 330     return false;
 331 }
 332
 333 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 334 wxMemorySize wxGetFreeMemory()
 335 {
 336     return (wxMemorySize)FreeMem();
 337 }
 338
 339 #ifndef __DARWIN__
 340
 341 void wxMicroSleep(unsigned long microseconds)
 342 {
 343     AbsoluteTime wakeup = AddDurationToAbsolute( microseconds * durationMicrosecond , UpTime());
 344     MPDelayUntil( & wakeup);
 345 }
 346
 347 void wxMilliSleep(unsigned long milliseconds)
 348 {
 349     AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime());
 350     MPDelayUntil( & wakeup);
 351 }
 352
 353 void wxSleep(int nSecs)
 354 {
 355     wxMilliSleep(1000*nSecs);
 356 }
 357
 358 #endif
 359
 360 // Consume all events until no more left
 361 void wxFlushEvents()
 362 {
 363 }
 364
 365 #endif // !__DARWIN__
 366
 367 // Emit a beeeeeep
 368 void wxBell()
 369 {
 370     SysBeep(30);
 371 }
 372
 373 wxToolkitInfo& wxConsoleAppTraits::GetToolkitInfo()
 374 {
 375     static wxToolkitInfo info;
 376
 377     info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
 378     info.name = _T("wxBase");
 379
 380     return info;
 381 }
 382
 383 #endif // wxUSE_BASE
 384
 385 #if wxUSE_GUI
 386
 387 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
 388 {
 389     static wxToolkitInfo info;
 390
 391     info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
 392     info.shortName = _T("mac");
 393     info.name = _T("wxMac");
 394
 395 #ifdef __WXUNIVERSAL__
 396     info.shortName << _T("univ");
 397     info.name << _T("/wxUniversal");
 398 #endif
 399
 400     return info;
 401 }
 402
 403 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 404 #if wxUSE_RESOURCES
 405 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
 406 {
 407     // TODO
 408     return false;
 409 }
 410
 411 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 412 {
 413     wxString buf;
 414     buf.Printf(wxT("%.4f"), value);
 415
 416     return wxWriteResource(section, entry, buf, file);
 417 }
 418
 419 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 420 {
 421     wxString buf;
 422     buf.Printf(wxT("%ld"), value);
 423
 424     return wxWriteResource(section, entry, buf, file);
 425 }
 426
 427 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 428 {
 429     wxString buf;
 430     buf.Printf(wxT("%d"), value);
 431
 432     return wxWriteResource(section, entry, buf, file);
 433 }
 434
 435 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
 436 {
 437     // TODO
 438     return false;
 439 }
 440
 441 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
 442 {
 443     char *s = NULL;
 444     bool succ = wxGetResource(section, entry, (char **)&s, file);
 445     if (succ)
 446     {
 447         *value = (float)strtod(s, NULL);
 448         delete[] s;
 449     }
 450
 451     return succ;
 452 }
 453
 454 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
 455 {
 456     char *s = NULL;
 457     bool succ = wxGetResource(section, entry, (char **)&s, file);
 458     if (succ)
 459     {
 460         *value = strtol(s, NULL, 10);
 461         delete[] s;
 462     }
 463
 464     return succ;
 465 }
 466
 467 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 468 {
 469     char *s = NULL;
 470     bool succ = wxGetResource(section, entry, (char **)&s, file);
 471     if (succ)
 472     {
 473         *value = (int)strtol(s, NULL, 10);
 474         delete[] s;
 475     }
 476
 477     return succ;
 478 }
 479 #endif // wxUSE_RESOURCES
 480
 481 int gs_wxBusyCursorCount = 0;
 482 extern wxCursor    gMacCurrentCursor;
 483 wxCursor        gMacStoredActiveCursor;
 484
 485 // Set the cursor to the busy cursor for all windows
 486 void wxBeginBusyCursor(const wxCursor *cursor)
 487 {
 488     if (gs_wxBusyCursorCount++ == 0)
 489     {
 490         gMacStoredActiveCursor = gMacCurrentCursor;
 491         cursor->MacInstall();
 492     }
 493     //else: nothing to do, already set
 494 }
 495
 496 // Restore cursor to normal
 497 void wxEndBusyCursor()
 498 {
 499     wxCHECK_RET( gs_wxBusyCursorCount > 0,
 500         wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
 501
 502     if (--gs_wxBusyCursorCount == 0)
 503     {
 504         gMacStoredActiveCursor.MacInstall();
 505         gMacStoredActiveCursor = wxNullCursor;
 506     }
 507 }
 508
 509 // true if we're between the above two calls
 510 bool wxIsBusy()
 511 {
 512     return (gs_wxBusyCursorCount > 0);
 513 }
 514
 515 #endif // wxUSE_GUI
 516
 517 #if wxUSE_BASE
 518
 519 wxString wxMacFindFolderNoSeparator( short        vol,
 520               OSType       folderType,
 521               Boolean      createFolder)
 522 {
 523     FSRef fsRef;
 524     wxString strDir;
 525
 526     if ( FSFindFolder( vol, folderType, createFolder, &fsRef) == noErr)
 527     {
 528         strDir = wxMacFSRefToPath( &fsRef );
 529     }
 530
 531     return strDir;
 532 }
 533
 534 wxString wxMacFindFolder( short        vol,
 535               OSType       folderType,
 536               Boolean      createFolder)
 537 {
 538     return wxMacFindFolderNoSeparator(vol, folderType, createFolder) + wxFILE_SEP_PATH;
 539 }
 540
 541 #endif // wxUSE_BASE
 542
 543 #if wxUSE_GUI
 544
 545 // Check whether this window wants to process messages, e.g. Stop button
 546 // in long calculations.
 547 bool wxCheckForInterrupt(wxWindow *wnd)
 548 {
 549     // TODO
 550     return false;
 551 }
 552
 553 void wxGetMousePosition( int* x, int* y )
 554 {
 555     Point pt;
 556
 557     GetMouse( &pt );
 558     LocalToGlobal( &pt );
 559     *x = pt.h;
 560     *y = pt.v;
 561 };
 562
 563 // Return true if we have a colour display
 564 bool wxColourDisplay()
 565 {
 566     return true;
 567 }
 568
 569 // Returns depth of screen
 570 int wxDisplayDepth()
 571 {
 572     Rect globRect;
 573     SetRect(&globRect, -32760, -32760, 32760, 32760);
 574     GDHandle    theMaxDevice;
 575
 576     int theDepth = 8;
 577     theMaxDevice = GetMaxDevice(&globRect);
 578     if (theMaxDevice != NULL)
 579         theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
 580
 581     return theDepth;
 582 }
 583
 584 // Get size of display
 585 void wxDisplaySize(int *width, int *height)
 586 {
 587     BitMap screenBits;
 588     GetQDGlobalsScreenBits( &screenBits );
 589
 590     if (width != NULL)
 591         *width = screenBits.bounds.right - screenBits.bounds.left;
 592
 593     if (height != NULL)
 594         *height = screenBits.bounds.bottom - screenBits.bounds.top;
 595 }
 596
 597 void wxDisplaySizeMM(int *width, int *height)
 598 {
 599     wxDisplaySize(width, height);
 600     // on mac 72 is fixed (at least now;-)
 601     float cvPt2Mm = 25.4 / 72;
 602
 603     if (width != NULL)
 604         *width = int( *width * cvPt2Mm );
 605
 606     if (height != NULL)
 607         *height = int( *height * cvPt2Mm );
 608 }
 609
 610 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 611 {
 612     Rect r;
 613
 614     GetAvailableWindowPositioningBounds( GetMainDevice() , &r );
 615     if ( x )
 616         *x = r.left;
 617     if ( y )
 618         *y = r.top;
 619     if ( width )
 620         *width = r.right - r.left;
 621     if ( height )
 622         *height = r.bottom - r.top;
 623 }
 624
 625 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 626 {
 627     return wxGenericFindWindowAtPoint(pt);
 628 }
 629
 630 #endif // wxUSE_GUI
 631
 632 #if wxUSE_BASE
 633
 634 wxString wxGetOsDescription()
 635 {
 636 #ifdef WXWIN_OS_DESCRIPTION
 637     // use configure generated description if available
 638     return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
 639 #else
 640     return wxT("MacOS"); //TODO:define further
 641 #endif
 642 }
 643
 644 #ifndef __DARWIN__
 645 wxChar *wxGetUserHome (const wxString& user)
 646 {
 647     // TODO
 648     return NULL;
 649 }
 650
 651 bool wxGetDiskSpace(const wxString& path, wxDiskspaceSize_t *pTotal, wxDiskspaceSize_t *pFree)
 652 {
 653     if ( path.empty() )
 654         return false;
 655
 656     wxString p = path;
 657     if (p[0u] == ':' )
 658       p = wxGetCwd() + p;
 659
 660     int pos = p.Find(':');
 661     if ( pos != wxNOT_FOUND )
 662       p = p.Mid(1,pos);
 663
 664     p = p + wxT(":");
 665
 666     OSErr err = noErr;
 667
 668     FSRef fsRef;
 669     err = wxMacPathToFSRef( p , &fsRef );
 670     if ( noErr == err )
 671     {
 672         FSVolumeRefNum vRefNum;
 673         err = FSGetVRefNum( &fsRef , &vRefNum );
 674         if ( noErr == err )
 675         {
 676             UInt64 freeBytes , totalBytes;
 677             err = FSGetVInfo( vRefNum , NULL , &freeBytes , &totalBytes );
 678             if ( noErr == err )
 679             {
 680                 if ( pTotal )
 681                     *pTotal = wxDiskspaceSize_t( totalBytes );
 682                 if ( pFree )
 683                     *pFree = wxDiskspaceSize_t( freeBytes );
 684             }
 685         }
 686     }
 687
 688     return err == noErr;
 689 }
 690 #endif // !__DARWIN__
 691
 692 //---------------------------------------------------------------------------
 693 // wxMac Specific utility functions
 694 //---------------------------------------------------------------------------
 695
 696 void wxMacStringToPascal( const wxString&from , StringPtr to )
 697 {
 698     wxCharBuffer buf = from.mb_str( wxConvLocal );
 699     int len = strlen(buf);
 700
 701     if ( len > 255 )
 702         len = 255;
 703     to[0] = len;
 704     memcpy( (char*) &to[1] , buf , len );
 705 }
 706
 707 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
 708 {
 709     return wxString( (char*) &from[1] , wxConvLocal , from[0] );
 710 }
 711
 712 // ----------------------------------------------------------------------------
 713 // Common Event Support
 714 // ----------------------------------------------------------------------------
 715
 716 extern ProcessSerialNumber gAppProcess;
 717
 718 void wxMacWakeUp()
 719 {
 720     ProcessSerialNumber psn;
 721     Boolean isSame;
 722     psn.highLongOfPSN = 0;
 723     psn.lowLongOfPSN = kCurrentProcess;
 724     SameProcess( &gAppProcess , &psn , &isSame );
 725     if ( isSame )
 726     {
 727 #if TARGET_CARBON
 728         OSStatus err = noErr;
 729
 730 #if 0
 731         // lead sometimes to race conditions, although all calls used should be thread safe ...
 732         static wxMacCarbonEvent s_wakeupEvent;
 733         if ( !s_wakeupEvent.IsValid() )
 734         {
 735            err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
 736                         kEventAttributeNone );
 737         }
 738         if ( err == noErr )
 739         {
 740
 741             if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
 742                 return;
 743             s_wakeupEvent.SetCurrentTime();
 744             err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
 745                                   kEventPriorityHigh );
 746         }
 747 #else
 748         wxMacCarbonEvent wakeupEvent;
 749         wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
 750                             kEventAttributeNone );
 751         err = PostEventToQueue(GetMainEventQueue(), wakeupEvent,
 752                                kEventPriorityHigh );
 753 #endif
 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 void wxMacRectToNative( const wxRect *wx , Rect *n )
 773 {
 774     n->left = wx->x;
 775     n->top = wx->y;
 776     n->right = wx->x + wx->width;
 777     n->bottom = wx->y + wx->height;
 778 }
 779
 780 void wxMacNativeToRect( const Rect *n , wxRect* wx )
 781 {
 782     wx->x = n->left;
 783     wx->y = n->top;
 784     wx->width = n->right - n->left;
 785     wx->height = n->bottom - n->top;
 786 }
 787
 788 void wxMacPointToNative( const wxPoint* wx , Point *n )
 789 {
 790     n->h = wx->x;
 791     n->v = wx->y;
 792 }
 793
 794 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
 795 {
 796     wx->x = n->h;
 797     wx->y = n->v;
 798 }
 799
 800 // ----------------------------------------------------------------------------
 801 // Carbon Event Support
 802 // ----------------------------------------------------------------------------
 803
 804 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
 805 {
 806     return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData );
 807 }
 808
 809 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
 810 {
 811     return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData );
 812 }
 813
 814 // ----------------------------------------------------------------------------
 815 // Control Access Support
 816 // ----------------------------------------------------------------------------
 817
 818 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
 819 {
 820     Init();
 821     m_peer = peer;
 822     m_isRootControl = isRootControl;
 823     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing();
 824 }
 825
 826 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
 827 {
 828     Init();
 829     m_peer = peer;
 830     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing();
 831     m_controlRef = control;
 832 }
 833
 834 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
 835 {
 836     Init();
 837     m_peer = peer;
 838     m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing();
 839     m_controlRef = (ControlRef) control;
 840 }
 841
 842 wxMacControl::~wxMacControl()
 843 {
 844 }
 845
 846 void wxMacControl::Init()
 847 {
 848     m_peer = NULL;
 849     m_controlRef = NULL;
 850     m_needsFocusRect = false;
 851     m_isCompositing = false;
 852     m_isRootControl = false;
 853 }
 854
 855 void wxMacControl::Dispose()
 856 {
 857     ::DisposeControl( m_controlRef );
 858     m_controlRef = NULL;
 859 }
 860
 861 void wxMacControl::SetReference( SInt32 data )
 862 {
 863     SetControlReference( m_controlRef , data );
 864 }
 865
 866 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
 867 {
 868     return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
 869 }
 870
 871 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
 872 {
 873     return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
 874 }
 875
 876 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
 877 {
 878     return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
 879 }
 880
 881 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
 882 {
 883 #if TARGET_API_MAC_OSX
 884     return SendEventToEventTargetWithOptions( event,
 885         HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
 886 #else
 887     #pragma unused(inOptions)
 888     return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) );
 889 #endif
 890 }
 891
 892 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
 893 {
 894     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
 895
 896     event.SetParameter<HICommand>(kEventParamDirectObject,command);
 897
 898     return SendEvent( event , inOptions );
 899 }
 900
 901 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions  )
 902 {
 903     HICommand command;
 904
 905     memset( &command, 0 , sizeof(command) );
 906     command.commandID = commandID;
 907     return SendHICommand( command , inOptions );
 908 }
 909
 910 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
 911 {
 912     unsigned long finalTicks;
 913
 914     HiliteControl( m_controlRef , part );
 915     Delay( ticks , &finalTicks );
 916     HiliteControl( m_controlRef , kControlNoPart );
 917 }
 918
 919 SInt32 wxMacControl::GetValue() const
 920 {
 921     return ::GetControl32BitValue( m_controlRef );
 922 }
 923
 924 SInt32 wxMacControl::GetMaximum() const
 925 {
 926     return ::GetControl32BitMaximum( m_controlRef );
 927 }
 928
 929 SInt32 wxMacControl::GetMinimum() const
 930 {
 931     return ::GetControl32BitMinimum( m_controlRef );
 932 }
 933
 934 void wxMacControl::SetValue( SInt32 v )
 935 {
 936     ::SetControl32BitValue( m_controlRef , v );
 937 }
 938
 939 void wxMacControl::SetMinimum( SInt32 v )
 940 {
 941     ::SetControl32BitMinimum( m_controlRef , v );
 942 }
 943
 944 void wxMacControl::SetMaximum( SInt32 v )
 945 {
 946     ::SetControl32BitMaximum( m_controlRef , v );
 947 }
 948
 949 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
 950 {
 951     ::SetControl32BitMinimum( m_controlRef , minimum );
 952     ::SetControl32BitMaximum( m_controlRef , maximum );
 953     ::SetControl32BitValue( m_controlRef , value );
 954 }
 955
 956 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
 957 {
 958     return SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, focusPart );
 959 }
 960
 961 bool wxMacControl::HasFocus() const
 962 {
 963     ControlRef control;
 964     GetKeyboardFocus( GetUserFocusWindow() , &control );
 965     return control == m_controlRef;
 966 }
 967
 968 void wxMacControl::SetNeedsFocusRect( bool needs )
 969 {
 970     m_needsFocusRect = needs;
 971 }
 972
 973 bool wxMacControl::NeedsFocusRect() const
 974 {
 975     return m_needsFocusRect;
 976 }
 977
 978 void wxMacControl::VisibilityChanged(bool shown)
 979 {
 980 }
 981
 982 void wxMacControl::SuperChangedPosition()
 983 {
 984 }
 985
 986 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
 987 {
 988     m_font = font;
 989     ControlFontStyleRec fontStyle;
 990     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 991     {
 992         switch ( font.MacGetThemeFontID() )
 993         {
 994             case kThemeSmallSystemFont :
 995                 fontStyle.font = kControlFontSmallSystemFont;
 996                 break;
 997
 998             case 109 : // mini font
 999                 fontStyle.font = -5;
1000                 break;
1001
1002             case kThemeSystemFont :
1003                 fontStyle.font = kControlFontBigSystemFont;
1004                 break;
1005
1006             default :
1007                 fontStyle.font = kControlFontBigSystemFont;
1008                 break;
1009         }
1010
1011         fontStyle.flags = kControlUseFontMask;
1012     }
1013     else
1014     {
1015         fontStyle.font = font.MacGetFontNum();
1016         fontStyle.style = font.MacGetFontStyle();
1017         fontStyle.size = font.MacGetFontSize();
1018         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
1019     }
1020
1021     fontStyle.just = teJustLeft;
1022     fontStyle.flags |= kControlUseJustMask;
1023     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1024         fontStyle.just = teJustCenter;
1025     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1026         fontStyle.just = teJustRight;
1027
1028
1029     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1030     // won't get grayed out by the system anymore
1031
1032     if ( foreground != *wxBLACK )
1033     {
1034         fontStyle.foreColor = MAC_WXCOLORREF( foreground.GetPixel() );
1035         fontStyle.flags |= kControlUseForeColorMask;
1036     }
1037
1038     ::SetControlFontStyle( m_controlRef , &fontStyle );
1039 }
1040
1041 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1042 {
1043     // TODO
1044     // setting up a color proc is not recommended anymore
1045 }
1046
1047 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1048 {
1049     ::SetControl32BitMinimum( m_controlRef , minimum );
1050     ::SetControl32BitMaximum( m_controlRef , maximum );
1051 }
1052
1053 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1054 {
1055     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1056 }
1057
1058 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1059 {
1060     SetControlAction( m_controlRef , actionProc );
1061 }
1062
1063 void wxMacControl::SetViewSize( SInt32 viewSize )
1064 {
1065     SetControlViewSize(m_controlRef , viewSize );
1066 }
1067
1068 SInt32 wxMacControl::GetViewSize() const
1069 {
1070     return GetControlViewSize( m_controlRef );
1071 }
1072
1073 bool wxMacControl::IsVisible() const
1074 {
1075     return IsControlVisible( m_controlRef );
1076 }
1077
1078 void wxMacControl::SetVisibility( bool visible , bool redraw )
1079 {
1080     SetControlVisibility( m_controlRef , visible , redraw );
1081 }
1082
1083 bool wxMacControl::IsEnabled() const
1084 {
1085 #if TARGET_API_MAC_OSX
1086     return IsControlEnabled( m_controlRef );
1087 #else
1088     return IsControlActive( m_controlRef );
1089 #endif
1090 }
1091
1092 bool wxMacControl::IsActive() const
1093 {
1094     return IsControlActive( m_controlRef );
1095 }
1096
1097 void wxMacControl::Enable( bool enable )
1098 {
1099 #if TARGET_API_MAC_OSX
1100     if ( enable )
1101         EnableControl( m_controlRef );
1102     else
1103         DisableControl( m_controlRef );
1104 #else
1105     if ( enable )
1106         ActivateControl( m_controlRef );
1107     else
1108         DeactivateControl( m_controlRef );
1109 #endif
1110 }
1111
1112 void wxMacControl::SetDrawingEnabled( bool enable )
1113 {
1114 #if TARGET_API_MAC_OSX
1115     HIViewSetDrawingEnabled( m_controlRef , enable );
1116 #endif
1117 }
1118
1119 #if TARGET_API_MAC_OSX
1120 bool wxMacControl::GetNeedsDisplay() const
1121 {
1122 #if TARGET_API_MAC_OSX
1123     if ( m_isCompositing )
1124     {
1125         return HIViewGetNeedsDisplay( m_controlRef );
1126     }
1127     else
1128 #endif
1129     {
1130         if ( !IsVisible() )
1131             return false;
1132
1133         Rect controlBounds;
1134         GetControlBounds( m_controlRef, &controlBounds );
1135         RgnHandle rgn = NewRgn();
1136         GetWindowRegion ( GetControlOwner( m_controlRef ) , kWindowUpdateRgn , rgn );
1137         Boolean intersect = RectInRgn ( &controlBounds , rgn );
1138         DisposeRgn( rgn );
1139
1140         return intersect;
1141     }
1142 }
1143 #endif
1144
1145 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1146 {
1147     if ( !IsVisible() )
1148         return;
1149
1150 #if TARGET_API_MAC_OSX
1151     if ( m_isCompositing )
1152     {
1153         HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
1154     }
1155     else
1156 #endif
1157     {
1158         Rect controlBounds;
1159         GetControlBounds( m_controlRef, &controlBounds );
1160         RgnHandle update = NewRgn();
1161         CopyRgn( where , update );
1162         OffsetRgn( update , controlBounds.left , controlBounds.top );
1163         InvalWindowRgn( GetControlOwner( m_controlRef) , update );
1164     }
1165 }
1166
1167 void wxMacControl::SetNeedsDisplay( Rect* where )
1168 {
1169     if ( !IsVisible() )
1170         return;
1171
1172 #if TARGET_API_MAC_OSX
1173     if ( m_isCompositing )
1174     {
1175         if ( where != NULL )
1176         {
1177             RgnHandle update = NewRgn();
1178             RectRgn( update , where );
1179             HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
1180             DisposeRgn( update );
1181         }
1182         else
1183             HIViewSetNeedsDisplay( m_controlRef , true );
1184     }
1185     else
1186 #endif
1187     {
1188         Rect controlBounds;
1189
1190         GetControlBounds( m_controlRef, &controlBounds );
1191         if ( where )
1192         {
1193             Rect whereLocal = *where;
1194             OffsetRect( &whereLocal , controlBounds.left , controlBounds.top );
1195             SectRect( &controlBounds , &whereLocal, &controlBounds );
1196         }
1197
1198         InvalWindowRect( GetControlOwner( m_controlRef) , &controlBounds );
1199     }
1200 }
1201
1202 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1203 {
1204 #if TARGET_API_MAC_OSX
1205     if ( from->m_peer->MacGetTopLevelWindow()->MacUsesCompositing() )
1206     {
1207         HIPoint hiPoint;
1208
1209         hiPoint.x = pt->x;
1210         hiPoint.y = pt->y;
1211         HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  );
1212         pt->x = (int)hiPoint.x;
1213         pt->y = (int)hiPoint.y;
1214     }
1215     else
1216 #endif
1217     {
1218         Rect fromRect, toRect;
1219
1220         GetControlBounds( from->m_controlRef , &fromRect );
1221         GetControlBounds( to->m_controlRef , &toRect );
1222         if ( from->m_isRootControl )
1223             fromRect.left = fromRect.top = 0;
1224         if ( to->m_isRootControl )
1225             toRect.left = toRect.top = 0;
1226
1227         pt->x = pt->x + fromRect.left - toRect.left;
1228         pt->y = pt->y + fromRect.top - toRect.top;
1229     }
1230 }
1231
1232 void wxMacControl::SetRect( Rect *r )
1233 {
1234 #if TARGET_API_MAC_OSX
1235     if ( m_isCompositing )
1236     {
1237         //A HIRect is actually a CGRect on OSX - which consists of two structures -
1238         //CGPoint and CGSize, which have two floats each
1239         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
1240         HIViewSetFrame ( m_controlRef , &hir );
1241         // eventuall we might have to do a SetVisibility( false , true );
1242         // before and a SetVisibility( true , true ); after
1243     }
1244     else
1245 #endif
1246     {
1247         bool vis = IsVisible();
1248         if ( vis )
1249         {
1250             Rect former;
1251             GetControlBounds( m_controlRef , &former );
1252             InvalWindowRect( GetControlOwner( m_controlRef ) , &former );
1253         }
1254
1255         Rect controlBounds = *r;
1256
1257         // since the rect passed in is always (even in non-compositing) relative
1258         // to the (native) parent, we have to adjust to window relative here
1259         wxMacControl* parent = m_peer->GetParent()->GetPeer();
1260         if ( !parent->m_isRootControl )
1261         {
1262             Rect superRect;
1263             GetControlBounds( parent->m_controlRef , &superRect );
1264             OffsetRect( &controlBounds , superRect.left , superRect.top );
1265         }
1266
1267         SetControlBounds( m_controlRef , &controlBounds );
1268         if ( vis )
1269             InvalWindowRect( GetControlOwner( m_controlRef ) , &controlBounds );
1270     }
1271 }
1272
1273 void wxMacControl::GetRect( Rect *r )
1274 {
1275     GetControlBounds( m_controlRef , r );
1276     if ( !m_isCompositing )
1277     {
1278         // correct the case of the root control
1279         if ( m_isRootControl )
1280         {
1281             WindowRef wr = GetControlOwner( m_controlRef );
1282             GetWindowBounds( wr , kWindowContentRgn , r );
1283             r->right -= r->left;
1284             r->bottom -= r->top;
1285             r->left = 0;
1286             r->top = 0;
1287         }
1288         else
1289         {
1290             wxMacControl* parent = m_peer->GetParent()->GetPeer();
1291             if ( !parent->m_isRootControl )
1292             {
1293                 Rect superRect;
1294                 GetControlBounds( parent->m_controlRef , &superRect );
1295                 OffsetRect( r , -superRect.left , -superRect.top );
1296             }
1297         }
1298     }
1299 }
1300
1301 void wxMacControl::GetRectInWindowCoords( Rect *r )
1302 {
1303     UMAGetControlBoundsInWindowCoords( m_controlRef , r );
1304 }
1305
1306 void wxMacControl::GetBestRect( Rect *r )
1307 {
1308     short   baselineoffset;
1309
1310     GetBestControlRect( m_controlRef , r , &baselineoffset );
1311 }
1312
1313 void wxMacControl::SetLabel( const wxString &title )
1314 {
1315     wxFontEncoding encoding;
1316
1317     if ( m_font.Ok() )
1318         encoding = m_font.GetEncoding();
1319     else
1320         encoding = wxFont::GetDefaultEncoding();
1321
1322     UMASetControlTitle( m_controlRef , title , encoding );
1323 }
1324
1325 void wxMacControl::GetFeatures( UInt32 * features )
1326 {
1327     GetControlFeatures( m_controlRef , features );
1328 }
1329
1330 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1331 {
1332     OSStatus err = GetControlRegion( m_controlRef , partCode , region );
1333     if ( !m_isCompositing )
1334     {
1335         if ( !m_isRootControl )
1336         {
1337             Rect r;
1338
1339             GetControlBounds(m_controlRef, &r );
1340             if ( !EmptyRgn( region ) )
1341                 OffsetRgn( region , -r.left , -r.top );
1342         }
1343     }
1344
1345     return err;
1346 }
1347
1348 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1349 {
1350 #if TARGET_API_MAC_OSX
1351     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1352        (other != NULL) ? other->m_controlRef : NULL);
1353 #else
1354     return 0;
1355 #endif
1356 }
1357
1358 #if TARGET_API_MAC_OSX
1359 // SetNeedsDisplay would not invalidate the children
1360 static void InvalidateControlAndChildren( HIViewRef control )
1361 {
1362     HIViewSetNeedsDisplay( control , true );
1363     UInt16 childrenCount = 0;
1364     OSStatus err = CountSubControls( control , &childrenCount );
1365     if ( err == errControlIsNotEmbedder )
1366         return;
1367
1368     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1369
1370     for ( UInt16 i = childrenCount; i >=1; --i )
1371     {
1372         HIViewRef child;
1373
1374         err = GetIndexedSubControl( control , i , & child );
1375         if ( err == errControlIsNotEmbedder )
1376             return;
1377
1378         InvalidateControlAndChildren( child );
1379     }
1380 }
1381 #endif
1382
1383 void wxMacControl::InvalidateWithChildren()
1384 {
1385 #if TARGET_API_MAC_OSX
1386     InvalidateControlAndChildren( m_controlRef );
1387 #endif
1388 }
1389
1390 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1391 {
1392     wxASSERT( r != NULL );
1393
1394 #if TARGET_API_MAC_OSX
1395     if ( m_isCompositing )
1396     {
1397         HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
1398         HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1399     }
1400     else
1401 #endif
1402     {
1403         Rect bounds;
1404
1405         GetControlBounds( m_controlRef , &bounds );
1406         bounds.left += r->x;
1407         bounds.top += r->y;
1408         bounds.bottom = bounds.top + r->height;
1409         bounds.right = bounds.left + r->width;
1410         wxMacWindowClipper clip( m_peer );
1411         RgnHandle updateRgn = NewRgn();
1412         ::ScrollRect( &bounds , dx , dy , updateRgn );
1413         InvalWindowRgn( GetControlOwner( m_controlRef ) , updateRgn );
1414         DisposeRgn( updateRgn );
1415     }
1416 }
1417
1418 OSType wxMacCreator = 'WXMC';
1419 OSType wxMacControlProperty = 'MCCT';
1420
1421 void wxMacControl::SetReferenceInNativeControl()
1422 {
1423     void * data = this;
1424     verify_noerr( SetControlProperty ( m_controlRef ,
1425         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1426 }
1427
1428 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1429 {
1430     wxMacControl* ctl = NULL;
1431     UInt32 actualSize;
1432     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1433         &actualSize , &ctl ) == noErr )
1434     {
1435         return ctl;
1436     }
1437     return NULL;
1438 }
1439
1440 // ============================================================================
1441 // DataBrowser Wrapper
1442 // ============================================================================
1443 //
1444 // basing on DataBrowserItemIDs
1445 //
1446
1447 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
1448     ControlRef browser,
1449     DataBrowserItemID itemID,
1450     DataBrowserItemNotification message,
1451     DataBrowserItemDataRef itemData )
1452 {
1453     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1454     if ( ctl != 0 )
1455     {
1456         ctl->ItemNotification(itemID, message, itemData);
1457     }
1458 }
1459
1460 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
1461     ControlRef browser,
1462     DataBrowserItemID itemID,
1463     DataBrowserPropertyID property,
1464     DataBrowserItemDataRef itemData,
1465     Boolean changeValue )
1466 {
1467     OSStatus err = errDataBrowserPropertyNotSupported;
1468
1469     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1470     if ( ctl != 0 )
1471     {
1472         err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
1473     }
1474     return err;
1475 }
1476
1477 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
1478     ControlRef browser,
1479     DataBrowserItemID itemOneID,
1480     DataBrowserItemID itemTwoID,
1481     DataBrowserPropertyID sortProperty)
1482 {
1483     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1484     if ( ctl != 0 )
1485     {
1486         return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
1487     }
1488     return false;
1489 }
1490
1491 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
1492 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
1493 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
1494
1495 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer, const wxPoint& pos, const wxSize& size, long style) : wxMacControl( peer )
1496 {
1497     Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
1498     OSStatus err = ::CreateDataBrowserControl(
1499         MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
1500         &bounds, kDataBrowserListView, &m_controlRef );
1501     SetReferenceInNativeControl();
1502     verify_noerr( err );
1503     if ( gDataBrowserItemCompareUPP == NULL )
1504         gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
1505     if ( gDataBrowserItemDataUPP == NULL )
1506         gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
1507     if ( gDataBrowserItemNotificationUPP == NULL )
1508     {
1509         gDataBrowserItemNotificationUPP =
1510 #if TARGET_API_MAC_OSX
1511             (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
1512 #else
1513             NewDataBrowserItemNotificationUPP(DataBrowserItemNotificationProc);
1514 #endif
1515     }
1516
1517     DataBrowserCallbacks callbacks;
1518     InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1519
1520     callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1521     callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1522     callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1523     SetCallbacks( &callbacks );
1524
1525 }
1526
1527 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1528     Boolean recurse,
1529     DataBrowserItemState state,
1530     UInt32 *numItems) const
1531 {
1532     return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1533 }
1534
1535 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1536     Boolean recurse,
1537     DataBrowserItemState state,
1538     Handle items) const
1539 {
1540     return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1541 }
1542
1543 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1544 {
1545     return SetDataBrowserSelectionFlags( m_controlRef, options );
1546 }
1547
1548 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1549         DataBrowserTableViewColumnIndex position )
1550 {
1551     return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1552 }
1553
1554 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1555 {
1556     return AutoSizeDataBrowserListViewColumns(m_controlRef);
1557 }
1558
1559 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1560 {
1561     return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1562 }
1563
1564 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1565 {
1566     return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1567 }
1568
1569 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1570 {
1571     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1572 }
1573
1574 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1575 {
1576     return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1577 }
1578
1579 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1580 {
1581     return SetDataBrowserCallbacks( m_controlRef, callbacks );
1582 }
1583
1584 OSStatus wxMacDataBrowserControl::UpdateItems(
1585     DataBrowserItemID container,
1586     UInt32 numItems,
1587     const DataBrowserItemID *items,
1588     DataBrowserPropertyID preSortProperty,
1589     DataBrowserPropertyID propertyID ) const
1590 {
1591     return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1592 }
1593
1594 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1595 {
1596     return IsDataBrowserItemSelected( m_controlRef, item );
1597 }
1598
1599 OSStatus wxMacDataBrowserControl::AddItems(
1600     DataBrowserItemID container,
1601     UInt32 numItems,
1602     const DataBrowserItemID *items,
1603     DataBrowserPropertyID preSortProperty )
1604 {
1605     return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1606 }
1607
1608 OSStatus wxMacDataBrowserControl::RemoveItems(
1609     DataBrowserItemID container,
1610     UInt32 numItems,
1611     const DataBrowserItemID *items,
1612     DataBrowserPropertyID preSortProperty )
1613 {
1614     return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1615 }
1616
1617 OSStatus wxMacDataBrowserControl::RevealItem(
1618     DataBrowserItemID item,
1619     DataBrowserPropertyID propertyID,
1620     DataBrowserRevealOptions options ) const
1621 {
1622     return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1623 }
1624
1625 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1626     UInt32 numItems,
1627     const DataBrowserItemID *items,
1628     DataBrowserSetOption operation )
1629 {
1630     return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1631 }
1632
1633 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1634 {
1635     return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1636 }
1637
1638 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1639 {
1640     return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1641 }
1642
1643 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1644 {
1645     return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1646 }
1647
1648 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1649 {
1650     return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1651 }
1652
1653 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1654 {
1655     return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1656 }
1657
1658 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1659 {
1660     return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1661 }
1662
1663 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1664 {
1665     return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1666 }
1667
1668 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1669 {
1670     return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1671 }
1672
1673 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1674 {
1675     return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1676 }
1677
1678 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1679 {
1680     return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1681 }
1682
1683 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1684 {
1685     return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1686 }
1687
1688 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1689 {
1690     return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1691 }
1692
1693 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1694     UInt32 *position) const
1695 {
1696     return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1697 }
1698
1699 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, UInt32 position)
1700 {
1701     return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1702 }
1703
1704 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1705 {
1706     return GetDataBrowserScrollPosition( m_controlRef , top , left );
1707 }
1708
1709 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1710 {
1711     return SetDataBrowserScrollPosition( m_controlRef , top , left );
1712 }
1713
1714 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1715 {
1716     return GetDataBrowserSortProperty( m_controlRef , column );
1717 }
1718
1719 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1720 {
1721     return SetDataBrowserSortProperty( m_controlRef , column );
1722 }
1723
1724 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1725 {
1726     return GetDataBrowserSortOrder( m_controlRef , order );
1727 }
1728
1729 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1730 {
1731     return SetDataBrowserSortOrder( m_controlRef , order );
1732 }
1733
1734 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1735     DataBrowserPropertyFlags *flags ) const
1736 {
1737     return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1738 }
1739
1740 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1741     DataBrowserPropertyFlags flags )
1742 {
1743     return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1744 }
1745
1746 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1747     DataBrowserListViewHeaderDesc *desc ) const
1748 {
1749     return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1750 }
1751
1752 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1753     DataBrowserListViewHeaderDesc *desc )
1754 {
1755     return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1756 }
1757
1758 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1759     Boolean expandableRows )
1760 {
1761     return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1762 }
1763
1764 // ============================================================================
1765 // Higher-level Databrowser
1766 // ============================================================================
1767 //
1768 // basing on data item objects
1769 //
1770
1771 wxMacDataItem::wxMacDataItem()
1772 {
1773 }
1774
1775 wxMacDataItem::~wxMacDataItem()
1776 {
1777 }
1778
1779 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *owner ,
1780     const wxMacDataItem*,
1781     DataBrowserPropertyID property) const
1782 {
1783     return false;
1784 }
1785
1786 OSStatus wxMacDataItem::GetSetData(wxMacDataItemBrowserControl *owner ,
1787     DataBrowserPropertyID property,
1788     DataBrowserItemDataRef itemData,
1789     bool changeValue )
1790 {
1791     return errDataBrowserPropertyNotSupported;
1792 }
1793
1794 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *owner ,
1795     DataBrowserItemNotification message,
1796     DataBrowserItemDataRef itemData ) const
1797 {
1798 }
1799
1800
1801 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1802     wxMacDataBrowserControl( peer, pos, size, style )
1803 {
1804     m_suppressSelection = false;
1805 }
1806
1807 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1808 {
1809     m_former = browser->SuppressSelection(true);
1810     m_browser = browser;
1811 }
1812
1813 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1814 {
1815     m_browser->SuppressSelection(m_former);
1816 }
1817
1818 bool  wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1819 {
1820     bool former = m_suppressSelection;
1821     m_suppressSelection = suppress;
1822
1823     return former;
1824 }
1825
1826 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1827     DataBrowserItemID itemTwoID,
1828     DataBrowserPropertyID sortProperty)
1829 {
1830     wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1831     wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1832     return CompareItems( itemOne , itemTwo , sortProperty );
1833 }
1834
1835 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem*  itemOne,
1836     const wxMacDataItem*  itemTwo,
1837     DataBrowserPropertyID sortProperty)
1838 {
1839     Boolean retval = false;
1840     if ( itemOne != NULL )
1841         retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1842     return retval;
1843 }
1844
1845 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1846     DataBrowserItemID itemID,
1847     DataBrowserPropertyID property,
1848     DataBrowserItemDataRef itemData,
1849     Boolean changeValue )
1850 {
1851     wxMacDataItem* item = (wxMacDataItem*) itemID;
1852     return GetSetItemData(item, property, itemData , changeValue );
1853 }
1854
1855 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1856     wxMacDataItem* item,
1857     DataBrowserPropertyID property,
1858     DataBrowserItemDataRef itemData,
1859     Boolean changeValue )
1860 {
1861     OSStatus err = errDataBrowserPropertyNotSupported;
1862     switch( property )
1863     {
1864         case kDataBrowserContainerIsClosableProperty :
1865         case kDataBrowserContainerIsSortableProperty :
1866         case kDataBrowserContainerIsOpenableProperty :
1867             // right now default behaviour on these
1868             break;
1869         default :
1870             if ( item != NULL )
1871                 err = item->GetSetData( this, property , itemData , changeValue );
1872             break;
1873
1874     }
1875     return err;
1876 }
1877
1878 void wxMacDataItemBrowserControl::ItemNotification(
1879     DataBrowserItemID itemID,
1880     DataBrowserItemNotification message,
1881     DataBrowserItemDataRef itemData)
1882 {
1883     wxMacDataItem* item = (wxMacDataItem*) itemID;
1884     ItemNotification( item , message, itemData);
1885 }
1886
1887 void wxMacDataItemBrowserControl::ItemNotification(
1888     const wxMacDataItem* item,
1889     DataBrowserItemNotification message,
1890     DataBrowserItemDataRef itemData)
1891 {
1892     if (item != NULL)
1893         item->Notification( this, message, itemData);
1894 }
1895
1896 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1897         bool recurse , DataBrowserItemState state) const
1898 {
1899     UInt32 numItems = 0;
1900     verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1901         recurse, state, &numItems ) );
1902     return numItems;
1903 }
1904
1905 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1906     bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1907 {
1908     Handle handle = NewHandle(0);
1909     verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1910         recurse , state, handle) );
1911
1912     int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1913     HLock( handle );
1914     wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1915     for ( int i = 0; i < itemCount; ++i)
1916     {
1917         items.Add(itemsArray[i]);
1918     }
1919     HUnlock( handle );
1920     DisposeHandle( handle );
1921 }
1922
1923 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1924 {
1925     DataBrowserTableViewRowIndex row;
1926     OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1927     wxASSERT( err == noErr);
1928     return row;
1929 }
1930
1931 wxMacDataItem*  wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1932 {
1933     DataBrowserItemID id;
1934     OSStatus err =  GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1935     wxASSERT( err == noErr);
1936     return (wxMacDataItem*) id;
1937 }
1938
1939 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1940         const wxMacDataItem *item , DataBrowserPropertyID property) const
1941 {
1942     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1943         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1944 }
1945
1946 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1947         wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1948 {
1949     unsigned int noItems = itemArray.GetCount();
1950     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1951     for ( unsigned int i = 0; i < noItems; ++i )
1952         items[i] = (DataBrowserItemID) itemArray[i];
1953
1954     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1955         items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1956     delete [] items;
1957 }
1958
1959 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1960 {
1961     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1962         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1963 }
1964
1965 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1966 {
1967     unsigned int noItems = itemArray.GetCount();
1968     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1969     for ( unsigned int i = 0; i < noItems; ++i )
1970         items[i] = (DataBrowserItemID) itemArray[i];
1971
1972     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1973         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1974     delete [] items;
1975 }
1976
1977 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1978 {
1979     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1980         (UInt32*) &item, kDataBrowserItemNoProperty );
1981     verify_noerr( err );
1982 }
1983
1984 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1985 {
1986     unsigned int noItems = itemArray.GetCount();
1987     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1988     for ( unsigned int i = 0; i < noItems; ++i )
1989         items[i] = (DataBrowserItemID) itemArray[i];
1990
1991     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1992         (UInt32*) items, kDataBrowserItemNoProperty );
1993     verify_noerr( err );
1994     delete [] items;
1995 }
1996
1997 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1998 {
1999     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
2000     verify_noerr( err );
2001 }
2002
2003 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
2004 {
2005     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
2006 }
2007
2008 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
2009 {
2010     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
2011 }
2012
2013 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
2014 {
2015     unsigned int noItems = itemArray.GetCount();
2016     DataBrowserItemID *items = new DataBrowserItemID[noItems];
2017     for ( unsigned int i = 0; i < noItems; ++i )
2018         items[i] = (DataBrowserItemID) itemArray[i];
2019
2020     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
2021     delete [] items;
2022 }
2023
2024 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
2025 {
2026     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
2027 }
2028
2029 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
2030 {
2031     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
2032 }
2033
2034 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
2035 {
2036     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
2037 }
2038
2039
2040
2041 //
2042 // Tab Control
2043 //
2044
2045 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
2046 {
2047     return ::SetTabEnabled( m_controlRef , tabNo , enable );
2048 }
2049
2050 //
2051 // Quartz Support
2052 //
2053
2054 #ifdef __WXMAC_OSX__
2055 // snippets from Sketch Sample from Apple :
2056
2057 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
2058
2059 /*
2060     This function locates, opens, and returns the profile reference for the calibrated
2061     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
2062     with the profile reference this function returns.
2063 */
2064 CMProfileRef wxMacOpenGenericProfile()
2065 {
2066     static CMProfileRef cachedRGBProfileRef = NULL;
2067
2068     // we only create the profile reference once
2069     if (cachedRGBProfileRef == NULL)
2070     {
2071         CMProfileLocation loc;
2072
2073         loc.locType = cmPathBasedProfile;
2074         strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
2075
2076         verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
2077     }
2078
2079     // clone the profile reference so that the caller has their own reference, not our cached one
2080     if (cachedRGBProfileRef)
2081         CMCloneProfileRef(cachedRGBProfileRef);
2082
2083     return cachedRGBProfileRef;
2084 }
2085
2086 /*
2087     Return the generic RGB color space. This is a 'get' function and the caller should
2088     not release the returned value unless the caller retains it first. Usually callers
2089     of this routine will immediately use the returned colorspace with CoreGraphics
2090     so they typically do not need to retain it themselves.
2091
2092     This function creates the generic RGB color space once and hangs onto it so it can
2093     return it whenever this function is called.
2094 */
2095
2096 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
2097 {
2098     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
2099
2100     if (genericRGBColorSpace == NULL)
2101     {
2102         if ( UMAGetSystemVersion() >= 0x1040 )
2103         {
2104             genericRGBColorSpace.Set( CGColorSpaceCreateWithName( CFSTR("kCGColorSpaceGenericRGB") ) );
2105         }
2106         else
2107         {
2108             CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
2109
2110             if (genericRGBProfile)
2111             {
2112                 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) );
2113
2114                 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") );
2115
2116                 // we opened the profile so it is up to us to close it
2117                 CMCloseProfile(genericRGBProfile);
2118             }
2119         }
2120     }
2121
2122     return genericRGBColorSpace;
2123 }
2124 #endif
2125
2126 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
2127 {
2128     ::GetPort( &m_port );
2129     ::SetPort( port );
2130 }
2131
2132 wxMacPortSaver::~wxMacPortSaver()
2133 {
2134     ::SetPort( m_port );
2135 }
2136
2137 #endif // wxUSE_GUI