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