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 #ifndef __LP64__
 647     ControlFontStyleRec fontStyle;
 648     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 649     {
 650         switch ( font.MacGetThemeFontID() )
 651         {
 652             case kThemeSmallSystemFont :
 653                 fontStyle.font = kControlFontSmallSystemFont;
 654                 break;
 655
 656             case 109 : // mini font
 657                 fontStyle.font = -5;
 658                 break;
 659
 660             case kThemeSystemFont :
 661                 fontStyle.font = kControlFontBigSystemFont;
 662                 break;
 663
 664             default :
 665                 fontStyle.font = kControlFontBigSystemFont;
 666                 break;
 667         }
 668
 669         fontStyle.flags = kControlUseFontMask;
 670     }
 671     else
 672     {
 673         fontStyle.font = font.MacGetFontNum();
 674         fontStyle.style = font.MacGetFontStyle();
 675         fontStyle.size = font.MacGetFontSize();
 676         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
 677     }
 678
 679     fontStyle.just = teJustLeft;
 680     fontStyle.flags |= kControlUseJustMask;
 681     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
 682         fontStyle.just = teJustCenter;
 683     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
 684         fontStyle.just = teJustRight;
 685
 686
 687     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
 688     // won't get grayed out by the system anymore
 689
 690     if ( foreground != *wxBLACK )
 691     {
 692         foreground.GetRGBColor( &fontStyle.foreColor );
 693         fontStyle.flags |= kControlUseForeColorMask;
 694     }
 695
 696     ::SetControlFontStyle( m_controlRef , &fontStyle );
 697 #endif
 698 }
 699
 700 void wxMacControl::SetBackgroundColour( const wxColour &WXUNUSED(col) )
 701 {
 702     // TODO
 703     // setting up a color proc is not recommended anymore
 704 }
 705
 706 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
 707 {
 708     ::SetControl32BitMinimum( m_controlRef , minimum );
 709     ::SetControl32BitMaximum( m_controlRef , maximum );
 710 }
 711
 712 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
 713 {
 714 #ifndef __LP64__
 715     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
 716 #else
 717     return 0;
 718 #endif
 719 }
 720
 721 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
 722 {
 723     SetControlAction( m_controlRef , actionProc );
 724 }
 725
 726 void wxMacControl::SetViewSize( SInt32 viewSize )
 727 {
 728     SetControlViewSize(m_controlRef , viewSize );
 729 }
 730
 731 SInt32 wxMacControl::GetViewSize() const
 732 {
 733     return GetControlViewSize( m_controlRef );
 734 }
 735
 736 bool wxMacControl::IsVisible() const
 737 {
 738     return IsControlVisible( m_controlRef );
 739 }
 740
 741 void wxMacControl::SetVisibility( bool visible , bool redraw )
 742 {
 743     SetControlVisibility( m_controlRef , visible , redraw );
 744 }
 745
 746 bool wxMacControl::IsEnabled() const
 747 {
 748     return IsControlEnabled( m_controlRef );
 749 }
 750
 751 bool wxMacControl::IsActive() const
 752 {
 753     return IsControlActive( m_controlRef );
 754 }
 755
 756 void wxMacControl::Enable( bool enable )
 757 {
 758     if ( enable )
 759         EnableControl( m_controlRef );
 760     else
 761         DisableControl( m_controlRef );
 762 }
 763
 764 void wxMacControl::SetDrawingEnabled( bool enable )
 765 {
 766     HIViewSetDrawingEnabled( m_controlRef , enable );
 767 }
 768
 769 bool wxMacControl::GetNeedsDisplay() const
 770 {
 771     return HIViewGetNeedsDisplay( m_controlRef );
 772 }
 773
 774 void wxMacControl::SetNeedsDisplay( RgnHandle where )
 775 {
 776     if ( !IsVisible() )
 777         return;
 778
 779     HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
 780 }
 781
 782 void wxMacControl::SetNeedsDisplay( Rect* where )
 783 {
 784     if ( !IsVisible() )
 785         return;
 786
 787     if ( where != NULL )
 788     {
 789         RgnHandle update = NewRgn();
 790         RectRgn( update , where );
 791         HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
 792         DisposeRgn( update );
 793     }
 794     else
 795         HIViewSetNeedsDisplay( m_controlRef , true );
 796 }
 797
 798 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
 799 {
 800     HIPoint hiPoint;
 801
 802     hiPoint.x = pt->x;
 803     hiPoint.y = pt->y;
 804     HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  );
 805     pt->x = (int)hiPoint.x;
 806     pt->y = (int)hiPoint.y;
 807 }
 808
 809 void wxMacControl::SetRect( Rect *r )
 810 {
 811         //A HIRect is actually a CGRect on OSX - which consists of two structures -
 812         //CGPoint and CGSize, which have two floats each
 813         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
 814         HIViewSetFrame ( m_controlRef , &hir );
 815         // eventuall we might have to do a SetVisibility( false , true );
 816         // before and a SetVisibility( true , true ); after
 817 }
 818
 819 void wxMacControl::GetRect( Rect *r )
 820 {
 821     GetControlBounds( m_controlRef , r );
 822 }
 823
 824 void wxMacControl::GetRectInWindowCoords( Rect *r )
 825 {
 826     UMAGetControlBoundsInWindowCoords( m_controlRef , r );
 827 }
 828
 829 void wxMacControl::GetBestRect( Rect *r )
 830 {
 831     short   baselineoffset;
 832
 833     GetBestControlRect( m_controlRef , r , &baselineoffset );
 834 }
 835
 836 void wxMacControl::SetLabel( const wxString &title )
 837 {
 838     wxFontEncoding encoding;
 839
 840     if ( m_font.Ok() )
 841         encoding = m_font.GetEncoding();
 842     else
 843         encoding = wxFont::GetDefaultEncoding();
 844
 845     SetControlTitleWithCFString( m_controlRef , wxMacCFStringHolder( title , encoding ) );
 846 }
 847
 848 void wxMacControl::GetFeatures( UInt32 * features )
 849 {
 850     GetControlFeatures( m_controlRef , features );
 851 }
 852
 853 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
 854 {
 855     OSStatus err = GetControlRegion( m_controlRef , partCode , region );
 856     return err;
 857 }
 858
 859 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
 860 {
 861     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
 862        (other != NULL) ? other->m_controlRef : NULL);
 863 }
 864
 865 // SetNeedsDisplay would not invalidate the children
 866 static void InvalidateControlAndChildren( HIViewRef control )
 867 {
 868     HIViewSetNeedsDisplay( control , true );
 869     UInt16 childrenCount = 0;
 870     OSStatus err = CountSubControls( control , &childrenCount );
 871     if ( err == errControlIsNotEmbedder )
 872         return;
 873
 874     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
 875
 876     for ( UInt16 i = childrenCount; i >=1; --i )
 877     {
 878         HIViewRef child;
 879
 880         err = GetIndexedSubControl( control , i , & child );
 881         if ( err == errControlIsNotEmbedder )
 882             return;
 883
 884         InvalidateControlAndChildren( child );
 885     }
 886 }
 887
 888 void wxMacControl::InvalidateWithChildren()
 889 {
 890     InvalidateControlAndChildren( m_controlRef );
 891 }
 892
 893 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
 894 {
 895     wxASSERT( r != NULL );
 896
 897     HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
 898     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
 899 }
 900
 901 OSType wxMacCreator = 'WXMC';
 902 OSType wxMacControlProperty = 'MCCT';
 903
 904 void wxMacControl::SetReferenceInNativeControl()
 905 {
 906     void * data = this;
 907     verify_noerr( SetControlProperty ( m_controlRef ,
 908         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
 909 }
 910
 911 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
 912 {
 913     wxMacControl* ctl = NULL;
 914     ByteCount actualSize;
 915     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
 916         &actualSize , &ctl ) == noErr )
 917     {
 918         return ctl;
 919     }
 920     return NULL;
 921 }
 922
 923 // ============================================================================
 924 // DataBrowser Wrapper
 925 // ============================================================================
 926 //
 927 // basing on DataBrowserItemIDs
 928 //
 929
 930 IMPLEMENT_ABSTRACT_CLASS( wxMacDataBrowserControl , wxMacControl )
 931
 932 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
 933     ControlRef browser,
 934     DataBrowserItemID itemID,
 935     DataBrowserItemNotification message,
 936     DataBrowserItemDataRef itemData )
 937 {
 938     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
 939     if ( ctl != 0 )
 940     {
 941         ctl->ItemNotification(itemID, message, itemData);
 942     }
 943 }
 944
 945 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
 946     ControlRef browser,
 947     DataBrowserItemID itemID,
 948     DataBrowserPropertyID property,
 949     DataBrowserItemDataRef itemData,
 950     Boolean changeValue )
 951 {
 952     OSStatus err = errDataBrowserPropertyNotSupported;
 953     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
 954     if ( ctl != 0 )
 955     {
 956         err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
 957     }
 958     return err;
 959 }
 960
 961 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
 962     ControlRef browser,
 963     DataBrowserItemID itemOneID,
 964     DataBrowserItemID itemTwoID,
 965     DataBrowserPropertyID sortProperty)
 966 {
 967     wxMacDataBrowserControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserControl);
 968     if ( ctl != 0 )
 969     {
 970         return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
 971     }
 972     return false;
 973 }
 974
 975 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
 976 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
 977 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
 978
 979 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer,
 980                                                   const wxPoint& pos,
 981                                                   const wxSize& size,
 982                                                   long WXUNUSED(style))
 983                        : wxMacControl( peer )
 984 {
 985     Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
 986     OSStatus err = ::CreateDataBrowserControl(
 987         MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
 988         &bounds, kDataBrowserListView, &m_controlRef );
 989     SetReferenceInNativeControl();
 990     verify_noerr( err );
 991     if ( gDataBrowserItemCompareUPP == NULL )
 992         gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
 993     if ( gDataBrowserItemDataUPP == NULL )
 994         gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
 995     if ( gDataBrowserItemNotificationUPP == NULL )
 996     {
 997         gDataBrowserItemNotificationUPP =
 998             (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
 999     }
1000
1001     DataBrowserCallbacks callbacks;
1002     InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1003
1004     callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1005     callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1006     callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1007     SetCallbacks( &callbacks );
1008
1009 }
1010
1011 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1012     Boolean recurse,
1013     DataBrowserItemState state,
1014     ItemCount *numItems) const
1015 {
1016     return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1017 }
1018
1019 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1020     Boolean recurse,
1021     DataBrowserItemState state,
1022     Handle items) const
1023 {
1024     return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1025 }
1026
1027 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1028 {
1029     return SetDataBrowserSelectionFlags( m_controlRef, options );
1030 }
1031
1032 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1033         DataBrowserTableViewColumnIndex position )
1034 {
1035     return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1036 }
1037
1038 OSStatus wxMacDataBrowserControl::GetColumnIDFromIndex( DataBrowserTableViewColumnIndex position, DataBrowserTableViewColumnID* id ){
1039     return GetDataBrowserTableViewColumnProperty( m_controlRef, position, id );
1040 }
1041
1042 OSStatus wxMacDataBrowserControl::RemoveColumn( DataBrowserTableViewColumnIndex position )
1043 {
1044     DataBrowserTableViewColumnID id;
1045     GetColumnIDFromIndex( position, &id );
1046     return RemoveDataBrowserTableViewColumn( m_controlRef, id );
1047 }
1048
1049 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1050 {
1051     return AutoSizeDataBrowserListViewColumns(m_controlRef);
1052 }
1053
1054 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1055 {
1056     return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1057 }
1058
1059 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1060 {
1061     return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1062 }
1063
1064 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1065 {
1066     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1067 }
1068
1069 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1070 {
1071     return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1072 }
1073
1074 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1075 {
1076     return SetDataBrowserCallbacks( m_controlRef, callbacks );
1077 }
1078
1079 OSStatus wxMacDataBrowserControl::UpdateItems(
1080     DataBrowserItemID container,
1081     UInt32 numItems,
1082     const DataBrowserItemID *items,
1083     DataBrowserPropertyID preSortProperty,
1084     DataBrowserPropertyID propertyID ) const
1085 {
1086     return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1087 }
1088
1089 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1090 {
1091     return IsDataBrowserItemSelected( m_controlRef, item );
1092 }
1093
1094 OSStatus wxMacDataBrowserControl::AddItems(
1095     DataBrowserItemID container,
1096     UInt32 numItems,
1097     const DataBrowserItemID *items,
1098     DataBrowserPropertyID preSortProperty )
1099 {
1100     return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1101 }
1102
1103 OSStatus wxMacDataBrowserControl::RemoveItems(
1104     DataBrowserItemID container,
1105     UInt32 numItems,
1106     const DataBrowserItemID *items,
1107     DataBrowserPropertyID preSortProperty )
1108 {
1109     return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1110 }
1111
1112 OSStatus wxMacDataBrowserControl::RevealItem(
1113     DataBrowserItemID item,
1114     DataBrowserPropertyID propertyID,
1115     DataBrowserRevealOptions options ) const
1116 {
1117     return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1118 }
1119
1120 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1121     UInt32 numItems,
1122     const DataBrowserItemID *items,
1123     DataBrowserSetOption operation )
1124 {
1125     return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1126 }
1127
1128 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1129 {
1130     return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1131 }
1132
1133 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1134 {
1135     return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1136 }
1137
1138 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1139 {
1140     return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1141 }
1142
1143 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1144 {
1145     return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1146 }
1147
1148 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1149 {
1150     return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1151 }
1152
1153 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1154 {
1155     return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1156 }
1157
1158 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1159 {
1160     return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1161 }
1162
1163 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1164 {
1165     return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1166 }
1167
1168 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1169 {
1170     return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1171 }
1172
1173 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1174 {
1175     return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1176 }
1177
1178 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1179 {
1180     return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1181 }
1182
1183 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1184 {
1185     return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1186 }
1187
1188 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1189     DataBrowserTableViewColumnIndex *position) const
1190 {
1191     return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1192 }
1193
1194 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, DataBrowserTableViewColumnIndex position)
1195 {
1196     return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1197 }
1198
1199 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1200 {
1201     return GetDataBrowserScrollPosition( m_controlRef , top , left );
1202 }
1203
1204 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1205 {
1206     return SetDataBrowserScrollPosition( m_controlRef , top , left );
1207 }
1208
1209 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1210 {
1211     return GetDataBrowserSortProperty( m_controlRef , column );
1212 }
1213
1214 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1215 {
1216     return SetDataBrowserSortProperty( m_controlRef , column );
1217 }
1218
1219 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1220 {
1221     return GetDataBrowserSortOrder( m_controlRef , order );
1222 }
1223
1224 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1225 {
1226     return SetDataBrowserSortOrder( m_controlRef , order );
1227 }
1228
1229 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1230     DataBrowserPropertyFlags *flags ) const
1231 {
1232     return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1233 }
1234
1235 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1236     DataBrowserPropertyFlags flags )
1237 {
1238     return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1239 }
1240
1241 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1242     DataBrowserListViewHeaderDesc *desc ) const
1243 {
1244     return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1245 }
1246
1247 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1248     DataBrowserListViewHeaderDesc *desc )
1249 {
1250     return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1251 }
1252
1253 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1254     Boolean expandableRows )
1255 {
1256     return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1257 }
1258
1259 // ============================================================================
1260 // Higher-level Databrowser
1261 // ============================================================================
1262 //
1263 // basing on data item objects
1264 //
1265
1266 wxMacDataItem::wxMacDataItem()
1267 {
1268     m_data = NULL;
1269
1270     m_order = 0;
1271     m_colId = kTextColumnId; // for compat with existing wx*ListBox impls.
1272 }
1273
1274 wxMacDataItem::~wxMacDataItem()
1275 {
1276 }
1277
1278 void wxMacDataItem::SetOrder( SInt32 order )
1279 {
1280     m_order = order;
1281 }
1282
1283 SInt32 wxMacDataItem::GetOrder() const
1284 {
1285     return m_order;
1286 }
1287
1288 void wxMacDataItem::SetData( void* data)
1289 {
1290     m_data = data;
1291 }
1292
1293 void* wxMacDataItem::GetData() const
1294 {
1295     return m_data;
1296 }
1297
1298 short wxMacDataItem::GetColumn()
1299 {
1300     return m_colId;
1301 }
1302
1303 void wxMacDataItem::SetColumn( short col )
1304 {
1305     m_colId = col;
1306 }
1307
1308 void wxMacDataItem::SetLabel( const wxString& str)
1309 {
1310     m_label = str;
1311     m_cfLabel.Assign( str , wxLocale::GetSystemEncoding());
1312 }
1313
1314 const wxString& wxMacDataItem::GetLabel() const
1315 {
1316     return m_label;
1317 }
1318
1319 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1320     const wxMacDataItem* rhs,
1321     DataBrowserPropertyID sortProperty) const
1322 {
1323     const wxMacDataItem* otherItem = wx_const_cast(wxMacDataItem*,rhs);
1324     bool retval = false;
1325
1326     if ( sortProperty == m_colId ){
1327         retval = m_label.CmpNoCase( otherItem->m_label) < 0;
1328     }
1329
1330     else if ( sortProperty == kNumericOrderColumnId )
1331         retval = m_order < otherItem->m_order;
1332
1333     return retval;
1334 }
1335
1336 OSStatus wxMacDataItem::GetSetData( wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1337     DataBrowserPropertyID property,
1338     DataBrowserItemDataRef itemData,
1339     bool changeValue )
1340 {
1341     OSStatus err = errDataBrowserPropertyNotSupported;
1342     if ( !changeValue )
1343     {
1344         if ( property == m_colId ){
1345             err = ::SetDataBrowserItemDataText( itemData, m_cfLabel );
1346             err = noErr;
1347         }
1348         else if ( property == kNumericOrderColumnId ){
1349             err = ::SetDataBrowserItemDataValue( itemData, m_order );
1350             err = noErr;
1351         }
1352         else{
1353         }
1354     }
1355     else
1356     {
1357         switch (property)
1358         {
1359             // no editable props here
1360             default:
1361                 break;
1362         }
1363     }
1364
1365     return err;
1366 }
1367
1368 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *WXUNUSED(owner) ,
1369     DataBrowserItemNotification WXUNUSED(message),
1370     DataBrowserItemDataRef WXUNUSED(itemData) ) const
1371 {
1372 }
1373
1374 IMPLEMENT_DYNAMIC_CLASS( wxMacDataItemBrowserControl , wxMacDataBrowserControl )
1375
1376 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1377     wxMacDataBrowserControl( peer, pos, size, style )
1378 {
1379     m_suppressSelection = false;
1380     m_sortOrder = SortOrder_None;
1381     m_clientDataItemsType = wxClientData_None;
1382 }
1383
1384 wxMacDataItem* wxMacDataItemBrowserControl::CreateItem()
1385 {
1386     return new wxMacDataItem();
1387 }
1388
1389 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1390 {
1391     m_former = browser->SuppressSelection(true);
1392     m_browser = browser;
1393 }
1394
1395 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1396 {
1397     m_browser->SuppressSelection(m_former);
1398 }
1399
1400 bool  wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1401 {
1402     bool former = m_suppressSelection;
1403     m_suppressSelection = suppress;
1404
1405     return former;
1406 }
1407
1408 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1409     DataBrowserItemID itemTwoID,
1410     DataBrowserPropertyID sortProperty)
1411 {
1412     wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1413     wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1414     return CompareItems( itemOne , itemTwo , sortProperty );
1415 }
1416
1417 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem*  itemOne,
1418     const wxMacDataItem*  itemTwo,
1419     DataBrowserPropertyID sortProperty)
1420 {
1421     Boolean retval = false;
1422     if ( itemOne != NULL )
1423         retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1424     return retval;
1425 }
1426
1427 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1428     DataBrowserItemID itemID,
1429     DataBrowserPropertyID property,
1430     DataBrowserItemDataRef itemData,
1431     Boolean changeValue )
1432 {
1433     wxMacDataItem* item = (wxMacDataItem*) itemID;
1434     return GetSetItemData(item, property, itemData , changeValue );
1435 }
1436
1437 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1438     wxMacDataItem* item,
1439     DataBrowserPropertyID property,
1440     DataBrowserItemDataRef itemData,
1441     Boolean changeValue )
1442 {
1443     OSStatus err = errDataBrowserPropertyNotSupported;
1444     switch( property )
1445     {
1446         case kDataBrowserContainerIsClosableProperty :
1447         case kDataBrowserContainerIsSortableProperty :
1448         case kDataBrowserContainerIsOpenableProperty :
1449             // right now default behaviour on these
1450             break;
1451         default :
1452
1453             if ( item != NULL ){
1454                 err = item->GetSetData( this, property , itemData , changeValue );
1455             }
1456             break;
1457
1458     }
1459     return err;
1460 }
1461
1462 void wxMacDataItemBrowserControl::ItemNotification(
1463     DataBrowserItemID itemID,
1464     DataBrowserItemNotification message,
1465     DataBrowserItemDataRef itemData)
1466 {
1467     wxMacDataItem* item = (wxMacDataItem*) itemID;
1468     ItemNotification( item , message, itemData);
1469 }
1470
1471 void wxMacDataItemBrowserControl::ItemNotification(
1472     const wxMacDataItem* item,
1473     DataBrowserItemNotification message,
1474     DataBrowserItemDataRef itemData)
1475 {
1476     if (item != NULL)
1477         item->Notification( this, message, itemData);
1478 }
1479
1480 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1481         bool recurse , DataBrowserItemState state) const
1482 {
1483     ItemCount numItems = 0;
1484     verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1485         recurse, state, &numItems ) );
1486     return numItems;
1487 }
1488
1489 unsigned int wxMacDataItemBrowserControl::GetSelectedItemCount( const wxMacDataItem* container,
1490         bool recurse ) const
1491 {
1492     return GetItemCount( container, recurse, kDataBrowserItemIsSelected );
1493
1494 }
1495
1496 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1497     bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1498 {
1499     Handle handle = NewHandle(0);
1500     verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1501         recurse , state, handle) );
1502
1503     int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1504     HLock( handle );
1505     wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1506     for ( int i = 0; i < itemCount; ++i)
1507     {
1508         items.Add(itemsArray[i]);
1509     }
1510     HUnlock( handle );
1511     DisposeHandle( handle );
1512 }
1513
1514 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1515 {
1516     DataBrowserTableViewRowIndex row;
1517     OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1518     wxASSERT( err == noErr);
1519     return row;
1520 }
1521
1522 wxMacDataItem*  wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1523 {
1524     DataBrowserItemID id;
1525     OSStatus err =  GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1526     wxASSERT( err == noErr);
1527     return (wxMacDataItem*) id;
1528 }
1529
1530 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1531         const wxMacDataItem *item , DataBrowserPropertyID property) const
1532 {
1533     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1534         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1535 }
1536
1537 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1538         wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1539 {
1540     unsigned int noItems = itemArray.GetCount();
1541     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1542     for ( unsigned int i = 0; i < noItems; ++i )
1543         items[i] = (DataBrowserItemID) itemArray[i];
1544
1545     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1546         items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1547     delete [] items;
1548 }
1549
1550 void wxMacDataItemBrowserControl::InsertColumn(int colId, DataBrowserPropertyType colType,
1551                                             const wxString& title, SInt16 just, int defaultWidth)
1552 {
1553     DataBrowserListViewColumnDesc columnDesc;
1554     columnDesc.headerBtnDesc.titleOffset = 0;
1555     columnDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
1556
1557     columnDesc.headerBtnDesc.btnFontStyle.flags =
1558         kControlUseFontMask | kControlUseJustMask;
1559
1560     columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
1561     columnDesc.headerBtnDesc.btnFontStyle.just = just;
1562     columnDesc.headerBtnDesc.btnFontStyle.font = kControlFontViewSystemFont;
1563     columnDesc.headerBtnDesc.btnFontStyle.style = normal;
1564
1565     // TODO: Why is m_font not defined when we enter wxLC_LIST mode, but is
1566     // defined for other modes?
1567     wxFontEncoding enc;
1568     if ( m_font.Ok() )
1569         enc = m_font.GetEncoding();
1570     else
1571         enc = wxLocale::GetSystemEncoding();
1572     wxMacCFStringHolder cfTitle;
1573     cfTitle.Assign( title, enc );
1574     columnDesc.headerBtnDesc.titleString = cfTitle;
1575
1576     columnDesc.headerBtnDesc.minimumWidth = 0;
1577     columnDesc.headerBtnDesc.maximumWidth = 30000;
1578
1579     columnDesc.propertyDesc.propertyID = (kMinColumnId + colId);
1580     columnDesc.propertyDesc.propertyType = colType;
1581     columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewSortableColumn;
1582     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn;
1583     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewNoGapForIconInHeaderButton;
1584
1585     verify_noerr( AddColumn( &columnDesc, kDataBrowserListViewAppendColumn ) );
1586
1587     if (defaultWidth > 0){
1588         SetColumnWidth(colId, defaultWidth);
1589     }
1590
1591 }
1592
1593 void wxMacDataItemBrowserControl::SetColumnWidth(int colId, int width)
1594 {
1595     DataBrowserPropertyID id;
1596     GetColumnIDFromIndex(colId, &id);
1597     verify_noerr( wxMacDataBrowserControl::SetColumnWidth(id, width));
1598 }
1599
1600 int wxMacDataItemBrowserControl::GetColumnWidth(int colId)
1601 {
1602     DataBrowserPropertyID id;
1603     GetColumnIDFromIndex(colId, &id);
1604     UInt16 result;
1605     verify_noerr( wxMacDataBrowserControl::GetColumnWidth(id, &result));
1606     return result;
1607 }
1608
1609 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1610 {
1611     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1612         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1613 }
1614
1615 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1616 {
1617     unsigned int noItems = itemArray.GetCount();
1618     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1619     for ( unsigned int i = 0; i < noItems; ++i )
1620         items[i] = (DataBrowserItemID) itemArray[i];
1621
1622     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1623         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1624     delete [] items;
1625 }
1626
1627 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1628 {
1629     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1630         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty );
1631     verify_noerr( err );
1632 }
1633
1634 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1635 {
1636     unsigned int noItems = itemArray.GetCount();
1637     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1638     for ( unsigned int i = 0; i < noItems; ++i )
1639         items[i] = (DataBrowserItemID) itemArray[i];
1640
1641     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1642         (DataBrowserItemID*) items, kDataBrowserItemNoProperty );
1643     verify_noerr( err );
1644     delete [] items;
1645 }
1646
1647 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1648 {
1649     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1650     verify_noerr( err );
1651 }
1652
1653 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1654 {
1655     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1656 }
1657
1658 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1659 {
1660     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1661 }
1662
1663 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1664 {
1665     unsigned int noItems = itemArray.GetCount();
1666     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1667     for ( unsigned int i = 0; i < noItems; ++i )
1668         items[i] = (DataBrowserItemID) itemArray[i];
1669
1670     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
1671     delete [] items;
1672 }
1673
1674 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
1675 {
1676     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
1677 }
1678
1679 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
1680 {
1681     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
1682 }
1683
1684 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
1685 {
1686     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
1687 }
1688
1689 wxClientDataType wxMacDataItemBrowserControl::GetClientDataType() const
1690 {
1691      return m_clientDataItemsType;
1692 }
1693 void wxMacDataItemBrowserControl::SetClientDataType(wxClientDataType clientDataItemsType)
1694 {
1695     m_clientDataItemsType = clientDataItemsType;
1696 }
1697
1698 unsigned int wxMacDataItemBrowserControl::MacGetCount() const
1699 {
1700     return GetItemCount(wxMacDataBrowserRootContainer,false,kDataBrowserItemAnyState);
1701 }
1702
1703 void wxMacDataItemBrowserControl::MacDelete( unsigned int n )
1704 {
1705     wxMacDataItem* item = (wxMacDataItem*)GetItemFromLine( n );
1706     RemoveItem( wxMacDataBrowserRootContainer, item );
1707 }
1708
1709 void wxMacDataItemBrowserControl::MacInsert( unsigned int n,
1710                                              const wxArrayStringsAdapter& items,
1711                                              int column )
1712 {
1713     size_t itemsCount = items.GetCount();
1714     if ( itemsCount == 0 )
1715         return;
1716
1717     SInt32 frontLineOrder = 0;
1718
1719     if ( m_sortOrder == SortOrder_None )
1720     {
1721         // increase the order of the lines to be shifted
1722         unsigned int lines = MacGetCount();
1723         for ( unsigned int i = n; i < lines; ++i)
1724         {
1725             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
1726             iter->SetOrder( iter->GetOrder() + itemsCount );
1727         }
1728         if ( n > 0 )
1729         {
1730             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
1731             frontLineOrder = iter->GetOrder();
1732         }
1733     }
1734
1735     wxArrayMacDataItemPtr ids;
1736     ids.SetCount( itemsCount );
1737
1738     for ( unsigned int i = 0; i < itemsCount; ++i )
1739     {
1740         wxMacDataItem* item = CreateItem();
1741         item->SetLabel( items[i]);
1742         if ( column != -1 )
1743             item->SetColumn( kMinColumnId + column );
1744
1745         if ( m_sortOrder == SortOrder_None )
1746             item->SetOrder( frontLineOrder + 1 + i );
1747
1748         ids[i] = item;
1749     }
1750
1751     AddItems( wxMacDataBrowserRootContainer, ids );
1752 }
1753
1754 int wxMacDataItemBrowserControl::MacAppend( const wxString& text)
1755 {
1756     wxMacDataItem* item = CreateItem();
1757     item->SetLabel( text );
1758     if ( m_sortOrder == SortOrder_None )
1759     {
1760         unsigned int lines = MacGetCount();
1761         if ( lines == 0 )
1762             item->SetOrder( 1 );
1763         else
1764         {
1765             wxMacDataItem* frontItem = (wxMacDataItem*) GetItemFromLine(lines-1);
1766             item->SetOrder( frontItem->GetOrder() + 1 );
1767         }
1768     }
1769     AddItem( wxMacDataBrowserRootContainer, item );
1770
1771     return GetLineFromItem(item);
1772 }
1773
1774 void wxMacDataItemBrowserControl::MacClear()
1775 {
1776     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1777     RemoveAllItems(wxMacDataBrowserRootContainer);
1778 }
1779
1780 void wxMacDataItemBrowserControl::MacDeselectAll()
1781 {
1782     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1783     SetSelectedAllItems( kDataBrowserItemsRemove );
1784 }
1785
1786 void wxMacDataItemBrowserControl::MacSetSelection( unsigned int n, bool select, bool multi )
1787 {
1788     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
1789     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
1790
1791     if ( IsItemSelected( item ) != select )
1792     {
1793         if ( select )
1794             SetSelectedItem( item, multi ? kDataBrowserItemsAdd : kDataBrowserItemsAssign );
1795         else
1796             SetSelectedItem( item, kDataBrowserItemsRemove );
1797     }
1798
1799     MacScrollTo( n );
1800 }
1801
1802 bool wxMacDataItemBrowserControl::MacIsSelected( unsigned int n ) const
1803 {
1804     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
1805     return IsItemSelected( item );
1806 }
1807
1808 int wxMacDataItemBrowserControl::MacGetSelection() const
1809 {
1810     wxMacDataItemPtr first, last;
1811     GetSelectionAnchor( &first, &last );
1812
1813     if ( first != NULL )
1814     {
1815         return GetLineFromItem( first );
1816     }
1817
1818     return -1;
1819 }
1820
1821 int wxMacDataItemBrowserControl::MacGetSelections( wxArrayInt& aSelections ) const
1822 {
1823     aSelections.Empty();
1824     wxArrayMacDataItemPtr selectedItems;
1825     GetItems( wxMacDataBrowserRootContainer, false , kDataBrowserItemIsSelected, selectedItems);
1826
1827     int count = selectedItems.GetCount();
1828
1829     for ( int i = 0; i < count; ++i)
1830     {
1831         aSelections.Add(GetLineFromItem(selectedItems[i]));
1832     }
1833
1834     return count;
1835 }
1836
1837 void wxMacDataItemBrowserControl::MacSetString( unsigned int n, const wxString& text )
1838 {
1839     // as we don't store the strings we only have to issue a redraw
1840     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
1841     item->SetLabel( text );
1842     UpdateItem( wxMacDataBrowserRootContainer, item , kTextColumnId );
1843 }
1844
1845 wxString wxMacDataItemBrowserControl::MacGetString( unsigned int n ) const
1846 {
1847     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1848     return item->GetLabel();
1849 }
1850
1851 void wxMacDataItemBrowserControl::MacSetClientData( unsigned int n, void * data)
1852 {
1853     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
1854     item->SetData( data );
1855     // not displayed, therefore no Update infos to DataBrowser
1856 }
1857
1858 void * wxMacDataItemBrowserControl::MacGetClientData( unsigned int n) const
1859 {
1860     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1861     return item->GetData();
1862 }
1863
1864 void wxMacDataItemBrowserControl::MacScrollTo( unsigned int n )
1865 {
1866     UInt32 top , left ;
1867     GetScrollPosition( &top , &left ) ;
1868     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
1869
1870     UInt16 height ;
1871     GetRowHeight( (DataBrowserItemID) item , &height ) ;
1872     SetScrollPosition( n * ((UInt32)height) , left ) ;
1873
1874     RevealItem( item , kDataBrowserRevealWithoutSelecting );
1875 }
1876
1877
1878
1879 //
1880 // Tab Control
1881 //
1882
1883 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1884 {
1885     return ::SetTabEnabled( m_controlRef , tabNo , enable );
1886 }
1887
1888 #endif
1889
1890 //
1891 // Quartz Support
1892 //
1893
1894 /*
1895     Return the generic RGB color space. This is a 'get' function and the caller should
1896     not release the returned value unless the caller retains it first. Usually callers
1897     of this routine will immediately use the returned colorspace with CoreGraphics
1898     so they typically do not need to retain it themselves.
1899
1900     This function creates the generic RGB color space once and hangs onto it so it can
1901     return it whenever this function is called.
1902 */
1903
1904 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1905 {
1906     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
1907
1908     if (genericRGBColorSpace == NULL)
1909     {
1910         genericRGBColorSpace.Set( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ) );
1911     }
1912
1913     return genericRGBColorSpace;
1914 }
1915
1916 CGColorRef wxMacCreateCGColorFromHITheme( ThemeBrush brush )
1917 {
1918     CGColorRef color ;
1919     HIThemeBrushCreateCGColor( brush, &color );
1920     return color;
1921 }
1922
1923 #ifndef __LP64__
1924
1925 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
1926 {
1927     ::GetPort( &m_port );
1928     ::SetPort( port );
1929 }
1930
1931 wxMacPortSaver::~wxMacPortSaver()
1932 {
1933     ::SetPort( m_port );
1934 }
1935 #endif
1936
1937 #if wxMAC_USE_QUICKDRAW
1938
1939 void wxMacGlobalToLocal( WindowRef window , Point*pt )
1940 {
1941     HIPoint p = CGPointMake( pt->h, pt->v );
1942     HIViewRef contentView ;
1943     // TODO check toolbar offset
1944     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
1945     HIPointConvert( &p, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceView, contentView );
1946     pt->h = p.x;
1947     pt->v = p.y;
1948 }
1949
1950 void wxMacLocalToGlobal( WindowRef window , Point*pt )
1951 {
1952     HIPoint p = CGPointMake( pt->h, pt->v );
1953     HIViewRef contentView ;
1954     // TODO check toolbar offset
1955     HIViewFindByID( HIViewGetRoot( window ), kHIViewWindowContentID , &contentView) ;
1956     HIPointConvert( &p, kHICoordSpaceView, contentView, kHICoordSpace72DPIGlobal, NULL );
1957     pt->h = p.x;
1958     pt->v = p.y;
1959 }
1960 #endif
1961
1962 #endif // wxUSE_GUI
1963
1964 #if wxUSE_BASE
1965
1966 #endif