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