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     wxASSERT_MSG( IsValidControlHandle(m_controlRef) , wxT("Invalid Control Handle (maybe already released) in Dispose") );
 830
 831     CFIndex count = CFGetRetainCount( m_controlRef ) ;
 832     wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in Dispose") );
 833
 834     ::DisposeControl( m_controlRef );
 835     m_controlRef = NULL;
 836 }
 837
 838 void wxMacControl::SetReference( SInt32 data )
 839 {
 840     SetControlReference( m_controlRef , data );
 841 }
 842
 843 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
 844 {
 845     return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
 846 }
 847
 848 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
 849 {
 850     return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
 851 }
 852
 853 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
 854 {
 855     return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
 856 }
 857
 858 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
 859 {
 860 #if TARGET_API_MAC_OSX
 861     return SendEventToEventTargetWithOptions( event,
 862         HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
 863 #else
 864     #pragma unused(inOptions)
 865     return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) );
 866 #endif
 867 }
 868
 869 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
 870 {
 871     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
 872
 873     event.SetParameter<HICommand>(kEventParamDirectObject,command);
 874
 875     return SendEvent( event , inOptions );
 876 }
 877
 878 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions  )
 879 {
 880     HICommand command;
 881
 882     memset( &command, 0 , sizeof(command) );
 883     command.commandID = commandID;
 884     return SendHICommand( command , inOptions );
 885 }
 886
 887 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
 888 {
 889     unsigned long finalTicks;
 890
 891     HiliteControl( m_controlRef , part );
 892     Delay( ticks , &finalTicks );
 893     HiliteControl( m_controlRef , kControlNoPart );
 894 }
 895
 896 SInt32 wxMacControl::GetValue() const
 897 {
 898     return ::GetControl32BitValue( m_controlRef );
 899 }
 900
 901 SInt32 wxMacControl::GetMaximum() const
 902 {
 903     return ::GetControl32BitMaximum( m_controlRef );
 904 }
 905
 906 SInt32 wxMacControl::GetMinimum() const
 907 {
 908     return ::GetControl32BitMinimum( m_controlRef );
 909 }
 910
 911 void wxMacControl::SetValue( SInt32 v )
 912 {
 913     ::SetControl32BitValue( m_controlRef , v );
 914 }
 915
 916 void wxMacControl::SetMinimum( SInt32 v )
 917 {
 918     ::SetControl32BitMinimum( m_controlRef , v );
 919 }
 920
 921 void wxMacControl::SetMaximum( SInt32 v )
 922 {
 923     ::SetControl32BitMaximum( m_controlRef , v );
 924 }
 925
 926 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
 927 {
 928     ::SetControl32BitMinimum( m_controlRef , minimum );
 929     ::SetControl32BitMaximum( m_controlRef , maximum );
 930     ::SetControl32BitValue( m_controlRef , value );
 931 }
 932
 933 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
 934 {
 935     return SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, focusPart );
 936 }
 937
 938 bool wxMacControl::HasFocus() const
 939 {
 940     ControlRef control;
 941     GetKeyboardFocus( GetUserFocusWindow() , &control );
 942     return control == m_controlRef;
 943 }
 944
 945 void wxMacControl::SetNeedsFocusRect( bool needs )
 946 {
 947     m_needsFocusRect = needs;
 948 }
 949
 950 bool wxMacControl::NeedsFocusRect() const
 951 {
 952     return m_needsFocusRect;
 953 }
 954
 955 void wxMacControl::VisibilityChanged(bool shown)
 956 {
 957 }
 958
 959 void wxMacControl::SuperChangedPosition()
 960 {
 961 }
 962
 963 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
 964 {
 965     m_font = font;
 966     ControlFontStyleRec fontStyle;
 967     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 968     {
 969         switch ( font.MacGetThemeFontID() )
 970         {
 971             case kThemeSmallSystemFont :
 972                 fontStyle.font = kControlFontSmallSystemFont;
 973                 break;
 974
 975             case 109 : // mini font
 976                 fontStyle.font = -5;
 977                 break;
 978
 979             case kThemeSystemFont :
 980                 fontStyle.font = kControlFontBigSystemFont;
 981                 break;
 982
 983             default :
 984                 fontStyle.font = kControlFontBigSystemFont;
 985                 break;
 986         }
 987
 988         fontStyle.flags = kControlUseFontMask;
 989     }
 990     else
 991     {
 992         fontStyle.font = font.MacGetFontNum();
 993         fontStyle.style = font.MacGetFontStyle();
 994         fontStyle.size = font.MacGetFontSize();
 995         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
 996     }
 997
 998     fontStyle.just = teJustLeft;
 999     fontStyle.flags |= kControlUseJustMask;
1000     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1001         fontStyle.just = teJustCenter;
1002     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1003         fontStyle.just = teJustRight;
1004
1005
1006     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1007     // won't get grayed out by the system anymore
1008
1009     if ( foreground != *wxBLACK )
1010     {
1011         fontStyle.foreColor = MAC_WXCOLORREF( foreground.GetPixel() );
1012         fontStyle.flags |= kControlUseForeColorMask;
1013     }
1014
1015     ::SetControlFontStyle( m_controlRef , &fontStyle );
1016 }
1017
1018 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1019 {
1020     // TODO
1021     // setting up a color proc is not recommended anymore
1022 }
1023
1024 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1025 {
1026     ::SetControl32BitMinimum( m_controlRef , minimum );
1027     ::SetControl32BitMaximum( m_controlRef , maximum );
1028 }
1029
1030 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1031 {
1032     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1033 }
1034
1035 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1036 {
1037     SetControlAction( m_controlRef , actionProc );
1038 }
1039
1040 void wxMacControl::SetViewSize( SInt32 viewSize )
1041 {
1042     SetControlViewSize(m_controlRef , viewSize );
1043 }
1044
1045 SInt32 wxMacControl::GetViewSize() const
1046 {
1047     return GetControlViewSize( m_controlRef );
1048 }
1049
1050 bool wxMacControl::IsVisible() const
1051 {
1052     return IsControlVisible( m_controlRef );
1053 }
1054
1055 void wxMacControl::SetVisibility( bool visible , bool redraw )
1056 {
1057     SetControlVisibility( m_controlRef , visible , redraw );
1058 }
1059
1060 bool wxMacControl::IsEnabled() const
1061 {
1062 #if TARGET_API_MAC_OSX
1063     return IsControlEnabled( m_controlRef );
1064 #else
1065     return IsControlActive( m_controlRef );
1066 #endif
1067 }
1068
1069 bool wxMacControl::IsActive() const
1070 {
1071     return IsControlActive( m_controlRef );
1072 }
1073
1074 void wxMacControl::Enable( bool enable )
1075 {
1076     if ( enable )
1077         EnableControl( m_controlRef );
1078     else
1079         DisableControl( m_controlRef );
1080 }
1081
1082 void wxMacControl::SetDrawingEnabled( bool enable )
1083 {
1084     HIViewSetDrawingEnabled( m_controlRef , enable );
1085 }
1086
1087 bool wxMacControl::GetNeedsDisplay() const
1088 {
1089     return HIViewGetNeedsDisplay( m_controlRef );
1090 }
1091
1092 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1093 {
1094     if ( !IsVisible() )
1095         return;
1096
1097     HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
1098 }
1099
1100 void wxMacControl::SetNeedsDisplay( Rect* where )
1101 {
1102     if ( !IsVisible() )
1103         return;
1104
1105     if ( where != NULL )
1106     {
1107         RgnHandle update = NewRgn();
1108         RectRgn( update , where );
1109         HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
1110         DisposeRgn( update );
1111     }
1112     else
1113         HIViewSetNeedsDisplay( m_controlRef , true );
1114 }
1115
1116 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1117 {
1118     HIPoint hiPoint;
1119
1120     hiPoint.x = pt->x;
1121     hiPoint.y = pt->y;
1122     HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  );
1123     pt->x = (int)hiPoint.x;
1124     pt->y = (int)hiPoint.y;
1125 }
1126
1127 void wxMacControl::SetRect( Rect *r )
1128 {
1129         //A HIRect is actually a CGRect on OSX - which consists of two structures -
1130         //CGPoint and CGSize, which have two floats each
1131         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
1132         HIViewSetFrame ( m_controlRef , &hir );
1133         // eventuall we might have to do a SetVisibility( false , true );
1134         // before and a SetVisibility( true , true ); after
1135 }
1136
1137 void wxMacControl::GetRect( Rect *r )
1138 {
1139     GetControlBounds( m_controlRef , r );
1140 }
1141
1142 void wxMacControl::GetRectInWindowCoords( Rect *r )
1143 {
1144     UMAGetControlBoundsInWindowCoords( m_controlRef , r );
1145 }
1146
1147 void wxMacControl::GetBestRect( Rect *r )
1148 {
1149     short   baselineoffset;
1150
1151     GetBestControlRect( m_controlRef , r , &baselineoffset );
1152 }
1153
1154 void wxMacControl::SetLabel( const wxString &title )
1155 {
1156     wxFontEncoding encoding;
1157
1158     if ( m_font.Ok() )
1159         encoding = m_font.GetEncoding();
1160     else
1161         encoding = wxFont::GetDefaultEncoding();
1162
1163     UMASetControlTitle( m_controlRef , title , encoding );
1164 }
1165
1166 void wxMacControl::GetFeatures( UInt32 * features )
1167 {
1168     GetControlFeatures( m_controlRef , features );
1169 }
1170
1171 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1172 {
1173     OSStatus err = GetControlRegion( m_controlRef , partCode , region );
1174     return err;
1175 }
1176
1177 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1178 {
1179 #if TARGET_API_MAC_OSX
1180     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1181        (other != NULL) ? other->m_controlRef : NULL);
1182 #else
1183     return 0;
1184 #endif
1185 }
1186
1187 #if TARGET_API_MAC_OSX
1188 // SetNeedsDisplay would not invalidate the children
1189 static void InvalidateControlAndChildren( HIViewRef control )
1190 {
1191     HIViewSetNeedsDisplay( control , true );
1192     UInt16 childrenCount = 0;
1193     OSStatus err = CountSubControls( control , &childrenCount );
1194     if ( err == errControlIsNotEmbedder )
1195         return;
1196
1197     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1198
1199     for ( UInt16 i = childrenCount; i >=1; --i )
1200     {
1201         HIViewRef child;
1202
1203         err = GetIndexedSubControl( control , i , & child );
1204         if ( err == errControlIsNotEmbedder )
1205             return;
1206
1207         InvalidateControlAndChildren( child );
1208     }
1209 }
1210 #endif
1211
1212 void wxMacControl::InvalidateWithChildren()
1213 {
1214 #if TARGET_API_MAC_OSX
1215     InvalidateControlAndChildren( m_controlRef );
1216 #endif
1217 }
1218
1219 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1220 {
1221     wxASSERT( r != NULL );
1222
1223     HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
1224     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1225 }
1226
1227 OSType wxMacCreator = 'WXMC';
1228 OSType wxMacControlProperty = 'MCCT';
1229
1230 void wxMacControl::SetReferenceInNativeControl()
1231 {
1232     void * data = this;
1233     verify_noerr( SetControlProperty ( m_controlRef ,
1234         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1235 }
1236
1237 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1238 {
1239     wxMacControl* ctl = NULL;
1240     UInt32 actualSize;
1241     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1242         &actualSize , &ctl ) == noErr )
1243     {
1244         return ctl;
1245     }
1246     return NULL;
1247 }
1248
1249 // ============================================================================
1250 // DataBrowser Wrapper
1251 // ============================================================================
1252 //
1253 // basing on DataBrowserItemIDs
1254 //
1255
1256 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
1257     ControlRef browser,
1258     DataBrowserItemID itemID,
1259     DataBrowserItemNotification message,
1260     DataBrowserItemDataRef itemData )
1261 {
1262     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1263     if ( ctl != 0 )
1264     {
1265         ctl->ItemNotification(itemID, message, itemData);
1266     }
1267 }
1268
1269 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
1270     ControlRef browser,
1271     DataBrowserItemID itemID,
1272     DataBrowserPropertyID property,
1273     DataBrowserItemDataRef itemData,
1274     Boolean changeValue )
1275 {
1276     OSStatus err = errDataBrowserPropertyNotSupported;
1277
1278     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1279     if ( ctl != 0 )
1280     {
1281         err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
1282     }
1283     return err;
1284 }
1285
1286 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
1287     ControlRef browser,
1288     DataBrowserItemID itemOneID,
1289     DataBrowserItemID itemTwoID,
1290     DataBrowserPropertyID sortProperty)
1291 {
1292     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1293     if ( ctl != 0 )
1294     {
1295         return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
1296     }
1297     return false;
1298 }
1299
1300 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
1301 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
1302 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
1303
1304 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer, const wxPoint& pos, const wxSize& size, long style) : wxMacControl( peer )
1305 {
1306     Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
1307     OSStatus err = ::CreateDataBrowserControl(
1308         MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
1309         &bounds, kDataBrowserListView, &m_controlRef );
1310     SetReferenceInNativeControl();
1311     verify_noerr( err );
1312     if ( gDataBrowserItemCompareUPP == NULL )
1313         gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
1314     if ( gDataBrowserItemDataUPP == NULL )
1315         gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
1316     if ( gDataBrowserItemNotificationUPP == NULL )
1317     {
1318         gDataBrowserItemNotificationUPP =
1319 #if TARGET_API_MAC_OSX
1320             (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
1321 #else
1322             NewDataBrowserItemNotificationUPP(DataBrowserItemNotificationProc);
1323 #endif
1324     }
1325
1326     DataBrowserCallbacks callbacks;
1327     InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1328
1329     callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1330     callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1331     callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1332     SetCallbacks( &callbacks );
1333
1334 }
1335
1336 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1337     Boolean recurse,
1338     DataBrowserItemState state,
1339     UInt32 *numItems) const
1340 {
1341     return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1342 }
1343
1344 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1345     Boolean recurse,
1346     DataBrowserItemState state,
1347     Handle items) const
1348 {
1349     return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1350 }
1351
1352 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1353 {
1354     return SetDataBrowserSelectionFlags( m_controlRef, options );
1355 }
1356
1357 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1358         DataBrowserTableViewColumnIndex position )
1359 {
1360     return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1361 }
1362
1363 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1364 {
1365     return AutoSizeDataBrowserListViewColumns(m_controlRef);
1366 }
1367
1368 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1369 {
1370     return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1371 }
1372
1373 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1374 {
1375     return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1376 }
1377
1378 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1379 {
1380     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1381 }
1382
1383 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1384 {
1385     return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1386 }
1387
1388 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1389 {
1390     return SetDataBrowserCallbacks( m_controlRef, callbacks );
1391 }
1392
1393 OSStatus wxMacDataBrowserControl::UpdateItems(
1394     DataBrowserItemID container,
1395     UInt32 numItems,
1396     const DataBrowserItemID *items,
1397     DataBrowserPropertyID preSortProperty,
1398     DataBrowserPropertyID propertyID ) const
1399 {
1400     return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1401 }
1402
1403 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1404 {
1405     return IsDataBrowserItemSelected( m_controlRef, item );
1406 }
1407
1408 OSStatus wxMacDataBrowserControl::AddItems(
1409     DataBrowserItemID container,
1410     UInt32 numItems,
1411     const DataBrowserItemID *items,
1412     DataBrowserPropertyID preSortProperty )
1413 {
1414     return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1415 }
1416
1417 OSStatus wxMacDataBrowserControl::RemoveItems(
1418     DataBrowserItemID container,
1419     UInt32 numItems,
1420     const DataBrowserItemID *items,
1421     DataBrowserPropertyID preSortProperty )
1422 {
1423     return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1424 }
1425
1426 OSStatus wxMacDataBrowserControl::RevealItem(
1427     DataBrowserItemID item,
1428     DataBrowserPropertyID propertyID,
1429     DataBrowserRevealOptions options ) const
1430 {
1431     return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1432 }
1433
1434 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1435     UInt32 numItems,
1436     const DataBrowserItemID *items,
1437     DataBrowserSetOption operation )
1438 {
1439     return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1440 }
1441
1442 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1443 {
1444     return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1445 }
1446
1447 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1448 {
1449     return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1450 }
1451
1452 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1453 {
1454     return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1455 }
1456
1457 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1458 {
1459     return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1460 }
1461
1462 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1463 {
1464     return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1465 }
1466
1467 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1468 {
1469     return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1470 }
1471
1472 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1473 {
1474     return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1475 }
1476
1477 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1478 {
1479     return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1480 }
1481
1482 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1483 {
1484     return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1485 }
1486
1487 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1488 {
1489     return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1490 }
1491
1492 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1493 {
1494     return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1495 }
1496
1497 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1498 {
1499     return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1500 }
1501
1502 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1503     UInt32 *position) const
1504 {
1505     return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1506 }
1507
1508 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, UInt32 position)
1509 {
1510     return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1511 }
1512
1513 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1514 {
1515     return GetDataBrowserScrollPosition( m_controlRef , top , left );
1516 }
1517
1518 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1519 {
1520     return SetDataBrowserScrollPosition( m_controlRef , top , left );
1521 }
1522
1523 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1524 {
1525     return GetDataBrowserSortProperty( m_controlRef , column );
1526 }
1527
1528 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1529 {
1530     return SetDataBrowserSortProperty( m_controlRef , column );
1531 }
1532
1533 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1534 {
1535     return GetDataBrowserSortOrder( m_controlRef , order );
1536 }
1537
1538 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1539 {
1540     return SetDataBrowserSortOrder( m_controlRef , order );
1541 }
1542
1543 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1544     DataBrowserPropertyFlags *flags ) const
1545 {
1546     return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1547 }
1548
1549 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1550     DataBrowserPropertyFlags flags )
1551 {
1552     return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1553 }
1554
1555 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1556     DataBrowserListViewHeaderDesc *desc ) const
1557 {
1558     return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1559 }
1560
1561 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1562     DataBrowserListViewHeaderDesc *desc )
1563 {
1564     return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1565 }
1566
1567 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1568     Boolean expandableRows )
1569 {
1570     return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1571 }
1572
1573 // ============================================================================
1574 // Higher-level Databrowser
1575 // ============================================================================
1576 //
1577 // basing on data item objects
1578 //
1579
1580 wxMacDataItem::wxMacDataItem()
1581 {
1582 }
1583
1584 wxMacDataItem::~wxMacDataItem()
1585 {
1586 }
1587
1588 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *owner ,
1589     const wxMacDataItem*,
1590     DataBrowserPropertyID property) const
1591 {
1592     return false;
1593 }
1594
1595 OSStatus wxMacDataItem::GetSetData(wxMacDataItemBrowserControl *owner ,
1596     DataBrowserPropertyID property,
1597     DataBrowserItemDataRef itemData,
1598     bool changeValue )
1599 {
1600     return errDataBrowserPropertyNotSupported;
1601 }
1602
1603 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *owner ,
1604     DataBrowserItemNotification message,
1605     DataBrowserItemDataRef itemData ) const
1606 {
1607 }
1608
1609
1610 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1611     wxMacDataBrowserControl( peer, pos, size, style )
1612 {
1613     m_suppressSelection = false;
1614 }
1615
1616 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1617 {
1618     m_former = browser->SuppressSelection(true);
1619     m_browser = browser;
1620 }
1621
1622 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1623 {
1624     m_browser->SuppressSelection(m_former);
1625 }
1626
1627 bool  wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1628 {
1629     bool former = m_suppressSelection;
1630     m_suppressSelection = suppress;
1631
1632     return former;
1633 }
1634
1635 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1636     DataBrowserItemID itemTwoID,
1637     DataBrowserPropertyID sortProperty)
1638 {
1639     wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1640     wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1641     return CompareItems( itemOne , itemTwo , sortProperty );
1642 }
1643
1644 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem*  itemOne,
1645     const wxMacDataItem*  itemTwo,
1646     DataBrowserPropertyID sortProperty)
1647 {
1648     Boolean retval = false;
1649     if ( itemOne != NULL )
1650         retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1651     return retval;
1652 }
1653
1654 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1655     DataBrowserItemID itemID,
1656     DataBrowserPropertyID property,
1657     DataBrowserItemDataRef itemData,
1658     Boolean changeValue )
1659 {
1660     wxMacDataItem* item = (wxMacDataItem*) itemID;
1661     return GetSetItemData(item, property, itemData , changeValue );
1662 }
1663
1664 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1665     wxMacDataItem* item,
1666     DataBrowserPropertyID property,
1667     DataBrowserItemDataRef itemData,
1668     Boolean changeValue )
1669 {
1670     OSStatus err = errDataBrowserPropertyNotSupported;
1671     switch( property )
1672     {
1673         case kDataBrowserContainerIsClosableProperty :
1674         case kDataBrowserContainerIsSortableProperty :
1675         case kDataBrowserContainerIsOpenableProperty :
1676             // right now default behaviour on these
1677             break;
1678         default :
1679             if ( item != NULL )
1680                 err = item->GetSetData( this, property , itemData , changeValue );
1681             break;
1682
1683     }
1684     return err;
1685 }
1686
1687 void wxMacDataItemBrowserControl::ItemNotification(
1688     DataBrowserItemID itemID,
1689     DataBrowserItemNotification message,
1690     DataBrowserItemDataRef itemData)
1691 {
1692     wxMacDataItem* item = (wxMacDataItem*) itemID;
1693     ItemNotification( item , message, itemData);
1694 }
1695
1696 void wxMacDataItemBrowserControl::ItemNotification(
1697     const wxMacDataItem* item,
1698     DataBrowserItemNotification message,
1699     DataBrowserItemDataRef itemData)
1700 {
1701     if (item != NULL)
1702         item->Notification( this, message, itemData);
1703 }
1704
1705 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1706         bool recurse , DataBrowserItemState state) const
1707 {
1708     UInt32 numItems = 0;
1709     verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1710         recurse, state, &numItems ) );
1711     return numItems;
1712 }
1713
1714 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1715     bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1716 {
1717     Handle handle = NewHandle(0);
1718     verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1719         recurse , state, handle) );
1720
1721     int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1722     HLock( handle );
1723     wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1724     for ( int i = 0; i < itemCount; ++i)
1725     {
1726         items.Add(itemsArray[i]);
1727     }
1728     HUnlock( handle );
1729     DisposeHandle( handle );
1730 }
1731
1732 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1733 {
1734     DataBrowserTableViewRowIndex row;
1735     OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1736     wxASSERT( err == noErr);
1737     return row;
1738 }
1739
1740 wxMacDataItem*  wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1741 {
1742     DataBrowserItemID id;
1743     OSStatus err =  GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1744     wxASSERT( err == noErr);
1745     return (wxMacDataItem*) id;
1746 }
1747
1748 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1749         const wxMacDataItem *item , DataBrowserPropertyID property) const
1750 {
1751     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1752         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1753 }
1754
1755 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1756         wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1757 {
1758     unsigned int noItems = itemArray.GetCount();
1759     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1760     for ( unsigned int i = 0; i < noItems; ++i )
1761         items[i] = (DataBrowserItemID) itemArray[i];
1762
1763     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1764         items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1765     delete [] items;
1766 }
1767
1768 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1769 {
1770     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1771         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1772 }
1773
1774 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1775 {
1776     unsigned int noItems = itemArray.GetCount();
1777     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1778     for ( unsigned int i = 0; i < noItems; ++i )
1779         items[i] = (DataBrowserItemID) itemArray[i];
1780
1781     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1782         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1783     delete [] items;
1784 }
1785
1786 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1787 {
1788     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1789         (UInt32*) &item, kDataBrowserItemNoProperty );
1790     verify_noerr( err );
1791 }
1792
1793 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1794 {
1795     unsigned int noItems = itemArray.GetCount();
1796     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1797     for ( unsigned int i = 0; i < noItems; ++i )
1798         items[i] = (DataBrowserItemID) itemArray[i];
1799
1800     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1801         (UInt32*) items, kDataBrowserItemNoProperty );
1802     verify_noerr( err );
1803     delete [] items;
1804 }
1805
1806 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1807 {
1808     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1809     verify_noerr( err );
1810 }
1811
1812 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1813 {
1814     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1815 }
1816
1817 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1818 {
1819     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1820 }
1821
1822 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1823 {
1824     unsigned int noItems = itemArray.GetCount();
1825     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1826     for ( unsigned int i = 0; i < noItems; ++i )
1827         items[i] = (DataBrowserItemID) itemArray[i];
1828
1829     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
1830     delete [] items;
1831 }
1832
1833 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
1834 {
1835     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
1836 }
1837
1838 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
1839 {
1840     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
1841 }
1842
1843 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
1844 {
1845     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
1846 }
1847
1848
1849
1850 //
1851 // Tab Control
1852 //
1853
1854 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1855 {
1856     return ::SetTabEnabled( m_controlRef , tabNo , enable );
1857 }
1858
1859 //
1860 // Quartz Support
1861 //
1862
1863 #ifdef __WXMAC_OSX__
1864 // snippets from Sketch Sample from Apple :
1865
1866 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
1867
1868 /*
1869     This function locates, opens, and returns the profile reference for the calibrated
1870     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
1871     with the profile reference this function returns.
1872 */
1873 CMProfileRef wxMacOpenGenericProfile()
1874 {
1875     static CMProfileRef cachedRGBProfileRef = NULL;
1876
1877     // we only create the profile reference once
1878     if (cachedRGBProfileRef == NULL)
1879     {
1880         CMProfileLocation loc;
1881
1882         loc.locType = cmPathBasedProfile;
1883         strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
1884
1885         verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
1886     }
1887
1888     // clone the profile reference so that the caller has their own reference, not our cached one
1889     if (cachedRGBProfileRef)
1890         CMCloneProfileRef(cachedRGBProfileRef);
1891
1892     return cachedRGBProfileRef;
1893 }
1894
1895 /*
1896     Return the generic RGB color space. This is a 'get' function and the caller should
1897     not release the returned value unless the caller retains it first. Usually callers
1898     of this routine will immediately use the returned colorspace with CoreGraphics
1899     so they typically do not need to retain it themselves.
1900
1901     This function creates the generic RGB color space once and hangs onto it so it can
1902     return it whenever this function is called.
1903 */
1904
1905 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1906 {
1907     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
1908
1909     if (genericRGBColorSpace == NULL)
1910     {
1911         if ( UMAGetSystemVersion() >= 0x1040 )
1912         {
1913             genericRGBColorSpace.Set( CGColorSpaceCreateWithName( CFSTR("kCGColorSpaceGenericRGB") ) );
1914         }
1915         else
1916         {
1917             CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
1918
1919             if (genericRGBProfile)
1920             {
1921                 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) );
1922
1923                 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") );
1924
1925                 // we opened the profile so it is up to us to close it
1926                 CMCloseProfile(genericRGBProfile);
1927             }
1928         }
1929     }
1930
1931     return genericRGBColorSpace;
1932 }
1933 #endif
1934
1935 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
1936 {
1937     ::GetPort( &m_port );
1938     ::SetPort( port );
1939 }
1940
1941 wxMacPortSaver::~wxMacPortSaver()
1942 {
1943     ::SetPort( m_port );
1944 }
1945
1946 #endif // wxUSE_GUI