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 *WXUNUSED(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 wxString wxGetUserHome (const wxString& user)
 593 {
 594     // TODO
 595     return wxString();
 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 WXUNUSED(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 #ifndef __LP64__
 947     ControlFontStyleRec fontStyle;
 948     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 949     {
 950         switch ( font.MacGetThemeFontID() )
 951         {
 952             case kThemeSmallSystemFont :
 953                 fontStyle.font = kControlFontSmallSystemFont;
 954                 break;
 955
 956             case 109 : // mini font
 957                 fontStyle.font = -5;
 958                 break;
 959
 960             case kThemeSystemFont :
 961                 fontStyle.font = kControlFontBigSystemFont;
 962                 break;
 963
 964             default :
 965                 fontStyle.font = kControlFontBigSystemFont;
 966                 break;
 967         }
 968
 969         fontStyle.flags = kControlUseFontMask;
 970     }
 971     else
 972     {
 973         fontStyle.font = font.MacGetFontNum();
 974         fontStyle.style = font.MacGetFontStyle();
 975         fontStyle.size = font.MacGetFontSize();
 976         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
 977     }
 978
 979     fontStyle.just = teJustLeft;
 980     fontStyle.flags |= kControlUseJustMask;
 981     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
 982         fontStyle.just = teJustCenter;
 983     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
 984         fontStyle.just = teJustRight;
 985
 986
 987     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
 988     // won't get grayed out by the system anymore
 989
 990     if ( foreground != *wxBLACK )
 991     {
 992         fontStyle.foreColor = MAC_WXCOLORREF( foreground.GetPixel() );
 993         fontStyle.flags |= kControlUseForeColorMask;
 994     }
 995
 996     ::SetControlFontStyle( m_controlRef , &fontStyle );
 997 #endif
 998 }
 999
1000 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1001 {
1002     // TODO
1003     // setting up a color proc is not recommended anymore
1004 }
1005
1006 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1007 {
1008     ::SetControl32BitMinimum( m_controlRef , minimum );
1009     ::SetControl32BitMaximum( m_controlRef , maximum );
1010 }
1011
1012 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1013 {
1014 #ifndef __LP64__
1015     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1016 #else
1017     return 0;
1018 #endif
1019 }
1020
1021 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1022 {
1023     SetControlAction( m_controlRef , actionProc );
1024 }
1025
1026 void wxMacControl::SetViewSize( SInt32 viewSize )
1027 {
1028     SetControlViewSize(m_controlRef , viewSize );
1029 }
1030
1031 SInt32 wxMacControl::GetViewSize() const
1032 {
1033     return GetControlViewSize( m_controlRef );
1034 }
1035
1036 bool wxMacControl::IsVisible() const
1037 {
1038     return IsControlVisible( m_controlRef );
1039 }
1040
1041 void wxMacControl::SetVisibility( bool visible , bool redraw )
1042 {
1043     SetControlVisibility( m_controlRef , visible , redraw );
1044 }
1045
1046 bool wxMacControl::IsEnabled() const
1047 {
1048 #if TARGET_API_MAC_OSX
1049     return IsControlEnabled( m_controlRef );
1050 #else
1051     return IsControlActive( m_controlRef );
1052 #endif
1053 }
1054
1055 bool wxMacControl::IsActive() const
1056 {
1057     return IsControlActive( m_controlRef );
1058 }
1059
1060 void wxMacControl::Enable( bool enable )
1061 {
1062     if ( enable )
1063         EnableControl( m_controlRef );
1064     else
1065         DisableControl( m_controlRef );
1066 }
1067
1068 void wxMacControl::SetDrawingEnabled( bool enable )
1069 {
1070     HIViewSetDrawingEnabled( m_controlRef , enable );
1071 }
1072
1073 bool wxMacControl::GetNeedsDisplay() const
1074 {
1075     return HIViewGetNeedsDisplay( m_controlRef );
1076 }
1077
1078 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1079 {
1080     if ( !IsVisible() )
1081         return;
1082
1083     HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
1084 }
1085
1086 void wxMacControl::SetNeedsDisplay( Rect* where )
1087 {
1088     if ( !IsVisible() )
1089         return;
1090
1091     if ( where != NULL )
1092     {
1093         RgnHandle update = NewRgn();
1094         RectRgn( update , where );
1095         HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
1096         DisposeRgn( update );
1097     }
1098     else
1099         HIViewSetNeedsDisplay( m_controlRef , true );
1100 }
1101
1102 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1103 {
1104     HIPoint hiPoint;
1105
1106     hiPoint.x = pt->x;
1107     hiPoint.y = pt->y;
1108     HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  );
1109     pt->x = (int)hiPoint.x;
1110     pt->y = (int)hiPoint.y;
1111 }
1112
1113 void wxMacControl::SetRect( Rect *r )
1114 {
1115         //A HIRect is actually a CGRect on OSX - which consists of two structures -
1116         //CGPoint and CGSize, which have two floats each
1117         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
1118         HIViewSetFrame ( m_controlRef , &hir );
1119         // eventuall we might have to do a SetVisibility( false , true );
1120         // before and a SetVisibility( true , true ); after
1121 }
1122
1123 void wxMacControl::GetRect( Rect *r )
1124 {
1125     GetControlBounds( m_controlRef , r );
1126 }
1127
1128 void wxMacControl::GetRectInWindowCoords( Rect *r )
1129 {
1130     UMAGetControlBoundsInWindowCoords( m_controlRef , r );
1131 }
1132
1133 void wxMacControl::GetBestRect( Rect *r )
1134 {
1135     short   baselineoffset;
1136
1137     GetBestControlRect( m_controlRef , r , &baselineoffset );
1138 }
1139
1140 void wxMacControl::SetLabel( const wxString &title )
1141 {
1142     wxFontEncoding encoding;
1143
1144     if ( m_font.Ok() )
1145         encoding = m_font.GetEncoding();
1146     else
1147         encoding = wxFont::GetDefaultEncoding();
1148
1149     UMASetControlTitle( m_controlRef , title , encoding );
1150 }
1151
1152 void wxMacControl::GetFeatures( UInt32 * features )
1153 {
1154     GetControlFeatures( m_controlRef , features );
1155 }
1156
1157 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1158 {
1159     OSStatus err = GetControlRegion( m_controlRef , partCode , region );
1160     return err;
1161 }
1162
1163 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1164 {
1165 #if TARGET_API_MAC_OSX
1166     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1167        (other != NULL) ? other->m_controlRef : NULL);
1168 #else
1169     return 0;
1170 #endif
1171 }
1172
1173 #if TARGET_API_MAC_OSX
1174 // SetNeedsDisplay would not invalidate the children
1175 static void InvalidateControlAndChildren( HIViewRef control )
1176 {
1177     HIViewSetNeedsDisplay( control , true );
1178     UInt16 childrenCount = 0;
1179     OSStatus err = CountSubControls( control , &childrenCount );
1180     if ( err == errControlIsNotEmbedder )
1181         return;
1182
1183     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1184
1185     for ( UInt16 i = childrenCount; i >=1; --i )
1186     {
1187         HIViewRef child;
1188
1189         err = GetIndexedSubControl( control , i , & child );
1190         if ( err == errControlIsNotEmbedder )
1191             return;
1192
1193         InvalidateControlAndChildren( child );
1194     }
1195 }
1196 #endif
1197
1198 void wxMacControl::InvalidateWithChildren()
1199 {
1200 #if TARGET_API_MAC_OSX
1201     InvalidateControlAndChildren( m_controlRef );
1202 #endif
1203 }
1204
1205 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1206 {
1207     wxASSERT( r != NULL );
1208
1209     HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
1210     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1211 }
1212
1213 OSType wxMacCreator = 'WXMC';
1214 OSType wxMacControlProperty = 'MCCT';
1215
1216 void wxMacControl::SetReferenceInNativeControl()
1217 {
1218     void * data = this;
1219     verify_noerr( SetControlProperty ( m_controlRef ,
1220         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1221 }
1222
1223 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1224 {
1225     wxMacControl* ctl = NULL;
1226     ByteCount actualSize;
1227     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1228         &actualSize , &ctl ) == noErr )
1229     {
1230         return ctl;
1231     }
1232     return NULL;
1233 }
1234
1235 // ============================================================================
1236 // DataBrowser Wrapper
1237 // ============================================================================
1238 //
1239 // basing on DataBrowserItemIDs
1240 //
1241
1242 IMPLEMENT_ABSTRACT_CLASS( wxMacDataBrowserControl , wxMacControl )
1243
1244 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
1245     ControlRef browser,
1246     DataBrowserItemID itemID,
1247     DataBrowserItemNotification message,
1248     DataBrowserItemDataRef itemData )
1249 {
1250     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
1251     if ( ctl != 0 )
1252     {
1253         ctl->ItemNotification(itemID, message, itemData);
1254     }
1255 }
1256
1257 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
1258     ControlRef browser,
1259     DataBrowserItemID itemID,
1260     DataBrowserPropertyID property,
1261     DataBrowserItemDataRef itemData,
1262     Boolean changeValue )
1263 {
1264     OSStatus err = errDataBrowserPropertyNotSupported;
1265     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
1266     if ( ctl != 0 )
1267     {
1268         err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
1269     }
1270     return err;
1271 }
1272
1273 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
1274     ControlRef browser,
1275     DataBrowserItemID itemOneID,
1276     DataBrowserItemID itemTwoID,
1277     DataBrowserPropertyID sortProperty)
1278 {
1279     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
1280     if ( ctl != 0 )
1281     {
1282         return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
1283     }
1284     return false;
1285 }
1286
1287 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
1288 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
1289 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
1290
1291 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer,
1292                                                   const wxPoint& pos,
1293                                                   const wxSize& size,
1294                                                   long WXUNUSED(style))
1295                        : wxMacControl( peer )
1296 {
1297     Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
1298     OSStatus err = ::CreateDataBrowserControl(
1299         MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
1300         &bounds, kDataBrowserListView, &m_controlRef );
1301     SetReferenceInNativeControl();
1302     verify_noerr( err );
1303     if ( gDataBrowserItemCompareUPP == NULL )
1304         gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
1305     if ( gDataBrowserItemDataUPP == NULL )
1306         gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
1307     if ( gDataBrowserItemNotificationUPP == NULL )
1308     {
1309         gDataBrowserItemNotificationUPP =
1310 #if TARGET_API_MAC_OSX
1311             (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
1312 #else
1313             NewDataBrowserItemNotificationUPP(DataBrowserItemNotificationProc);
1314 #endif
1315     }
1316
1317     DataBrowserCallbacks callbacks;
1318     InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1319
1320     callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1321     callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1322     callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1323     SetCallbacks( &callbacks );
1324
1325 }
1326
1327 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1328     Boolean recurse,
1329     DataBrowserItemState state,
1330     ItemCount *numItems) const
1331 {
1332     return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1333 }
1334
1335 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1336     Boolean recurse,
1337     DataBrowserItemState state,
1338     Handle items) const
1339 {
1340     return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1341 }
1342
1343 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1344 {
1345     return SetDataBrowserSelectionFlags( m_controlRef, options );
1346 }
1347
1348 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1349         DataBrowserTableViewColumnIndex position )
1350 {
1351     return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1352 }
1353
1354 OSStatus wxMacDataBrowserControl::GetColumnIDFromIndex( DataBrowserTableViewColumnIndex position, DataBrowserTableViewColumnID* id ){
1355     return GetDataBrowserTableViewColumnProperty( m_controlRef, position, id );
1356 }
1357
1358 OSStatus wxMacDataBrowserControl::RemoveColumn( DataBrowserTableViewColumnIndex position )
1359 {
1360     DataBrowserTableViewColumnID id;
1361     GetColumnIDFromIndex( position, &id );
1362     return RemoveDataBrowserTableViewColumn( m_controlRef, id );
1363 }
1364
1365 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1366 {
1367     return AutoSizeDataBrowserListViewColumns(m_controlRef);
1368 }
1369
1370 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1371 {
1372     return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1373 }
1374
1375 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1376 {
1377     return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1378 }
1379
1380 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1381 {
1382     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1383 }
1384
1385 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1386 {
1387     return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1388 }
1389
1390 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1391 {
1392     return SetDataBrowserCallbacks( m_controlRef, callbacks );
1393 }
1394
1395 OSStatus wxMacDataBrowserControl::UpdateItems(
1396     DataBrowserItemID container,
1397     UInt32 numItems,
1398     const DataBrowserItemID *items,
1399     DataBrowserPropertyID preSortProperty,
1400     DataBrowserPropertyID propertyID ) const
1401 {
1402     return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1403 }
1404
1405 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1406 {
1407     return IsDataBrowserItemSelected( m_controlRef, item );
1408 }
1409
1410 OSStatus wxMacDataBrowserControl::AddItems(
1411     DataBrowserItemID container,
1412     UInt32 numItems,
1413     const DataBrowserItemID *items,
1414     DataBrowserPropertyID preSortProperty )
1415 {
1416     return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1417 }
1418
1419 OSStatus wxMacDataBrowserControl::RemoveItems(
1420     DataBrowserItemID container,
1421     UInt32 numItems,
1422     const DataBrowserItemID *items,
1423     DataBrowserPropertyID preSortProperty )
1424 {
1425     return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1426 }
1427
1428 OSStatus wxMacDataBrowserControl::RevealItem(
1429     DataBrowserItemID item,
1430     DataBrowserPropertyID propertyID,
1431     DataBrowserRevealOptions options ) const
1432 {
1433     return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1434 }
1435
1436 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1437     UInt32 numItems,
1438     const DataBrowserItemID *items,
1439     DataBrowserSetOption operation )
1440 {
1441     return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1442 }
1443
1444 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1445 {
1446     return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1447 }
1448
1449 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1450 {
1451     return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1452 }
1453
1454 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1455 {
1456     return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1457 }
1458
1459 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1460 {
1461     return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1462 }
1463
1464 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1465 {
1466     return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1467 }
1468
1469 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1470 {
1471     return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1472 }
1473
1474 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1475 {
1476     return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1477 }
1478
1479 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1480 {
1481     return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1482 }
1483
1484 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1485 {
1486     return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1487 }
1488
1489 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1490 {
1491     return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1492 }
1493
1494 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1495 {
1496     return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1497 }
1498
1499 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1500 {
1501     return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1502 }
1503
1504 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1505     DataBrowserTableViewColumnIndex *position) const
1506 {
1507     return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1508 }
1509
1510 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, DataBrowserTableViewColumnIndex position)
1511 {
1512     return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1513 }
1514
1515 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1516 {
1517     return GetDataBrowserScrollPosition( m_controlRef , top , left );
1518 }
1519
1520 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1521 {
1522     return SetDataBrowserScrollPosition( m_controlRef , top , left );
1523 }
1524
1525 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1526 {
1527     return GetDataBrowserSortProperty( m_controlRef , column );
1528 }
1529
1530 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1531 {
1532     return SetDataBrowserSortProperty( m_controlRef , column );
1533 }
1534
1535 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1536 {
1537     return GetDataBrowserSortOrder( m_controlRef , order );
1538 }
1539
1540 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1541 {
1542     return SetDataBrowserSortOrder( m_controlRef , order );
1543 }
1544
1545 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1546     DataBrowserPropertyFlags *flags ) const
1547 {
1548     return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1549 }
1550
1551 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1552     DataBrowserPropertyFlags flags )
1553 {
1554     return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1555 }
1556
1557 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1558     DataBrowserListViewHeaderDesc *desc ) const
1559 {
1560     return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1561 }
1562
1563 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1564     DataBrowserListViewHeaderDesc *desc )
1565 {
1566     return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1567 }
1568
1569 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1570     Boolean expandableRows )
1571 {
1572     return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1573 }
1574
1575 // ============================================================================
1576 // Higher-level Databrowser
1577 // ============================================================================
1578 //
1579 // basing on data item objects
1580 //
1581
1582 wxMacDataItem::wxMacDataItem()
1583 {
1584     m_data = NULL;
1585
1586     m_order = 0;
1587     m_colId = kTextColumnId; // for compat with existing wx*ListBox impls.
1588 }
1589
1590 wxMacDataItem::~wxMacDataItem()
1591 {
1592 }
1593
1594 void wxMacDataItem::SetOrder( SInt32 order )
1595 {
1596     m_order = order;
1597 }
1598
1599 SInt32 wxMacDataItem::GetOrder() const
1600 {
1601     return m_order;
1602 }
1603
1604 void wxMacDataItem::SetData( void* data)
1605 {
1606     m_data = data;
1607 }
1608
1609 void* wxMacDataItem::GetData() const
1610 {
1611     return m_data;
1612 }
1613
1614 short wxMacDataItem::GetColumn()
1615 {
1616     return m_colId;
1617 }
1618
1619 void wxMacDataItem::SetColumn( short col )
1620 {
1621     m_colId = col;
1622 }
1623
1624 void wxMacDataItem::SetLabel( const wxString& str)
1625 {
1626     m_label = str;
1627     m_cfLabel.Assign( str , wxLocale::GetSystemEncoding());
1628 }
1629
1630 const wxString& wxMacDataItem::GetLabel() const
1631 {
1632     return m_label;
1633 }
1634
1635 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1636     const wxMacDataItem* rhs,
1637     DataBrowserPropertyID sortProperty) const
1638 {
1639     const wxMacDataItem* otherItem = wx_const_cast(wxMacDataItem*,rhs);
1640     bool retval = false;
1641
1642     if ( sortProperty == m_colId ){
1643         retval = m_label.CmpNoCase( otherItem->m_label) < 0;
1644     }
1645
1646     else if ( sortProperty == kNumericOrderColumnId )
1647         retval = m_order < otherItem->m_order;
1648
1649     return retval;
1650 }
1651
1652 OSStatus wxMacDataItem::GetSetData( wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1653     DataBrowserPropertyID property,
1654     DataBrowserItemDataRef itemData,
1655     bool changeValue )
1656 {
1657     OSStatus err = errDataBrowserPropertyNotSupported;
1658     if ( !changeValue )
1659     {
1660         if ( property == m_colId ){
1661             err = ::SetDataBrowserItemDataText( itemData, m_cfLabel );
1662             err = noErr;
1663         }
1664         else if ( property == kNumericOrderColumnId ){
1665             err = ::SetDataBrowserItemDataValue( itemData, m_order );
1666             err = noErr;
1667         }
1668         else{
1669         }
1670     }
1671     else
1672     {
1673         switch (property)
1674         {
1675             // no editable props here
1676             default:
1677                 break;
1678         }
1679     }
1680
1681     return err;
1682 }
1683
1684 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1685     DataBrowserItemNotification WXUNUSED(message),
1686     DataBrowserItemDataRef WXUNUSED(itemData) ) const
1687 {
1688 }
1689
1690 IMPLEMENT_DYNAMIC_CLASS( wxMacDataItemBrowserControl , wxMacDataBrowserControl )
1691
1692 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1693     wxMacDataBrowserControl( peer, pos, size, style )
1694 {
1695     m_suppressSelection = false;
1696     m_sortOrder = SortOrder_None;
1697     m_clientDataItemsType = wxClientData_None;
1698 }
1699
1700 wxMacDataItem* wxMacDataItemBrowserControl::CreateItem()
1701 {
1702     return new wxMacDataItem();
1703 }
1704
1705 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1706 {
1707     m_former = browser->SuppressSelection(true);
1708     m_browser = browser;
1709 }
1710
1711 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1712 {
1713     m_browser->SuppressSelection(m_former);
1714 }
1715
1716 bool  wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1717 {
1718     bool former = m_suppressSelection;
1719     m_suppressSelection = suppress;
1720
1721     return former;
1722 }
1723
1724 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1725     DataBrowserItemID itemTwoID,
1726     DataBrowserPropertyID sortProperty)
1727 {
1728     wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1729     wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1730     return CompareItems( itemOne , itemTwo , sortProperty );
1731 }
1732
1733 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem*  itemOne,
1734     const wxMacDataItem*  itemTwo,
1735     DataBrowserPropertyID sortProperty)
1736 {
1737     Boolean retval = false;
1738     if ( itemOne != NULL )
1739         retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1740     return retval;
1741 }
1742
1743 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1744     DataBrowserItemID itemID,
1745     DataBrowserPropertyID property,
1746     DataBrowserItemDataRef itemData,
1747     Boolean changeValue )
1748 {
1749     wxMacDataItem* item = (wxMacDataItem*) itemID;
1750     return GetSetItemData(item, property, itemData , changeValue );
1751 }
1752
1753 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1754     wxMacDataItem* item,
1755     DataBrowserPropertyID property,
1756     DataBrowserItemDataRef itemData,
1757     Boolean changeValue )
1758 {
1759     OSStatus err = errDataBrowserPropertyNotSupported;
1760     switch( property )
1761     {
1762         case kDataBrowserContainerIsClosableProperty :
1763         case kDataBrowserContainerIsSortableProperty :
1764         case kDataBrowserContainerIsOpenableProperty :
1765             // right now default behaviour on these
1766             break;
1767         default :
1768
1769             if ( item != NULL ){
1770                 err = item->GetSetData( this, property , itemData , changeValue );
1771             }
1772             break;
1773
1774     }
1775     return err;
1776 }
1777
1778 void wxMacDataItemBrowserControl::ItemNotification(
1779     DataBrowserItemID itemID,
1780     DataBrowserItemNotification message,
1781     DataBrowserItemDataRef itemData)
1782 {
1783     wxMacDataItem* item = (wxMacDataItem*) itemID;
1784     ItemNotification( item , message, itemData);
1785 }
1786
1787 void wxMacDataItemBrowserControl::ItemNotification(
1788     const wxMacDataItem* item,
1789     DataBrowserItemNotification message,
1790     DataBrowserItemDataRef itemData)
1791 {
1792     if (item != NULL)
1793         item->Notification( this, message, itemData);
1794 }
1795
1796 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1797         bool recurse , DataBrowserItemState state) const
1798 {
1799     ItemCount numItems = 0;
1800     verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1801         recurse, state, &numItems ) );
1802     return numItems;
1803 }
1804
1805 unsigned int wxMacDataItemBrowserControl::GetSelectedItemCount( const wxMacDataItem* container,
1806         bool recurse ) const
1807 {
1808     return GetItemCount( container, recurse, kDataBrowserItemIsSelected );
1809
1810 }
1811
1812 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1813     bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1814 {
1815     Handle handle = NewHandle(0);
1816     verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1817         recurse , state, handle) );
1818
1819     int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1820     HLock( handle );
1821     wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1822     for ( int i = 0; i < itemCount; ++i)
1823     {
1824         items.Add(itemsArray[i]);
1825     }
1826     HUnlock( handle );
1827     DisposeHandle( handle );
1828 }
1829
1830 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1831 {
1832     DataBrowserTableViewRowIndex row;
1833     OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1834     wxASSERT( err == noErr);
1835     return row;
1836 }
1837
1838 wxMacDataItem*  wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1839 {
1840     DataBrowserItemID id;
1841     OSStatus err =  GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1842     wxASSERT( err == noErr);
1843     return (wxMacDataItem*) id;
1844 }
1845
1846 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1847         const wxMacDataItem *item , DataBrowserPropertyID property) const
1848 {
1849     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1850         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1851 }
1852
1853 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1854         wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1855 {
1856     unsigned int noItems = itemArray.GetCount();
1857     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1858     for ( unsigned int i = 0; i < noItems; ++i )
1859         items[i] = (DataBrowserItemID) itemArray[i];
1860
1861     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1862         items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1863     delete [] items;
1864 }
1865
1866 void wxMacDataItemBrowserControl::InsertColumn(int colId, DataBrowserPropertyType colType,
1867                                             const wxString& title, SInt16 just, int defaultWidth)
1868 {
1869     DataBrowserListViewColumnDesc columnDesc;
1870     columnDesc.headerBtnDesc.titleOffset = 0;
1871     columnDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
1872
1873     columnDesc.headerBtnDesc.btnFontStyle.flags =
1874         kControlUseFontMask | kControlUseJustMask;
1875
1876     columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
1877     columnDesc.headerBtnDesc.btnFontStyle.just = just;
1878     columnDesc.headerBtnDesc.btnFontStyle.font = kControlFontViewSystemFont;
1879     columnDesc.headerBtnDesc.btnFontStyle.style = normal;
1880
1881     // TODO: Why is m_font not defined when we enter wxLC_LIST mode, but is
1882     // defined for other modes?
1883     wxFontEncoding enc;
1884     if ( m_font.Ok() )
1885         enc = m_font.GetEncoding();
1886     else
1887         enc = wxLocale::GetSystemEncoding();
1888     wxMacCFStringHolder cfTitle;
1889     cfTitle.Assign( title, enc );
1890     columnDesc.headerBtnDesc.titleString = cfTitle;
1891
1892     columnDesc.headerBtnDesc.minimumWidth = 0;
1893     columnDesc.headerBtnDesc.maximumWidth = 30000;
1894
1895     columnDesc.propertyDesc.propertyID = (kMinColumnId + colId);
1896     columnDesc.propertyDesc.propertyType = colType;
1897     columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewSortableColumn;
1898 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
1899     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn;
1900 #endif
1901 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
1902     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewNoGapForIconInHeaderButton;
1903 #endif
1904
1905     verify_noerr( AddColumn( &columnDesc, kDataBrowserListViewAppendColumn ) );
1906
1907     if (defaultWidth > 0){
1908         SetColumnWidth(colId, defaultWidth);
1909     }
1910
1911 }
1912
1913 void wxMacDataItemBrowserControl::SetColumnWidth(int colId, int width)
1914 {
1915     DataBrowserPropertyID id;
1916     GetColumnIDFromIndex(colId, &id);
1917     verify_noerr( wxMacDataBrowserControl::SetColumnWidth(id, width));
1918 }
1919
1920 int wxMacDataItemBrowserControl::GetColumnWidth(int colId)
1921 {
1922     DataBrowserPropertyID id;
1923     GetColumnIDFromIndex(colId, &id);
1924     UInt16 result;
1925     verify_noerr( wxMacDataBrowserControl::GetColumnWidth(id, &result));
1926     return result;
1927 }
1928
1929 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1930 {
1931     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1932         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1933 }
1934
1935 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1936 {
1937     unsigned int noItems = itemArray.GetCount();
1938     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1939     for ( unsigned int i = 0; i < noItems; ++i )
1940         items[i] = (DataBrowserItemID) itemArray[i];
1941
1942     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1943         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1944     delete [] items;
1945 }
1946
1947 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1948 {
1949     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1950         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty );
1951     verify_noerr( err );
1952 }
1953
1954 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1955 {
1956     unsigned int noItems = itemArray.GetCount();
1957     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1958     for ( unsigned int i = 0; i < noItems; ++i )
1959         items[i] = (DataBrowserItemID) itemArray[i];
1960
1961     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1962         (DataBrowserItemID*) items, kDataBrowserItemNoProperty );
1963     verify_noerr( err );
1964     delete [] items;
1965 }
1966
1967 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1968 {
1969     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1970     verify_noerr( err );
1971 }
1972
1973 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1974 {
1975     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1976 }
1977
1978 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1979 {
1980     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1981 }
1982
1983 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1984 {
1985     unsigned int noItems = itemArray.GetCount();
1986     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1987     for ( unsigned int i = 0; i < noItems; ++i )
1988         items[i] = (DataBrowserItemID) itemArray[i];
1989
1990     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
1991     delete [] items;
1992 }
1993
1994 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
1995 {
1996     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
1997 }
1998
1999 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
2000 {
2001     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
2002 }
2003
2004 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
2005 {
2006     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
2007 }
2008
2009 wxClientDataType wxMacDataItemBrowserControl::GetClientDataType() const
2010 {
2011      return m_clientDataItemsType;
2012 }
2013 void wxMacDataItemBrowserControl::SetClientDataType(wxClientDataType clientDataItemsType)
2014 {
2015     m_clientDataItemsType = clientDataItemsType;
2016 }
2017
2018 unsigned int wxMacDataItemBrowserControl::MacGetCount() const
2019 {
2020     return GetItemCount(wxMacDataBrowserRootContainer,false,kDataBrowserItemAnyState);
2021 }
2022
2023 void wxMacDataItemBrowserControl::MacDelete( unsigned int n )
2024 {
2025     wxMacDataItem* item = (wxMacDataItem*)GetItemFromLine( n );
2026     RemoveItem( wxMacDataBrowserRootContainer, item );
2027 }
2028
2029 void wxMacDataItemBrowserControl::MacInsert( unsigned int n,
2030                                              const wxArrayStringsAdapter& items,
2031                                              int column )
2032 {
2033     size_t itemsCount = items.GetCount();
2034     if ( itemsCount == 0 )
2035         return;
2036
2037     SInt32 frontLineOrder = 0;
2038
2039     if ( m_sortOrder == SortOrder_None )
2040     {
2041         // increase the order of the lines to be shifted
2042         unsigned int lines = MacGetCount();
2043         for ( unsigned int i = n; i < lines; ++i)
2044         {
2045             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
2046             iter->SetOrder( iter->GetOrder() + itemsCount );
2047         }
2048         if ( n > 0 )
2049         {
2050             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
2051             frontLineOrder = iter->GetOrder();
2052         }
2053     }
2054
2055     wxArrayMacDataItemPtr ids;
2056     ids.SetCount( itemsCount );
2057
2058     for ( unsigned int i = 0; i < itemsCount; ++i )
2059     {
2060         wxMacDataItem* item = CreateItem();
2061         item->SetLabel( items[i]);
2062         if ( column != -1 )
2063             item->SetColumn( kMinColumnId + column );
2064
2065         if ( m_sortOrder == SortOrder_None )
2066             item->SetOrder( frontLineOrder + 1 + i );
2067
2068         ids[i] = item;
2069     }
2070
2071     AddItems( wxMacDataBrowserRootContainer, ids );
2072 }
2073
2074 int wxMacDataItemBrowserControl::MacAppend( const wxString& text)
2075 {
2076     wxMacDataItem* item = CreateItem();
2077     item->SetLabel( text );
2078     if ( m_sortOrder == SortOrder_None )
2079     {
2080         unsigned int lines = MacGetCount();
2081         if ( lines == 0 )
2082             item->SetOrder( 1 );
2083         else
2084         {
2085             wxMacDataItem* frontItem = (wxMacDataItem*) GetItemFromLine(lines-1);
2086             item->SetOrder( frontItem->GetOrder() + 1 );
2087         }
2088     }
2089     AddItem( wxMacDataBrowserRootContainer, item );
2090
2091     return GetLineFromItem(item);
2092 }
2093
2094 void wxMacDataItemBrowserControl::MacClear()
2095 {
2096     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2097     RemoveAllItems(wxMacDataBrowserRootContainer);
2098 }
2099
2100 void wxMacDataItemBrowserControl::MacDeselectAll()
2101 {
2102     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2103     SetSelectedAllItems( kDataBrowserItemsRemove );
2104 }
2105
2106 void wxMacDataItemBrowserControl::MacSetSelection( unsigned int n, bool select, bool multi )
2107 {
2108     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2109     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2110
2111     if ( IsItemSelected( item ) != select )
2112     {
2113         if ( select )
2114             SetSelectedItem( item, multi ? kDataBrowserItemsAdd : kDataBrowserItemsAssign );
2115         else
2116             SetSelectedItem( item, kDataBrowserItemsRemove );
2117     }
2118
2119     MacScrollTo( n );
2120 }
2121
2122 bool wxMacDataItemBrowserControl::MacIsSelected( unsigned int n ) const
2123 {
2124     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2125     return IsItemSelected( item );
2126 }
2127
2128 int wxMacDataItemBrowserControl::MacGetSelection() const
2129 {
2130     wxMacDataItemPtr first, last;
2131     GetSelectionAnchor( &first, &last );
2132
2133     if ( first != NULL )
2134     {
2135         return GetLineFromItem( first );
2136     }
2137
2138     return -1;
2139 }
2140
2141 int wxMacDataItemBrowserControl::MacGetSelections( wxArrayInt& aSelections ) const
2142 {
2143     aSelections.Empty();
2144     wxArrayMacDataItemPtr selectedItems;
2145     GetItems( wxMacDataBrowserRootContainer, false , kDataBrowserItemIsSelected, selectedItems);
2146
2147     int count = selectedItems.GetCount();
2148
2149     for ( int i = 0; i < count; ++i)
2150     {
2151         aSelections.Add(GetLineFromItem(selectedItems[i]));
2152     }
2153
2154     return count;
2155 }
2156
2157 void wxMacDataItemBrowserControl::MacSetString( unsigned int n, const wxString& text )
2158 {
2159     // as we don't store the strings we only have to issue a redraw
2160     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2161     item->SetLabel( text );
2162     UpdateItem( wxMacDataBrowserRootContainer, item , kTextColumnId );
2163 }
2164
2165 wxString wxMacDataItemBrowserControl::MacGetString( unsigned int n ) const
2166 {
2167     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2168     return item->GetLabel();
2169 }
2170
2171 void wxMacDataItemBrowserControl::MacSetClientData( unsigned int n, void * data)
2172 {
2173     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2174     item->SetData( data );
2175     // not displayed, therefore no Update infos to DataBrowser
2176 }
2177
2178 void * wxMacDataItemBrowserControl::MacGetClientData( unsigned int n) const
2179 {
2180     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2181     return item->GetData();
2182 }
2183
2184 void wxMacDataItemBrowserControl::MacScrollTo( unsigned int n )
2185 {
2186     UInt32 top , left ;
2187     GetScrollPosition( &top , &left ) ;
2188     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2189
2190     UInt16 height ;
2191     GetRowHeight( (DataBrowserItemID) item , &height ) ;
2192     SetScrollPosition( n * ((UInt32)height) , left ) ;
2193
2194     RevealItem( item , kDataBrowserRevealWithoutSelecting );
2195 }
2196
2197
2198
2199 //
2200 // Tab Control
2201 //
2202
2203 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
2204 {
2205     return ::SetTabEnabled( m_controlRef , tabNo , enable );
2206 }
2207
2208 //
2209 // Quartz Support
2210 //
2211
2212 #ifdef __WXMAC_OSX__
2213 // snippets from Sketch Sample from Apple :
2214
2215 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
2216
2217 /*
2218     This function locates, opens, and returns the profile reference for the calibrated
2219     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
2220     with the profile reference this function returns.
2221 */
2222 CMProfileRef wxMacOpenGenericProfile()
2223 {
2224     static CMProfileRef cachedRGBProfileRef = NULL;
2225
2226     // we only create the profile reference once
2227     if (cachedRGBProfileRef == NULL)
2228     {
2229         CMProfileLocation loc;
2230
2231         loc.locType = cmPathBasedProfile;
2232         strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
2233
2234         verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
2235     }
2236
2237     // clone the profile reference so that the caller has their own reference, not our cached one
2238     if (cachedRGBProfileRef)
2239         CMCloneProfileRef(cachedRGBProfileRef);
2240
2241     return cachedRGBProfileRef;
2242 }
2243
2244 /*
2245     Return the generic RGB color space. This is a 'get' function and the caller should
2246     not release the returned value unless the caller retains it first. Usually callers
2247     of this routine will immediately use the returned colorspace with CoreGraphics
2248     so they typically do not need to retain it themselves.
2249
2250     This function creates the generic RGB color space once and hangs onto it so it can
2251     return it whenever this function is called.
2252 */
2253
2254 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
2255 {
2256     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
2257
2258     if (genericRGBColorSpace == NULL)
2259     {
2260         if ( UMAGetSystemVersion() >= 0x1040 )
2261         {
2262             genericRGBColorSpace.Set( CGColorSpaceCreateWithName( CFSTR("kCGColorSpaceGenericRGB") ) );
2263         }
2264         else
2265         {
2266             CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
2267
2268             if (genericRGBProfile)
2269             {
2270                 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) );
2271
2272                 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") );
2273
2274                 // we opened the profile so it is up to us to close it
2275                 CMCloseProfile(genericRGBProfile);
2276             }
2277         }
2278     }
2279
2280     return genericRGBColorSpace;
2281 }
2282 #endif
2283
2284 #ifndef __LP64__
2285
2286 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
2287 {
2288     ::GetPort( &m_port );
2289     ::SetPort( port );
2290 }
2291
2292 wxMacPortSaver::~wxMacPortSaver()
2293 {
2294     ::SetPort( m_port );
2295 }
2296 #endif
2297
2298 void wxMacGlobalToLocal( WindowRef window , Point*pt )
2299 {
2300 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4
2301     HIPoint p = CGPointMake( pt->h, pt->v );
2302     HIViewRef contentView ;
2303     // TODO check toolbar offset
2304     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
2305     HIPointConvert( &p, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceView, contentView );
2306     pt->h = p.x;
2307     pt->v = p.y;
2308 #else
2309     QDGlobalToLocalPoint( GetWindowPort(window), pt ) ;
2310 #endif
2311 }
2312
2313 void wxMacLocalToGlobal( WindowRef window , Point*pt )
2314 {
2315 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4
2316     HIPoint p = CGPointMake( pt->h, pt->v );
2317     HIViewRef contentView ;
2318     // TODO check toolbar offset
2319     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
2320     HIPointConvert( &p, kHICoordSpaceView, contentView, kHICoordSpace72DPIGlobal, NULL );
2321     pt->h = p.x;
2322     pt->v = p.y;
2323 #else
2324     QDLocalToGlobalPoint( GetWindowPort(window), pt ) ;
2325 #endif
2326 }
2327
2328 #endif // wxUSE_GUI