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 , wxMacCFStringHolder( 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.Assign( 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     wxMacCFStringHolder cfTitle;
1605     cfTitle.Assign( title, enc );
1606     columnDesc.headerBtnDesc.titleString = cfTitle;
1607
1608     columnDesc.headerBtnDesc.minimumWidth = 0;
1609     columnDesc.headerBtnDesc.maximumWidth = 30000;
1610
1611     columnDesc.propertyDesc.propertyID = (kMinColumnId + colId);
1612     columnDesc.propertyDesc.propertyType = colType;
1613     columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewSortableColumn;
1614     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn;
1615     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewNoGapForIconInHeaderButton;
1616
1617     verify_noerr( AddColumn( &columnDesc, kDataBrowserListViewAppendColumn ) );
1618
1619     if (defaultWidth > 0){
1620         SetColumnWidth(colId, defaultWidth);
1621     }
1622
1623 }
1624
1625 void wxMacDataItemBrowserControl::SetColumnWidth(int colId, int width)
1626 {
1627     DataBrowserPropertyID id;
1628     GetColumnIDFromIndex(colId, &id);
1629     verify_noerr( wxMacDataBrowserControl::SetColumnWidth(id, width));
1630 }
1631
1632 int wxMacDataItemBrowserControl::GetColumnWidth(int colId)
1633 {
1634     DataBrowserPropertyID id;
1635     GetColumnIDFromIndex(colId, &id);
1636     UInt16 result;
1637     verify_noerr( wxMacDataBrowserControl::GetColumnWidth(id, &result));
1638     return result;
1639 }
1640
1641 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1642 {
1643     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1644         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1645 }
1646
1647 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1648 {
1649     unsigned int noItems = itemArray.GetCount();
1650     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1651     for ( unsigned int i = 0; i < noItems; ++i )
1652         items[i] = (DataBrowserItemID) itemArray[i];
1653
1654     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1655         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1656     delete [] items;
1657 }
1658
1659 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1660 {
1661     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1662         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty );
1663     verify_noerr( err );
1664 }
1665
1666 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1667 {
1668     unsigned int noItems = itemArray.GetCount();
1669     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1670     for ( unsigned int i = 0; i < noItems; ++i )
1671         items[i] = (DataBrowserItemID) itemArray[i];
1672
1673     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1674         (DataBrowserItemID*) items, kDataBrowserItemNoProperty );
1675     verify_noerr( err );
1676     delete [] items;
1677 }
1678
1679 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1680 {
1681     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1682     verify_noerr( err );
1683 }
1684
1685 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1686 {
1687     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1688 }
1689
1690 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1691 {
1692     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1693 }
1694
1695 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1696 {
1697     unsigned int noItems = itemArray.GetCount();
1698     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1699     for ( unsigned int i = 0; i < noItems; ++i )
1700         items[i] = (DataBrowserItemID) itemArray[i];
1701
1702     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
1703     delete [] items;
1704 }
1705
1706 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
1707 {
1708     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
1709 }
1710
1711 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
1712 {
1713     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
1714 }
1715
1716 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
1717 {
1718     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
1719 }
1720
1721 wxClientDataType wxMacDataItemBrowserControl::GetClientDataType() const
1722 {
1723      return m_clientDataItemsType;
1724 }
1725 void wxMacDataItemBrowserControl::SetClientDataType(wxClientDataType clientDataItemsType)
1726 {
1727     m_clientDataItemsType = clientDataItemsType;
1728 }
1729
1730 unsigned int wxMacDataItemBrowserControl::MacGetCount() const
1731 {
1732     return GetItemCount(wxMacDataBrowserRootContainer,false,kDataBrowserItemAnyState);
1733 }
1734
1735 void wxMacDataItemBrowserControl::MacDelete( unsigned int n )
1736 {
1737     wxMacDataItem* item = (wxMacDataItem*)GetItemFromLine( n );
1738     RemoveItem( wxMacDataBrowserRootContainer, item );
1739 }
1740
1741 void wxMacDataItemBrowserControl::MacInsert( unsigned int n,
1742                                              const wxArrayStringsAdapter& items,
1743                                              int column )
1744 {
1745     size_t itemsCount = items.GetCount();
1746     if ( itemsCount == 0 )
1747         return;
1748
1749     SInt32 frontLineOrder = 0;
1750
1751     if ( m_sortOrder == SortOrder_None )
1752     {
1753         // increase the order of the lines to be shifted
1754         unsigned int lines = MacGetCount();
1755         for ( unsigned int i = n; i < lines; ++i)
1756         {
1757             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
1758             iter->SetOrder( iter->GetOrder() + itemsCount );
1759         }
1760         if ( n > 0 )
1761         {
1762             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
1763             frontLineOrder = iter->GetOrder();
1764         }
1765     }
1766
1767     wxArrayMacDataItemPtr ids;
1768     ids.SetCount( itemsCount );
1769
1770     for ( unsigned int i = 0; i < itemsCount; ++i )
1771     {
1772         wxMacDataItem* item = CreateItem();
1773         item->SetLabel( items[i]);
1774         if ( column != -1 )
1775             item->SetColumn( kMinColumnId + column );
1776
1777         if ( m_sortOrder == SortOrder_None )
1778             item->SetOrder( frontLineOrder + 1 + i );
1779
1780         ids[i] = item;
1781     }
1782
1783     AddItems( wxMacDataBrowserRootContainer, ids );
1784 }
1785
1786 int wxMacDataItemBrowserControl::MacAppend( const wxString& text)
1787 {
1788     wxMacDataItem* item = CreateItem();
1789     item->SetLabel( text );
1790     if ( m_sortOrder == SortOrder_None )
1791     {
1792         unsigned int lines = MacGetCount();
1793         if ( lines == 0 )
1794             item->SetOrder( 1 );
1795         else
1796         {
1797             wxMacDataItem* frontItem = (wxMacDataItem*) GetItemFromLine(lines-1);
1798             item->SetOrder( frontItem->GetOrder() + 1 );
1799         }
1800     }
1801     AddItem( wxMacDataBrowserRootContainer, item );
1802
1803     return GetLineFromItem(item);
1804 }
1805
1806 void wxMacDataItemBrowserControl::MacClear()
1807 {
1808     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1809     RemoveAllItems(wxMacDataBrowserRootContainer);
1810 }
1811
1812 void wxMacDataItemBrowserControl::MacDeselectAll()
1813 {
1814     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1815     SetSelectedAllItems( kDataBrowserItemsRemove );
1816 }
1817
1818 void wxMacDataItemBrowserControl::MacSetSelection( unsigned int n, bool select, bool multi )
1819 {
1820     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
1821     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1822
1823     if ( IsItemSelected( item ) != select )
1824     {
1825         if ( select )
1826             SetSelectedItem( item, multi ? kDataBrowserItemsAdd : kDataBrowserItemsAssign );
1827         else
1828             SetSelectedItem( item, kDataBrowserItemsRemove );
1829     }
1830
1831     MacScrollTo( n );
1832 }
1833
1834 bool wxMacDataItemBrowserControl::MacIsSelected( unsigned int n ) const
1835 {
1836     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
1837     return IsItemSelected( item );
1838 }
1839
1840 int wxMacDataItemBrowserControl::MacGetSelection() const
1841 {
1842     wxMacDataItemPtr first, last;
1843     GetSelectionAnchor( &first, &last );
1844
1845     if ( first != NULL )
1846     {
1847         return GetLineFromItem( first );
1848     }
1849
1850     return -1;
1851 }
1852
1853 int wxMacDataItemBrowserControl::MacGetSelections( wxArrayInt& aSelections ) const
1854 {
1855     aSelections.Empty();
1856     wxArrayMacDataItemPtr selectedItems;
1857     GetItems( wxMacDataBrowserRootContainer, false , kDataBrowserItemIsSelected, selectedItems);
1858
1859     int count = selectedItems.GetCount();
1860
1861     for ( int i = 0; i < count; ++i)
1862     {
1863         aSelections.Add(GetLineFromItem(selectedItems[i]));
1864     }
1865
1866     return count;
1867 }
1868
1869 void wxMacDataItemBrowserControl::MacSetString( unsigned int n, const wxString& text )
1870 {
1871     // as we don't store the strings we only have to issue a redraw
1872     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
1873     item->SetLabel( text );
1874     UpdateItem( wxMacDataBrowserRootContainer, item , kTextColumnId );
1875 }
1876
1877 wxString wxMacDataItemBrowserControl::MacGetString( unsigned int n ) const
1878 {
1879     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1880     return item->GetLabel();
1881 }
1882
1883 void wxMacDataItemBrowserControl::MacSetClientData( unsigned int n, void * data)
1884 {
1885     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
1886     item->SetData( data );
1887     // not displayed, therefore no Update infos to DataBrowser
1888 }
1889
1890 void * wxMacDataItemBrowserControl::MacGetClientData( unsigned int n) const
1891 {
1892     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1893     return item->GetData();
1894 }
1895
1896 void wxMacDataItemBrowserControl::MacScrollTo( unsigned int n )
1897 {
1898     UInt32 top , left ;
1899     GetScrollPosition( &top , &left ) ;
1900     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1901
1902     // there is a bug in RevealItem that leads to situations
1903     // in large lists, where the item does not get scrolled
1904     // into sight, so we do a pre-scroll if necessary
1905     UInt16 height ;
1906     GetRowHeight( (DataBrowserItemID) item , &height ) ;
1907     UInt32 linetop = n * ((UInt32) height );
1908     UInt32 linebottom = linetop + height;
1909     Rect rect ;
1910     GetRect( &rect );
1911
1912     if ( linetop < top || linebottom > (top + rect.bottom - rect.top ) )
1913         SetScrollPosition( wxMax( n-2, 0 ) * ((UInt32)height) , left ) ;
1914
1915     RevealItem( item , kDataBrowserRevealWithoutSelecting );
1916 }
1917
1918
1919
1920 //
1921 // Tab Control
1922 //
1923
1924 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1925 {
1926     return ::SetTabEnabled( m_controlRef , tabNo , enable );
1927 }
1928
1929 #endif
1930
1931 //
1932 // Quartz Support
1933 //
1934
1935 /*
1936     Return the generic RGB color space. This is a 'get' function and the caller should
1937     not release the returned value unless the caller retains it first. Usually callers
1938     of this routine will immediately use the returned colorspace with CoreGraphics
1939     so they typically do not need to retain it themselves.
1940
1941     This function creates the generic RGB color space once and hangs onto it so it can
1942     return it whenever this function is called.
1943 */
1944
1945 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1946 {
1947     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
1948
1949     if (genericRGBColorSpace == NULL)
1950     {
1951         genericRGBColorSpace.Set( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ) );
1952     }
1953
1954     return genericRGBColorSpace;
1955 }
1956
1957 CGColorRef wxMacCreateCGColorFromHITheme( ThemeBrush brush )
1958 {
1959     CGColorRef color ;
1960     HIThemeBrushCreateCGColor( brush, &color );
1961     return color;
1962 }
1963
1964 #if wxMAC_USE_QUICKDRAW
1965
1966 static inline void PointFromHIPoint(const HIPoint& p, Point *pt)
1967 {
1968     pt->h = wx_static_cast(short, p.x);
1969     pt->v = wx_static_cast(short, p.y);
1970 }
1971
1972 void wxMacGlobalToLocal( WindowRef window , Point*pt )
1973 {
1974     HIPoint p = CGPointMake( pt->h, pt->v );
1975     HIViewRef contentView ;
1976     // TODO check toolbar offset
1977     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
1978     HIPointConvert( &p, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceView, contentView );
1979     PointFromHIPoint(p, pt);
1980 }
1981
1982 void wxMacLocalToGlobal( WindowRef window , Point*pt )
1983 {
1984     HIPoint p = CGPointMake( pt->h, pt->v );
1985     HIViewRef contentView ;
1986     // TODO check toolbar offset
1987     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
1988     HIPointConvert( &p, kHICoordSpaceView, contentView, kHICoordSpace72DPIGlobal, NULL );
1989     PointFromHIPoint(p, pt);
1990 }
1991
1992 #endif // wxMAC_USE_QUICKDRAW
1993
1994 #endif // wxUSE_GUI
1995
1996 #if wxUSE_BASE
1997
1998 #endif