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