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