src/mac/carbon/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/utils.cpp
   3 // Purpose:     Various utilities
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     1998-01-01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #include "wx/utils.h"
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/intl.h"
  18     #include "wx/app.h"
  19     #if wxUSE_GUI
  20         #include "wx/toplevel.h"
  21         #include "wx/font.h"
  22     #endif
  23 #endif
  24
  25 #include "wx/apptrait.h"
  26
  27 #if wxUSE_GUI
  28     #include "wx/mac/uma.h"
  29 #endif
  30
  31 #include <ctype.h>
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <stdarg.h>
  37
  38 #include "MoreFilesX.h"
  39
  40 #ifndef __DARWIN__
  41     #include <Threads.h>
  42     #include <Sound.h>
  43 #endif
  44
  45 #if wxUSE_GUI
  46 #if TARGET_API_MAC_OSX
  47     #include <CoreServices/CoreServices.h>
  48 #else
  49     #include <DriverServices.h>
  50     #include <Multiprocessing.h>
  51 #endif
  52
  53 #ifdef __DARWIN__
  54     #include <Carbon/Carbon.h>
  55 #else
  56     #include <ATSUnicode.h>
  57     #include <TextCommon.h>
  58     #include <TextEncodingConverter.h>
  59 #endif
  60 #endif // wxUSE_GUI
  61
  62 #include "wx/mac/private.h"
  63
  64 #if defined(__MWERKS__) && wxUSE_UNICODE
  65 #if __MWERKS__ < 0x4100 || !defined(__DARWIN__)
  66     #include <wtime.h>
  67 #endif
  68 #endif
  69
  70 #if wxUSE_BASE
  71
  72 // our OS version is the same in non GUI and GUI cases
  73 wxOperatingSystemId wxGetOsVersion(int *majorVsn, int *minorVsn)
  74 {
  75     long theSystem;
  76     Gestalt(gestaltSystemVersion, &theSystem);
  77
  78     if ( majorVsn != NULL )
  79         *majorVsn = (theSystem >> 8);
  80
  81     if ( minorVsn != NULL )
  82         *minorVsn = (theSystem & 0xFF);
  83
  84 #if defined( __DARWIN__ )
  85     return wxOS_MAC_OSX_DARWIN;
  86 #else
  87     return wxOS_MAC_OS;
  88 #endif
  89 }
  90
  91 // ----------------------------------------------------------------------------
  92 // debugging support
  93 // ----------------------------------------------------------------------------
  94
  95 #if defined(__WXDEBUG__) && defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
  96
  97 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
  98
  99 #ifndef __MetroNubUtils__
 100 #include "MetroNubUtils.h"
 101 #endif
 102
 103 #ifndef __GESTALT__
 104 #include <Gestalt.h>
 105 #endif
 106
 107 #if TARGET_API_MAC_CARBON
 108
 109 #include <CodeFragments.h>
 110
 111 extern "C" long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
 112
 113 ProcPtr gCallUniversalProc_Proc = NULL;
 114
 115 #endif
 116
 117 static MetroNubUserEntryBlock*    gMetroNubEntry = NULL;
 118
 119 static long fRunOnce = false;
 120
 121
 122 Boolean IsMetroNubInstalled()
 123 {
 124     if (!fRunOnce)
 125     {
 126         long result, value;
 127
 128         fRunOnce = true;
 129         gMetroNubEntry = NULL;
 130
 131         if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
 132         {
 133             // look for MetroNub's Gestalt selector
 134             if (Gestalt(kMetroNubUserSignature, &result) == noErr)
 135             {
 136 #if TARGET_API_MAC_CARBON
 137                 if (gCallUniversalProc_Proc == NULL)
 138                 {
 139                     CFragConnectionID   connectionID;
 140                     Ptr                 mainAddress;
 141                     Str255              errorString;
 142                     ProcPtr             symbolAddress;
 143                     OSErr               err;
 144                     CFragSymbolClass    symbolClass;
 145
 146                     symbolAddress = NULL;
 147                     err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
 148                                            &connectionID, &mainAddress, errorString);
 149
 150                     if (err != noErr)
 151                     {
 152                         gCallUniversalProc_Proc = NULL;
 153                         goto end;
 154                     }
 155
 156                     err = FindSymbol(connectionID, "\pCallUniversalProc",
 157                                     (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
 158
 159                     if (err != noErr)
 160                     {
 161                         gCallUniversalProc_Proc = NULL;
 162                         goto end;
 163                     }
 164                 }
 165 #endif
 166
 167                 {
 168                     MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
 169
 170                     // make sure the version of the API is compatible
 171                     if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
 172                         kMetroNubUserAPIVersion <= block->apiHiVersion)
 173                     {
 174                         // success!
 175                         gMetroNubEntry = block;
 176                     }
 177                 }
 178             }
 179         }
 180     }
 181
 182 end:
 183
 184 #if TARGET_API_MAC_CARBON
 185     return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
 186 #else
 187     return (gMetroNubEntry != NULL);
 188 #endif
 189 }
 190
 191 Boolean IsMWDebuggerRunning()
 192 {
 193     if (IsMetroNubInstalled())
 194         return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
 195
 196     return false;
 197 }
 198
 199 Boolean AmIBeingMWDebugged()
 200 {
 201     if (IsMetroNubInstalled())
 202         return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
 203
 204     return false;
 205 }
 206
 207 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 208 {
 209     return IsMWDebuggerRunning() && AmIBeingMWDebugged();
 210 }
 211
 212 #else
 213
 214 extern bool WXDLLEXPORT wxIsDebuggerRunning()
 215 {
 216     return false;
 217 }
 218
 219 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
 220
 221
 222 #ifndef __DARWIN__
 223 // defined in unix/utilsunx.cpp for Mac OS X
 224
 225 // get full hostname (with domain name if possible)
 226 bool wxGetFullHostName(wxChar *buf, int maxSize)
 227 {
 228     return wxGetHostName(buf, maxSize);
 229 }
 230
 231 // Get user ID e.g. jacs
 232 bool wxGetUserId(wxChar *buf, int maxSize)
 233 {
 234     return wxGetUserName( buf , maxSize );
 235 }
 236
 237 const wxChar* wxGetHomeDir(wxString *pstr)
 238 {
 239     *pstr = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder );
 240     return pstr->c_str();
 241 }
 242
 243 // Get hostname only (without domain name)
 244 bool wxGetHostName(wxChar *buf, int maxSize)
 245 {
 246     // Gets Chooser name of user by examining a System resource.
 247     buf[0] = 0;
 248
 249     const short kComputerNameID = -16413;
 250
 251     short oldResFile = CurResFile();
 252     UseResFile(0);
 253     StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
 254     UseResFile(oldResFile);
 255
 256     if (chooserName && *chooserName)
 257     {
 258         HLock( (Handle) chooserName );
 259         wxString name = wxMacMakeStringFromPascal( *chooserName );
 260         HUnlock( (Handle) chooserName );
 261         ReleaseResource( (Handle) chooserName );
 262         wxStrncpy( buf , name , maxSize - 1 );
 263     }
 264
 265     return true;
 266 }
 267
 268 // Get user name e.g. Stefan Csomor
 269 bool wxGetUserName(wxChar *buf, int maxSize)
 270 {
 271     // Gets Chooser name of user by examining a System resource.
 272     buf[0] = 0;
 273
 274     const short kChooserNameID = -16096;
 275
 276     short oldResFile = CurResFile();
 277     UseResFile(0);
 278     StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
 279     UseResFile(oldResFile);
 280
 281     if (chooserName && *chooserName)
 282     {
 283         HLock( (Handle) chooserName );
 284         wxString name = wxMacMakeStringFromPascal( *chooserName );
 285         HUnlock( (Handle) chooserName );
 286         ReleaseResource( (Handle) chooserName );
 287         wxStrncpy( buf , name , maxSize - 1 );
 288     }
 289
 290     return true;
 291 }
 292
 293 int wxKill(long pid, wxSignal sig , wxKillError *rc, int flags)
 294 {
 295     // TODO
 296     return 0;
 297 }
 298
 299 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
 300 {
 301     // TODO : under classic there is no environement support, under X yes
 302     return false;
 303 }
 304
 305 // set the env var name to the given value, return true on success
 306 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
 307 {
 308     // TODO : under classic there is no environement support, under X yes
 309     return false;
 310 }
 311
 312 // Execute a program in an Interactive Shell
 313 bool wxShell(const wxString& command)
 314 {
 315     // TODO
 316     return false;
 317 }
 318
 319 // Shutdown or reboot the PC
 320 bool wxShutdown(wxShutdownFlags wFlags)
 321 {
 322     // TODO
 323     return false;
 324 }
 325
 326 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 327 wxMemorySize wxGetFreeMemory()
 328 {
 329     return (wxMemorySize)FreeMem();
 330 }
 331
 332 #ifndef __DARWIN__
 333
 334 void wxMicroSleep(unsigned long microseconds)
 335 {
 336     AbsoluteTime wakeup = AddDurationToAbsolute( microseconds * durationMicrosecond , UpTime());
 337     MPDelayUntil( & wakeup);
 338 }
 339
 340 void wxMilliSleep(unsigned long milliseconds)
 341 {
 342     AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime());
 343     MPDelayUntil( & wakeup);
 344 }
 345
 346 void wxSleep(int nSecs)
 347 {
 348     wxMilliSleep(1000*nSecs);
 349 }
 350
 351 #endif
 352
 353 // Consume all events until no more left
 354 void wxFlushEvents()
 355 {
 356 }
 357
 358 #endif // !__DARWIN__
 359
 360 // Emit a beeeeeep
 361 void wxBell()
 362 {
 363     SysBeep(30);
 364 }
 365
 366
 367 #endif // wxUSE_BASE
 368
 369 #if wxUSE_GUI
 370
 371 wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const
 372 {
 373     // We suppose that toolkit version is the same as OS version under Mac
 374     wxGetOsVersion(verMaj, verMin);
 375
 376     return wxPORT_MAC;
 377 }
 378
 379 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 380 #if wxUSE_RESOURCES
 381 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
 382 {
 383     // TODO
 384     return false;
 385 }
 386
 387 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 388 {
 389     wxString buf;
 390     buf.Printf(wxT("%.4f"), value);
 391
 392     return wxWriteResource(section, entry, buf, file);
 393 }
 394
 395 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 396 {
 397     wxString buf;
 398     buf.Printf(wxT("%ld"), value);
 399
 400     return wxWriteResource(section, entry, buf, file);
 401 }
 402
 403 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 404 {
 405     wxString buf;
 406     buf.Printf(wxT("%d"), value);
 407
 408     return wxWriteResource(section, entry, buf, file);
 409 }
 410
 411 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
 412 {
 413     // TODO
 414     return false;
 415 }
 416
 417 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
 418 {
 419     char *s = NULL;
 420     bool succ = wxGetResource(section, entry, (char **)&s, file);
 421     if (succ)
 422     {
 423         *value = (float)strtod(s, NULL);
 424         delete[] s;
 425     }
 426
 427     return succ;
 428 }
 429
 430 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
 431 {
 432     char *s = NULL;
 433     bool succ = wxGetResource(section, entry, (char **)&s, file);
 434     if (succ)
 435     {
 436         *value = strtol(s, NULL, 10);
 437         delete[] s;
 438     }
 439
 440     return succ;
 441 }
 442
 443 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 444 {
 445     char *s = NULL;
 446     bool succ = wxGetResource(section, entry, (char **)&s, file);
 447     if (succ)
 448     {
 449         *value = (int)strtol(s, NULL, 10);
 450         delete[] s;
 451     }
 452
 453     return succ;
 454 }
 455 #endif // wxUSE_RESOURCES
 456
 457 int gs_wxBusyCursorCount = 0;
 458 extern wxCursor    gMacCurrentCursor;
 459 wxCursor        gMacStoredActiveCursor;
 460
 461 // Set the cursor to the busy cursor for all windows
 462 void wxBeginBusyCursor(const wxCursor *cursor)
 463 {
 464     if (gs_wxBusyCursorCount++ == 0)
 465     {
 466         gMacStoredActiveCursor = gMacCurrentCursor;
 467         cursor->MacInstall();
 468     }
 469     //else: nothing to do, already set
 470 }
 471
 472 // Restore cursor to normal
 473 void wxEndBusyCursor()
 474 {
 475     wxCHECK_RET( gs_wxBusyCursorCount > 0,
 476         wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
 477
 478     if (--gs_wxBusyCursorCount == 0)
 479     {
 480         gMacStoredActiveCursor.MacInstall();
 481         gMacStoredActiveCursor = wxNullCursor;
 482     }
 483 }
 484
 485 // true if we're between the above two calls
 486 bool wxIsBusy()
 487 {
 488     return (gs_wxBusyCursorCount > 0);
 489 }
 490
 491 #endif // wxUSE_GUI
 492
 493 #if wxUSE_BASE
 494
 495 wxString wxMacFindFolderNoSeparator( short        vol,
 496               OSType       folderType,
 497               Boolean      createFolder)
 498 {
 499     FSRef fsRef;
 500     wxString strDir;
 501
 502     if ( FSFindFolder( vol, folderType, createFolder, &fsRef) == noErr)
 503     {
 504         strDir = wxMacFSRefToPath( &fsRef );
 505     }
 506
 507     return strDir;
 508 }
 509
 510 wxString wxMacFindFolder( short        vol,
 511               OSType       folderType,
 512               Boolean      createFolder)
 513 {
 514     return wxMacFindFolderNoSeparator(vol, folderType, createFolder) + wxFILE_SEP_PATH;
 515 }
 516
 517 #endif // wxUSE_BASE
 518
 519 #if wxUSE_GUI
 520
 521 // Check whether this window wants to process messages, e.g. Stop button
 522 // in long calculations.
 523 bool wxCheckForInterrupt(wxWindow *wnd)
 524 {
 525     // TODO
 526     return false;
 527 }
 528
 529 void wxGetMousePosition( int* x, int* y )
 530 {
 531     Point pt;
 532
 533     GetMouse( &pt );
 534     LocalToGlobal( &pt );
 535     *x = pt.h;
 536     *y = pt.v;
 537 };
 538
 539 // Return true if we have a colour display
 540 bool wxColourDisplay()
 541 {
 542     return true;
 543 }
 544
 545 // Returns depth of screen
 546 int wxDisplayDepth()
 547 {
 548     Rect globRect;
 549     SetRect(&globRect, -32760, -32760, 32760, 32760);
 550     GDHandle    theMaxDevice;
 551
 552     int theDepth = 8;
 553     theMaxDevice = GetMaxDevice(&globRect);
 554     if (theMaxDevice != NULL)
 555         theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
 556
 557     return theDepth;
 558 }
 559
 560 // Get size of display
 561 void wxDisplaySize(int *width, int *height)
 562 {
 563     BitMap screenBits;
 564     GetQDGlobalsScreenBits( &screenBits );
 565
 566     if (width != NULL)
 567         *width = screenBits.bounds.right - screenBits.bounds.left;
 568
 569     if (height != NULL)
 570         *height = screenBits.bounds.bottom - screenBits.bounds.top;
 571 }
 572
 573 void wxDisplaySizeMM(int *width, int *height)
 574 {
 575     wxDisplaySize(width, height);
 576     // on mac 72 is fixed (at least now;-)
 577     float cvPt2Mm = 25.4 / 72;
 578
 579     if (width != NULL)
 580         *width = int( *width * cvPt2Mm );
 581
 582     if (height != NULL)
 583         *height = int( *height * cvPt2Mm );
 584 }
 585
 586 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
 587 {
 588     Rect r;
 589
 590     GetAvailableWindowPositioningBounds( GetMainDevice() , &r );
 591     if ( x )
 592         *x = r.left;
 593     if ( y )
 594         *y = r.top;
 595     if ( width )
 596         *width = r.right - r.left;
 597     if ( height )
 598         *height = r.bottom - r.top;
 599 }
 600
 601 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 602 {
 603     return wxGenericFindWindowAtPoint(pt);
 604 }
 605
 606 #endif // wxUSE_GUI
 607
 608 #if wxUSE_BASE
 609
 610 wxString wxGetOsDescription()
 611 {
 612 #ifdef WXWIN_OS_DESCRIPTION
 613     // use configure generated description if available
 614     return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
 615 #else
 616     return wxT("MacOS"); //TODO:define further
 617 #endif
 618 }
 619
 620 #ifndef __DARWIN__
 621 wxChar *wxGetUserHome (const wxString& user)
 622 {
 623     // TODO
 624     return NULL;
 625 }
 626
 627 bool wxGetDiskSpace(const wxString& path, wxDiskspaceSize_t *pTotal, wxDiskspaceSize_t *pFree)
 628 {
 629     if ( path.empty() )
 630         return false;
 631
 632     wxString p = path;
 633     if (p[0u] == ':' )
 634       p = wxGetCwd() + p;
 635
 636     int pos = p.Find(':');
 637     if ( pos != wxNOT_FOUND )
 638       p = p.Mid(1,pos);
 639
 640     p = p + wxT(":");
 641
 642     OSErr err = noErr;
 643
 644     FSRef fsRef;
 645     err = wxMacPathToFSRef( p , &fsRef );
 646     if ( noErr == err )
 647     {
 648         FSVolumeRefNum vRefNum;
 649         err = FSGetVRefNum( &fsRef , &vRefNum );
 650         if ( noErr == err )
 651         {
 652             UInt64 freeBytes , totalBytes;
 653             err = FSGetVInfo( vRefNum , NULL , &freeBytes , &totalBytes );
 654             if ( noErr == err )
 655             {
 656                 if ( pTotal )
 657                     *pTotal = wxDiskspaceSize_t( totalBytes );
 658                 if ( pFree )
 659                     *pFree = wxDiskspaceSize_t( freeBytes );
 660             }
 661         }
 662     }
 663
 664     return err == noErr;
 665 }
 666 #endif // !__DARWIN__
 667
 668 //---------------------------------------------------------------------------
 669 // wxMac Specific utility functions
 670 //---------------------------------------------------------------------------
 671
 672 void wxMacStringToPascal( const wxString&from , StringPtr to )
 673 {
 674     wxCharBuffer buf = from.mb_str( wxConvLocal );
 675     int len = strlen(buf);
 676
 677     if ( len > 255 )
 678         len = 255;
 679     to[0] = len;
 680     memcpy( (char*) &to[1] , buf , len );
 681 }
 682
 683 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
 684 {
 685     return wxString( (char*) &from[1] , wxConvLocal , from[0] );
 686 }
 687
 688 // ----------------------------------------------------------------------------
 689 // Common Event Support
 690 // ----------------------------------------------------------------------------
 691
 692 extern ProcessSerialNumber gAppProcess;
 693
 694 void wxMacWakeUp()
 695 {
 696     ProcessSerialNumber psn;
 697     Boolean isSame;
 698     psn.highLongOfPSN = 0;
 699     psn.lowLongOfPSN = kCurrentProcess;
 700     SameProcess( &gAppProcess , &psn , &isSame );
 701     if ( isSame )
 702     {
 703 #if TARGET_CARBON
 704         OSStatus err = noErr;
 705
 706 #if 0
 707         // lead sometimes to race conditions, although all calls used should be thread safe ...
 708         static wxMacCarbonEvent s_wakeupEvent;
 709         if ( !s_wakeupEvent.IsValid() )
 710         {
 711            err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
 712                         kEventAttributeNone );
 713         }
 714         if ( err == noErr )
 715         {
 716
 717             if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
 718                 return;
 719             s_wakeupEvent.SetCurrentTime();
 720             err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
 721                                   kEventPriorityHigh );
 722         }
 723 #else
 724         wxMacCarbonEvent wakeupEvent;
 725         wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
 726                             kEventAttributeNone );
 727         err = PostEventToQueue(GetMainEventQueue(), wakeupEvent,
 728                                kEventPriorityHigh );
 729 #endif
 730 #else
 731         PostEvent( nullEvent , 0 );
 732 #endif
 733     }
 734     else
 735     {
 736         WakeUpProcess( &gAppProcess );
 737     }
 738 }
 739
 740 #endif // wxUSE_BASE
 741
 742 #if wxUSE_GUI
 743
 744 // ----------------------------------------------------------------------------
 745 // Native Struct Conversions
 746 // ----------------------------------------------------------------------------
 747
 748 void wxMacRectToNative( const wxRect *wx , Rect *n )
 749 {
 750     n->left = wx->x;
 751     n->top = wx->y;
 752     n->right = wx->x + wx->width;
 753     n->bottom = wx->y + wx->height;
 754 }
 755
 756 void wxMacNativeToRect( const Rect *n , wxRect* wx )
 757 {
 758     wx->x = n->left;
 759     wx->y = n->top;
 760     wx->width = n->right - n->left;
 761     wx->height = n->bottom - n->top;
 762 }
 763
 764 void wxMacPointToNative( const wxPoint* wx , Point *n )
 765 {
 766     n->h = wx->x;
 767     n->v = wx->y;
 768 }
 769
 770 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
 771 {
 772     wx->x = n->h;
 773     wx->y = n->v;
 774 }
 775
 776 // ----------------------------------------------------------------------------
 777 // Carbon Event Support
 778 // ----------------------------------------------------------------------------
 779
 780 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
 781 {
 782     return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData );
 783 }
 784
 785 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
 786 {
 787     return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData );
 788 }
 789
 790 // ----------------------------------------------------------------------------
 791 // Control Access Support
 792 // ----------------------------------------------------------------------------
 793
 794 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
 795 {
 796     Init();
 797     m_peer = peer;
 798     m_isRootControl = isRootControl;
 799 }
 800
 801 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
 802 {
 803     Init();
 804     m_peer = peer;
 805     m_controlRef = control;
 806 }
 807
 808 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
 809 {
 810     Init();
 811     m_peer = peer;
 812     m_controlRef = (ControlRef) control;
 813 }
 814
 815 wxMacControl::~wxMacControl()
 816 {
 817 }
 818
 819 void wxMacControl::Init()
 820 {
 821     m_peer = NULL;
 822     m_controlRef = NULL;
 823     m_needsFocusRect = false;
 824     m_isRootControl = false;
 825 }
 826
 827 void wxMacControl::Dispose()
 828 {
 829     wxASSERT_MSG( IsValidControlHandle(m_controlRef) , wxT("Invalid Control Handle (maybe already released) in Dispose") );
 830
 831     CFIndex count = CFGetRetainCount( m_controlRef ) ;
 832     wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in Dispose") );
 833
 834     ::DisposeControl( m_controlRef );
 835     m_controlRef = NULL;
 836 }
 837
 838 void wxMacControl::SetReference( SInt32 data )
 839 {
 840     SetControlReference( m_controlRef , data );
 841 }
 842
 843 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
 844 {
 845     return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
 846 }
 847
 848 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
 849 {
 850     return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
 851 }
 852
 853 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
 854 {
 855     return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
 856 }
 857
 858 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
 859 {
 860 #if TARGET_API_MAC_OSX
 861     return SendEventToEventTargetWithOptions( event,
 862         HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
 863 #else
 864     #pragma unused(inOptions)
 865     return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) );
 866 #endif
 867 }
 868
 869 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
 870 {
 871     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
 872
 873     event.SetParameter<HICommand>(kEventParamDirectObject,command);
 874
 875     return SendEvent( event , inOptions );
 876 }
 877
 878 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions  )
 879 {
 880     HICommand command;
 881
 882     memset( &command, 0 , sizeof(command) );
 883     command.commandID = commandID;
 884     return SendHICommand( command , inOptions );
 885 }
 886
 887 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
 888 {
 889     unsigned long finalTicks;
 890
 891     HiliteControl( m_controlRef , part );
 892     Delay( ticks , &finalTicks );
 893     HiliteControl( m_controlRef , kControlNoPart );
 894 }
 895
 896 SInt32 wxMacControl::GetValue() const
 897 {
 898     return ::GetControl32BitValue( m_controlRef );
 899 }
 900
 901 SInt32 wxMacControl::GetMaximum() const
 902 {
 903     return ::GetControl32BitMaximum( m_controlRef );
 904 }
 905
 906 SInt32 wxMacControl::GetMinimum() const
 907 {
 908     return ::GetControl32BitMinimum( m_controlRef );
 909 }
 910
 911 void wxMacControl::SetValue( SInt32 v )
 912 {
 913     ::SetControl32BitValue( m_controlRef , v );
 914 }
 915
 916 void wxMacControl::SetMinimum( SInt32 v )
 917 {
 918     ::SetControl32BitMinimum( m_controlRef , v );
 919 }
 920
 921 void wxMacControl::SetMaximum( SInt32 v )
 922 {
 923     ::SetControl32BitMaximum( m_controlRef , v );
 924 }
 925
 926 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
 927 {
 928     ::SetControl32BitMinimum( m_controlRef , minimum );
 929     ::SetControl32BitMaximum( m_controlRef , maximum );
 930     ::SetControl32BitValue( m_controlRef , value );
 931 }
 932
 933 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
 934 {
 935     return SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, focusPart );
 936 }
 937
 938 bool wxMacControl::HasFocus() const
 939 {
 940     ControlRef control;
 941     GetKeyboardFocus( GetUserFocusWindow() , &control );
 942     return control == m_controlRef;
 943 }
 944
 945 void wxMacControl::SetNeedsFocusRect( bool needs )
 946 {
 947     m_needsFocusRect = needs;
 948 }
 949
 950 bool wxMacControl::NeedsFocusRect() const
 951 {
 952     return m_needsFocusRect;
 953 }
 954
 955 void wxMacControl::VisibilityChanged(bool shown)
 956 {
 957 }
 958
 959 void wxMacControl::SuperChangedPosition()
 960 {
 961 }
 962
 963 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
 964 {
 965     m_font = font;
 966     ControlFontStyleRec fontStyle;
 967     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
 968     {
 969         switch ( font.MacGetThemeFontID() )
 970         {
 971             case kThemeSmallSystemFont :
 972                 fontStyle.font = kControlFontSmallSystemFont;
 973                 break;
 974
 975             case 109 : // mini font
 976                 fontStyle.font = -5;
 977                 break;
 978
 979             case kThemeSystemFont :
 980                 fontStyle.font = kControlFontBigSystemFont;
 981                 break;
 982
 983             default :
 984                 fontStyle.font = kControlFontBigSystemFont;
 985                 break;
 986         }
 987
 988         fontStyle.flags = kControlUseFontMask;
 989     }
 990     else
 991     {
 992         fontStyle.font = font.MacGetFontNum();
 993         fontStyle.style = font.MacGetFontStyle();
 994         fontStyle.size = font.MacGetFontSize();
 995         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
 996     }
 997
 998     fontStyle.just = teJustLeft;
 999     fontStyle.flags |= kControlUseJustMask;
1000     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1001         fontStyle.just = teJustCenter;
1002     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1003         fontStyle.just = teJustRight;
1004
1005
1006     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1007     // won't get grayed out by the system anymore
1008
1009     if ( foreground != *wxBLACK )
1010     {
1011         fontStyle.foreColor = MAC_WXCOLORREF( foreground.GetPixel() );
1012         fontStyle.flags |= kControlUseForeColorMask;
1013     }
1014
1015     ::SetControlFontStyle( m_controlRef , &fontStyle );
1016 }
1017
1018 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1019 {
1020     // TODO
1021     // setting up a color proc is not recommended anymore
1022 }
1023
1024 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1025 {
1026     ::SetControl32BitMinimum( m_controlRef , minimum );
1027     ::SetControl32BitMaximum( m_controlRef , maximum );
1028 }
1029
1030 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1031 {
1032     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1033 }
1034
1035 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1036 {
1037     SetControlAction( m_controlRef , actionProc );
1038 }
1039
1040 void wxMacControl::SetViewSize( SInt32 viewSize )
1041 {
1042     SetControlViewSize(m_controlRef , viewSize );
1043 }
1044
1045 SInt32 wxMacControl::GetViewSize() const
1046 {
1047     return GetControlViewSize( m_controlRef );
1048 }
1049
1050 bool wxMacControl::IsVisible() const
1051 {
1052     return IsControlVisible( m_controlRef );
1053 }
1054
1055 void wxMacControl::SetVisibility( bool visible , bool redraw )
1056 {
1057     SetControlVisibility( m_controlRef , visible , redraw );
1058 }
1059
1060 bool wxMacControl::IsEnabled() const
1061 {
1062 #if TARGET_API_MAC_OSX
1063     return IsControlEnabled( m_controlRef );
1064 #else
1065     return IsControlActive( m_controlRef );
1066 #endif
1067 }
1068
1069 bool wxMacControl::IsActive() const
1070 {
1071     return IsControlActive( m_controlRef );
1072 }
1073
1074 void wxMacControl::Enable( bool enable )
1075 {
1076     if ( enable )
1077         EnableControl( m_controlRef );
1078     else
1079         DisableControl( m_controlRef );
1080 }
1081
1082 void wxMacControl::SetDrawingEnabled( bool enable )
1083 {
1084     HIViewSetDrawingEnabled( m_controlRef , enable );
1085 }
1086
1087 bool wxMacControl::GetNeedsDisplay() const
1088 {
1089     return HIViewGetNeedsDisplay( m_controlRef );
1090 }
1091
1092 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1093 {
1094     if ( !IsVisible() )
1095         return;
1096
1097     HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
1098 }
1099
1100 void wxMacControl::SetNeedsDisplay( Rect* where )
1101 {
1102     if ( !IsVisible() )
1103         return;
1104
1105     if ( where != NULL )
1106     {
1107         RgnHandle update = NewRgn();
1108         RectRgn( update , where );
1109         HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
1110         DisposeRgn( update );
1111     }
1112     else
1113         HIViewSetNeedsDisplay( m_controlRef , true );
1114 }
1115
1116 void  wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1117 {
1118     HIPoint hiPoint;
1119
1120     hiPoint.x = pt->x;
1121     hiPoint.y = pt->y;
1122     HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef  );
1123     pt->x = (int)hiPoint.x;
1124     pt->y = (int)hiPoint.y;
1125 }
1126
1127 void wxMacControl::SetRect( Rect *r )
1128 {
1129         //A HIRect is actually a CGRect on OSX - which consists of two structures -
1130         //CGPoint and CGSize, which have two floats each
1131         HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
1132         HIViewSetFrame ( m_controlRef , &hir );
1133         // eventuall we might have to do a SetVisibility( false , true );
1134         // before and a SetVisibility( true , true ); after
1135 }
1136
1137 void wxMacControl::GetRect( Rect *r )
1138 {
1139     GetControlBounds( m_controlRef , r );
1140 }
1141
1142 void wxMacControl::GetRectInWindowCoords( Rect *r )
1143 {
1144     UMAGetControlBoundsInWindowCoords( m_controlRef , r );
1145 }
1146
1147 void wxMacControl::GetBestRect( Rect *r )
1148 {
1149     short   baselineoffset;
1150
1151     GetBestControlRect( m_controlRef , r , &baselineoffset );
1152 }
1153
1154 void wxMacControl::SetLabel( const wxString &title )
1155 {
1156     wxFontEncoding encoding;
1157
1158     if ( m_font.Ok() )
1159         encoding = m_font.GetEncoding();
1160     else
1161         encoding = wxFont::GetDefaultEncoding();
1162
1163     UMASetControlTitle( m_controlRef , title , encoding );
1164 }
1165
1166 void wxMacControl::GetFeatures( UInt32 * features )
1167 {
1168     GetControlFeatures( m_controlRef , features );
1169 }
1170
1171 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1172 {
1173     OSStatus err = GetControlRegion( m_controlRef , partCode , region );
1174     return err;
1175 }
1176
1177 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1178 {
1179 #if TARGET_API_MAC_OSX
1180     return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1181        (other != NULL) ? other->m_controlRef : NULL);
1182 #else
1183     return 0;
1184 #endif
1185 }
1186
1187 #if TARGET_API_MAC_OSX
1188 // SetNeedsDisplay would not invalidate the children
1189 static void InvalidateControlAndChildren( HIViewRef control )
1190 {
1191     HIViewSetNeedsDisplay( control , true );
1192     UInt16 childrenCount = 0;
1193     OSStatus err = CountSubControls( control , &childrenCount );
1194     if ( err == errControlIsNotEmbedder )
1195         return;
1196
1197     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1198
1199     for ( UInt16 i = childrenCount; i >=1; --i )
1200     {
1201         HIViewRef child;
1202
1203         err = GetIndexedSubControl( control , i , & child );
1204         if ( err == errControlIsNotEmbedder )
1205             return;
1206
1207         InvalidateControlAndChildren( child );
1208     }
1209 }
1210 #endif
1211
1212 void wxMacControl::InvalidateWithChildren()
1213 {
1214 #if TARGET_API_MAC_OSX
1215     InvalidateControlAndChildren( m_controlRef );
1216 #endif
1217 }
1218
1219 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1220 {
1221     wxASSERT( r != NULL );
1222
1223     HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
1224     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1225 }
1226
1227 OSType wxMacCreator = 'WXMC';
1228 OSType wxMacControlProperty = 'MCCT';
1229
1230 void wxMacControl::SetReferenceInNativeControl()
1231 {
1232     void * data = this;
1233     verify_noerr( SetControlProperty ( m_controlRef ,
1234         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1235 }
1236
1237 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1238 {
1239     wxMacControl* ctl = NULL;
1240     UInt32 actualSize;
1241     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1242         &actualSize , &ctl ) == noErr )
1243     {
1244         return ctl;
1245     }
1246     return NULL;
1247 }
1248
1249 // ============================================================================
1250 // DataBrowser Wrapper
1251 // ============================================================================
1252 //
1253 // basing on DataBrowserItemIDs
1254 //
1255
1256 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
1257     ControlRef browser,
1258     DataBrowserItemID itemID,
1259     DataBrowserItemNotification message,
1260     DataBrowserItemDataRef itemData )
1261 {
1262     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1263     if ( ctl != 0 )
1264     {
1265         ctl->ItemNotification(itemID, message, itemData);
1266     }
1267 }
1268
1269 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
1270     ControlRef browser,
1271     DataBrowserItemID itemID,
1272     DataBrowserPropertyID property,
1273     DataBrowserItemDataRef itemData,
1274     Boolean changeValue )
1275 {
1276     OSStatus err = errDataBrowserPropertyNotSupported;
1277     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1278     if ( ctl != 0 )
1279     {
1280         err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
1281     }
1282     return err;
1283 }
1284
1285 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
1286     ControlRef browser,
1287     DataBrowserItemID itemOneID,
1288     DataBrowserItemID itemTwoID,
1289     DataBrowserPropertyID sortProperty)
1290 {
1291     wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1292     if ( ctl != 0 )
1293     {
1294         return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
1295     }
1296     return false;
1297 }
1298
1299 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
1300 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
1301 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
1302
1303 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer, const wxPoint& pos, const wxSize& size, long style) : wxMacControl( peer )
1304 {
1305     Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
1306     OSStatus err = ::CreateDataBrowserControl(
1307         MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
1308         &bounds, kDataBrowserListView, &m_controlRef );
1309     SetReferenceInNativeControl();
1310     verify_noerr( err );
1311     if ( gDataBrowserItemCompareUPP == NULL )
1312         gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
1313     if ( gDataBrowserItemDataUPP == NULL )
1314         gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
1315     if ( gDataBrowserItemNotificationUPP == NULL )
1316     {
1317         gDataBrowserItemNotificationUPP =
1318 #if TARGET_API_MAC_OSX
1319             (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
1320 #else
1321             NewDataBrowserItemNotificationUPP(DataBrowserItemNotificationProc);
1322 #endif
1323     }
1324
1325     DataBrowserCallbacks callbacks;
1326     InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1327
1328     callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1329     callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1330     callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1331     SetCallbacks( &callbacks );
1332
1333 }
1334
1335 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1336     Boolean recurse,
1337     DataBrowserItemState state,
1338     UInt32 *numItems) const
1339 {
1340     return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1341 }
1342
1343 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1344     Boolean recurse,
1345     DataBrowserItemState state,
1346     Handle items) const
1347 {
1348     return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1349 }
1350
1351 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1352 {
1353     return SetDataBrowserSelectionFlags( m_controlRef, options );
1354 }
1355
1356 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1357         DataBrowserTableViewColumnIndex position )
1358 {
1359     return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1360 }
1361
1362 OSStatus wxMacDataBrowserControl::GetColumnIDFromIndex( DataBrowserTableViewColumnIndex position, DataBrowserTableViewColumnID* id ){
1363     return GetDataBrowserTableViewColumnProperty( m_controlRef, position, id );
1364 }
1365
1366 OSStatus wxMacDataBrowserControl::RemoveColumn( DataBrowserTableViewColumnIndex position )
1367 {
1368     DataBrowserTableViewColumnID id;
1369     GetColumnIDFromIndex( position, &id );
1370     return RemoveDataBrowserTableViewColumn( m_controlRef, id );
1371 }
1372
1373 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1374 {
1375     return AutoSizeDataBrowserListViewColumns(m_controlRef);
1376 }
1377
1378 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1379 {
1380     return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1381 }
1382
1383 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1384 {
1385     return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1386 }
1387
1388 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1389 {
1390     return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1391 }
1392
1393 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1394 {
1395     return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1396 }
1397
1398 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1399 {
1400     return SetDataBrowserCallbacks( m_controlRef, callbacks );
1401 }
1402
1403 OSStatus wxMacDataBrowserControl::UpdateItems(
1404     DataBrowserItemID container,
1405     UInt32 numItems,
1406     const DataBrowserItemID *items,
1407     DataBrowserPropertyID preSortProperty,
1408     DataBrowserPropertyID propertyID ) const
1409 {
1410     return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1411 }
1412
1413 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1414 {
1415     return IsDataBrowserItemSelected( m_controlRef, item );
1416 }
1417
1418 OSStatus wxMacDataBrowserControl::AddItems(
1419     DataBrowserItemID container,
1420     UInt32 numItems,
1421     const DataBrowserItemID *items,
1422     DataBrowserPropertyID preSortProperty )
1423 {
1424     return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1425 }
1426
1427 OSStatus wxMacDataBrowserControl::RemoveItems(
1428     DataBrowserItemID container,
1429     UInt32 numItems,
1430     const DataBrowserItemID *items,
1431     DataBrowserPropertyID preSortProperty )
1432 {
1433     return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1434 }
1435
1436 OSStatus wxMacDataBrowserControl::RevealItem(
1437     DataBrowserItemID item,
1438     DataBrowserPropertyID propertyID,
1439     DataBrowserRevealOptions options ) const
1440 {
1441     return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1442 }
1443
1444 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1445     UInt32 numItems,
1446     const DataBrowserItemID *items,
1447     DataBrowserSetOption operation )
1448 {
1449     return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1450 }
1451
1452 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1453 {
1454     return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1455 }
1456
1457 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1458 {
1459     return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1460 }
1461
1462 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1463 {
1464     return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1465 }
1466
1467 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1468 {
1469     return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1470 }
1471
1472 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1473 {
1474     return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1475 }
1476
1477 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1478 {
1479     return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1480 }
1481
1482 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1483 {
1484     return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1485 }
1486
1487 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1488 {
1489     return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1490 }
1491
1492 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1493 {
1494     return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1495 }
1496
1497 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1498 {
1499     return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1500 }
1501
1502 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1503 {
1504     return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1505 }
1506
1507 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1508 {
1509     return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1510 }
1511
1512 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1513     UInt32 *position) const
1514 {
1515     return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1516 }
1517
1518 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, UInt32 position)
1519 {
1520     return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1521 }
1522
1523 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1524 {
1525     return GetDataBrowserScrollPosition( m_controlRef , top , left );
1526 }
1527
1528 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1529 {
1530     return SetDataBrowserScrollPosition( m_controlRef , top , left );
1531 }
1532
1533 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1534 {
1535     return GetDataBrowserSortProperty( m_controlRef , column );
1536 }
1537
1538 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1539 {
1540     return SetDataBrowserSortProperty( m_controlRef , column );
1541 }
1542
1543 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1544 {
1545     return GetDataBrowserSortOrder( m_controlRef , order );
1546 }
1547
1548 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1549 {
1550     return SetDataBrowserSortOrder( m_controlRef , order );
1551 }
1552
1553 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1554     DataBrowserPropertyFlags *flags ) const
1555 {
1556     return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1557 }
1558
1559 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1560     DataBrowserPropertyFlags flags )
1561 {
1562     return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1563 }
1564
1565 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1566     DataBrowserListViewHeaderDesc *desc ) const
1567 {
1568     return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1569 }
1570
1571 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1572     DataBrowserListViewHeaderDesc *desc )
1573 {
1574     return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1575 }
1576
1577 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1578     Boolean expandableRows )
1579 {
1580     return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1581 }
1582
1583 // ============================================================================
1584 // Higher-level Databrowser
1585 // ============================================================================
1586 //
1587 // basing on data item objects
1588 //
1589
1590 wxMacDataItem::wxMacDataItem()
1591 {
1592     m_data = NULL;
1593     m_order = 0;
1594     m_colId = kTextColumnId; // for compat with existing wx*ListBox impls.
1595 }
1596
1597 wxMacDataItem::~wxMacDataItem()
1598 {
1599 }
1600
1601 void wxMacDataItem::SetOrder( SInt32 order )
1602 {
1603     m_order = order;
1604 }
1605
1606 SInt32 wxMacDataItem::GetOrder() const
1607 {
1608     return m_order;
1609 }
1610
1611 void wxMacDataItem::SetData( void* data)
1612 {
1613     m_data = data;
1614 }
1615
1616 void* wxMacDataItem::GetData() const
1617 {
1618     return m_data;
1619 }
1620
1621 short wxMacDataItem::GetColumn()
1622 {
1623     return m_colId;
1624 }
1625
1626 void wxMacDataItem::SetColumn( short col )
1627 {
1628     m_colId = col;
1629 }
1630
1631 void wxMacDataItem::SetLabel( const wxString& str)
1632 {
1633     m_label = str;
1634     m_cfLabel.Assign( str , wxLocale::GetSystemEncoding());
1635 }
1636
1637 const wxString& wxMacDataItem::GetLabel() const
1638 {
1639     return m_label;
1640 }
1641
1642 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *owner ,
1643     const wxMacDataItem* rhs,
1644     DataBrowserPropertyID sortProperty) const
1645 {
1646     const wxMacDataItem* otherItem = dynamic_cast<const wxMacDataItem*>(rhs);
1647     bool retval = false;
1648
1649     if ( sortProperty == m_colId ){
1650         retval = m_label.CmpNoCase( otherItem->m_label) < 0;
1651     }
1652
1653     else if ( sortProperty == kNumericOrderColumnId )
1654         retval = m_order < otherItem->m_order;
1655
1656     return retval;
1657 }
1658
1659 OSStatus wxMacDataItem::GetSetData( wxMacDataItemBrowserControl *owner ,
1660     DataBrowserPropertyID property,
1661     DataBrowserItemDataRef itemData,
1662     bool changeValue )
1663 {
1664     OSStatus err = errDataBrowserPropertyNotSupported;
1665     if ( !changeValue )
1666     {
1667         if ( property == m_colId ){
1668             err = ::SetDataBrowserItemDataText( itemData, m_cfLabel );
1669             err = noErr;
1670         }
1671         else if ( property == kNumericOrderColumnId ){
1672             err = ::SetDataBrowserItemDataValue( itemData, m_order );
1673             err = noErr;
1674         }
1675         else{
1676         }
1677     }
1678     else
1679     {
1680         switch (property)
1681         {
1682             // no editable props here
1683             default:
1684                 break;
1685         }
1686     }
1687
1688     return err;
1689 }
1690
1691 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *owner ,
1692     DataBrowserItemNotification message,
1693     DataBrowserItemDataRef itemData ) const
1694 {
1695 }
1696
1697
1698 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1699     wxMacDataBrowserControl( peer, pos, size, style )
1700 {
1701     m_suppressSelection = false;
1702     m_sortOrder = SortOrder_None;
1703     m_clientDataItemsType = wxClientData_None;
1704 }
1705
1706 wxMacDataItem* wxMacDataItemBrowserControl::CreateItem()
1707 {
1708     return new wxMacDataItem();
1709 }
1710
1711 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1712 {
1713     m_former = browser->SuppressSelection(true);
1714     m_browser = browser;
1715 }
1716
1717 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1718 {
1719     m_browser->SuppressSelection(m_former);
1720 }
1721
1722 bool  wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1723 {
1724     bool former = m_suppressSelection;
1725     m_suppressSelection = suppress;
1726
1727     return former;
1728 }
1729
1730 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1731     DataBrowserItemID itemTwoID,
1732     DataBrowserPropertyID sortProperty)
1733 {
1734     wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1735     wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1736     return CompareItems( itemOne , itemTwo , sortProperty );
1737 }
1738
1739 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem*  itemOne,
1740     const wxMacDataItem*  itemTwo,
1741     DataBrowserPropertyID sortProperty)
1742 {
1743     Boolean retval = false;
1744     if ( itemOne != NULL )
1745         retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1746     return retval;
1747 }
1748
1749 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1750     DataBrowserItemID itemID,
1751     DataBrowserPropertyID property,
1752     DataBrowserItemDataRef itemData,
1753     Boolean changeValue )
1754 {
1755     wxMacDataItem* item = (wxMacDataItem*) itemID;
1756     return GetSetItemData(item, property, itemData , changeValue );
1757 }
1758
1759 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1760     wxMacDataItem* item,
1761     DataBrowserPropertyID property,
1762     DataBrowserItemDataRef itemData,
1763     Boolean changeValue )
1764 {
1765     OSStatus err = errDataBrowserPropertyNotSupported;
1766     switch( property )
1767     {
1768         case kDataBrowserContainerIsClosableProperty :
1769         case kDataBrowserContainerIsSortableProperty :
1770         case kDataBrowserContainerIsOpenableProperty :
1771             // right now default behaviour on these
1772             break;
1773         default :
1774
1775             if ( item != NULL ){
1776                 err = item->GetSetData( this, property , itemData , changeValue );
1777             }
1778             break;
1779
1780     }
1781     return err;
1782 }
1783
1784 void wxMacDataItemBrowserControl::ItemNotification(
1785     DataBrowserItemID itemID,
1786     DataBrowserItemNotification message,
1787     DataBrowserItemDataRef itemData)
1788 {
1789     wxMacDataItem* item = (wxMacDataItem*) itemID;
1790     ItemNotification( item , message, itemData);
1791 }
1792
1793 void wxMacDataItemBrowserControl::ItemNotification(
1794     const wxMacDataItem* item,
1795     DataBrowserItemNotification message,
1796     DataBrowserItemDataRef itemData)
1797 {
1798     if (item != NULL)
1799         item->Notification( this, message, itemData);
1800 }
1801
1802 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1803         bool recurse , DataBrowserItemState state) const
1804 {
1805     UInt32 numItems = 0;
1806     verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1807         recurse, state, &numItems ) );
1808     return numItems;
1809 }
1810
1811 unsigned int wxMacDataItemBrowserControl::GetSelectedItemCount( const wxMacDataItem* container,
1812         bool recurse ) const
1813 {
1814     return GetItemCount( container, recurse, kDataBrowserItemIsSelected );
1815
1816 }
1817
1818 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1819     bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1820 {
1821     Handle handle = NewHandle(0);
1822     verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1823         recurse , state, handle) );
1824
1825     int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1826     HLock( handle );
1827     wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1828     for ( int i = 0; i < itemCount; ++i)
1829     {
1830         items.Add(itemsArray[i]);
1831     }
1832     HUnlock( handle );
1833     DisposeHandle( handle );
1834 }
1835
1836 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1837 {
1838     DataBrowserTableViewRowIndex row;
1839     OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1840     wxASSERT( err == noErr);
1841     return row;
1842 }
1843
1844 wxMacDataItem*  wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1845 {
1846     DataBrowserItemID id;
1847     OSStatus err =  GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1848     wxASSERT( err == noErr);
1849     return (wxMacDataItem*) id;
1850 }
1851
1852 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1853         const wxMacDataItem *item , DataBrowserPropertyID property) const
1854 {
1855     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1856         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1857 }
1858
1859 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1860         wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1861 {
1862     unsigned int noItems = itemArray.GetCount();
1863     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1864     for ( unsigned int i = 0; i < noItems; ++i )
1865         items[i] = (DataBrowserItemID) itemArray[i];
1866
1867     verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1868         items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1869     delete [] items;
1870 }
1871
1872 void wxMacDataItemBrowserControl::InsertColumn(int colId, DataBrowserPropertyType colType,
1873                                             const wxString& title, SInt16 just, int minWidth, int maxWidth)
1874 {
1875     DataBrowserListViewColumnDesc columnDesc;
1876     columnDesc.headerBtnDesc.titleOffset = 0;
1877     columnDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
1878
1879     columnDesc.headerBtnDesc.btnFontStyle.flags =
1880         kControlUseFontMask | kControlUseJustMask;
1881
1882     columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
1883     columnDesc.headerBtnDesc.btnFontStyle.just = just;
1884     columnDesc.headerBtnDesc.btnFontStyle.font = kControlFontViewSystemFont;
1885     columnDesc.headerBtnDesc.btnFontStyle.style = normal;
1886
1887     // TODO: Why is m_font not defined when we enter wxLC_LIST mode, but is
1888     // defined for other modes?
1889     wxFontEncoding enc;
1890     if ( m_font.Ok() )
1891         enc = m_font.GetEncoding();
1892     else
1893         enc = wxLocale::GetSystemEncoding();
1894     wxMacCFStringHolder cfTitle;
1895     cfTitle.Assign( title, enc );
1896     columnDesc.headerBtnDesc.titleString = cfTitle;
1897
1898     int colMinWidth = 0;
1899     if (minWidth != -1)
1900         colMinWidth = minWidth;
1901     columnDesc.headerBtnDesc.minimumWidth = colMinWidth;
1902
1903     int colMaxWidth = 500;
1904     if (maxWidth != -1)
1905         colMaxWidth = maxWidth;
1906     columnDesc.headerBtnDesc.maximumWidth = colMaxWidth;
1907
1908     columnDesc.propertyDesc.propertyID = (kMinColumnId + colId);
1909     columnDesc.propertyDesc.propertyType = colType;
1910     columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewDefaultColumnFlags | kDataBrowserListViewNoGapForIconInHeaderButton;
1911 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
1912     columnDesc.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn;
1913 #endif
1914
1915     verify_noerr( AddColumn( &columnDesc, kDataBrowserListViewAppendColumn ) );
1916 }
1917
1918 void wxMacDataItemBrowserControl::SetColumnWidth(int colId, int width)
1919 {
1920     DataBrowserPropertyID id;
1921     GetColumnIDFromIndex(colId, &id);
1922     verify_noerr( wxMacDataBrowserControl::SetColumnWidth(id, width));
1923 }
1924
1925 int wxMacDataItemBrowserControl::GetColumnWidth(int colId)
1926 {
1927     DataBrowserPropertyID id;
1928     GetColumnIDFromIndex(colId, &id);
1929     UInt16 result;
1930     verify_noerr( wxMacDataBrowserControl::GetColumnWidth(id, &result));
1931     return result;
1932 }
1933
1934 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1935 {
1936     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1937         (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1938 }
1939
1940 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1941 {
1942     unsigned int noItems = itemArray.GetCount();
1943     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1944     for ( unsigned int i = 0; i < noItems; ++i )
1945         items[i] = (DataBrowserItemID) itemArray[i];
1946
1947     verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1948         (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1949     delete [] items;
1950 }
1951
1952 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1953 {
1954     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1955         (UInt32*) &item, kDataBrowserItemNoProperty );
1956     verify_noerr( err );
1957 }
1958
1959 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1960 {
1961     unsigned int noItems = itemArray.GetCount();
1962     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1963     for ( unsigned int i = 0; i < noItems; ++i )
1964         items[i] = (DataBrowserItemID) itemArray[i];
1965
1966     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1967         (UInt32*) items, kDataBrowserItemNoProperty );
1968     verify_noerr( err );
1969     delete [] items;
1970 }
1971
1972 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1973 {
1974     OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1975     verify_noerr( err );
1976 }
1977
1978 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1979 {
1980     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1981 }
1982
1983 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1984 {
1985     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1986 }
1987
1988 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1989 {
1990     unsigned int noItems = itemArray.GetCount();
1991     DataBrowserItemID *items = new DataBrowserItemID[noItems];
1992     for ( unsigned int i = 0; i < noItems; ++i )
1993         items[i] = (DataBrowserItemID) itemArray[i];
1994
1995     verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
1996     delete [] items;
1997 }
1998
1999 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
2000 {
2001     return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
2002 }
2003
2004 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
2005 {
2006     verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
2007 }
2008
2009 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
2010 {
2011     verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
2012 }
2013
2014 wxClientDataType wxMacDataItemBrowserControl::GetClientDataType() const
2015 {
2016      return m_clientDataItemsType;
2017 }
2018 void wxMacDataItemBrowserControl::SetClientDataType(wxClientDataType clientDataItemsType)
2019 {
2020     m_clientDataItemsType = clientDataItemsType;
2021 }
2022
2023 unsigned int wxMacDataItemBrowserControl::MacGetCount() const
2024 {
2025     return GetItemCount(wxMacDataBrowserRootContainer,false,kDataBrowserItemAnyState);
2026 }
2027
2028 void wxMacDataItemBrowserControl::MacDelete( unsigned int n )
2029 {
2030     wxMacDataItem* item = (wxMacDataItem*)GetItemFromLine( n );
2031     RemoveItem( wxMacDataBrowserRootContainer, item );
2032 }
2033
2034 void wxMacDataItemBrowserControl::MacInsert( unsigned int n, const wxString& text, int column )
2035 {
2036     wxMacDataItem* newItem = CreateItem();
2037     newItem->SetLabel( text );
2038     if ( column != -1 )
2039         newItem->SetColumn( kMinColumnId + column );
2040
2041     if ( m_sortOrder == SortOrder_None )
2042     {
2043         // increase the order of the lines to be shifted
2044         unsigned int lines = MacGetCount();
2045         for ( unsigned int i = n; i < lines; ++i)
2046         {
2047             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
2048             iter->SetOrder( iter->GetOrder() + 1 );
2049         }
2050
2051         SInt32 frontLineOrder = 0;
2052         if ( n > 0 )
2053         {
2054             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
2055             frontLineOrder = iter->GetOrder();
2056         }
2057         newItem->SetOrder( frontLineOrder + 1 );
2058     }
2059
2060     AddItem( wxMacDataBrowserRootContainer, newItem );
2061 }
2062
2063 void wxMacDataItemBrowserControl::MacInsert( unsigned int n, const wxArrayString& items, int column )
2064 {
2065     size_t itemsCount = items.GetCount();
2066     if ( itemsCount == 0 )
2067         return;
2068
2069     SInt32 frontLineOrder = 0;
2070
2071     if ( m_sortOrder == SortOrder_None )
2072     {
2073         // increase the order of the lines to be shifted
2074         unsigned int lines = MacGetCount();
2075         for ( unsigned int i = n; i < lines; ++i)
2076         {
2077             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
2078             iter->SetOrder( iter->GetOrder() + itemsCount );
2079         }
2080         if ( n > 0 )
2081         {
2082             wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
2083             frontLineOrder = iter->GetOrder();
2084         }
2085     }
2086
2087     wxArrayMacDataItemPtr ids;
2088     ids.SetCount( itemsCount );
2089
2090     for ( unsigned int i = 0; i < itemsCount; ++i )
2091     {
2092         wxMacDataItem* item = CreateItem();
2093         item->SetLabel( items[i]);
2094         if ( column != -1 )
2095             item->SetColumn( kMinColumnId + column );
2096
2097         if ( m_sortOrder == SortOrder_None )
2098             item->SetOrder( frontLineOrder + 1 + i );
2099
2100         ids[i] = item;
2101     }
2102
2103     AddItems( wxMacDataBrowserRootContainer, ids );
2104 }
2105
2106 int wxMacDataItemBrowserControl::MacAppend( const wxString& text)
2107 {
2108     wxMacDataItem* item = CreateItem();
2109     item->SetLabel( text );
2110     if ( m_sortOrder == SortOrder_None )
2111     {
2112         unsigned int lines = MacGetCount();
2113         if ( lines == 0 )
2114             item->SetOrder( 1 );
2115         else
2116         {
2117             wxMacDataItem* frontItem = (wxMacDataItem*) GetItemFromLine(lines-1);
2118             item->SetOrder( frontItem->GetOrder() + 1 );
2119         }
2120     }
2121     AddItem( wxMacDataBrowserRootContainer, item );
2122
2123     return GetLineFromItem(item);
2124 }
2125
2126 void wxMacDataItemBrowserControl::MacClear()
2127 {
2128     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2129     RemoveAllItems(wxMacDataBrowserRootContainer);
2130 }
2131
2132 void wxMacDataItemBrowserControl::MacDeselectAll()
2133 {
2134     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2135     SetSelectedAllItems( kDataBrowserItemsRemove );
2136 }
2137
2138 void wxMacDataItemBrowserControl::MacSetSelection( unsigned int n, bool select, bool multi )
2139 {
2140     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2141     wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2142
2143     if ( IsItemSelected( item ) != select )
2144     {
2145         if ( select )
2146             SetSelectedItem( item, multi ? kDataBrowserItemsAdd : kDataBrowserItemsAssign );
2147         else
2148             SetSelectedItem( item, kDataBrowserItemsRemove );
2149     }
2150
2151     MacScrollTo( n );
2152 }
2153
2154 bool wxMacDataItemBrowserControl::MacIsSelected( unsigned int n ) const
2155 {
2156     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2157     return IsItemSelected( item );
2158 }
2159
2160 int wxMacDataItemBrowserControl::MacGetSelection() const
2161 {
2162     wxMacDataItemPtr first, last;
2163     GetSelectionAnchor( &first, &last );
2164
2165     if ( first != NULL )
2166     {
2167         return GetLineFromItem( first );
2168     }
2169
2170     return -1;
2171 }
2172
2173 int wxMacDataItemBrowserControl::MacGetSelections( wxArrayInt& aSelections ) const
2174 {
2175     aSelections.Empty();
2176     wxArrayMacDataItemPtr selectedItems;
2177     GetItems( wxMacDataBrowserRootContainer, false , kDataBrowserItemIsSelected, selectedItems);
2178
2179     int count = selectedItems.GetCount();
2180
2181     for ( int i = 0; i < count; ++i)
2182     {
2183         aSelections.Add(GetLineFromItem(selectedItems[i]));
2184     }
2185
2186     return count;
2187 }
2188
2189 void wxMacDataItemBrowserControl::MacSetString( unsigned int n, const wxString& text )
2190 {
2191     // as we don't store the strings we only have to issue a redraw
2192     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2193     item->SetLabel( text );
2194     UpdateItem( wxMacDataBrowserRootContainer, item , kTextColumnId );
2195 }
2196
2197 wxString wxMacDataItemBrowserControl::MacGetString( unsigned int n ) const
2198 {
2199     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2200     return item->GetLabel();
2201 }
2202
2203 void wxMacDataItemBrowserControl::MacSetClientData( unsigned int n, void * data)
2204 {
2205     wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2206     item->SetData( data );
2207     // not displayed, therefore no Update infos to DataBrowser
2208 }
2209
2210 void * wxMacDataItemBrowserControl::MacGetClientData( unsigned int n) const
2211 {
2212     wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2213     return item->GetData();
2214 }
2215
2216 void wxMacDataItemBrowserControl::MacScrollTo( unsigned int n )
2217 {
2218     RevealItem( GetItemFromLine( n) , kDataBrowserRevealWithoutSelecting );
2219 }
2220
2221
2222
2223 //
2224 // Tab Control
2225 //
2226
2227 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
2228 {
2229     return ::SetTabEnabled( m_controlRef , tabNo , enable );
2230 }
2231
2232 //
2233 // Quartz Support
2234 //
2235
2236 #ifdef __WXMAC_OSX__
2237 // snippets from Sketch Sample from Apple :
2238
2239 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
2240
2241 /*
2242     This function locates, opens, and returns the profile reference for the calibrated
2243     Generic RGB color space. It is up to the caller to call CMCloseProfile when done
2244     with the profile reference this function returns.
2245 */
2246 CMProfileRef wxMacOpenGenericProfile()
2247 {
2248     static CMProfileRef cachedRGBProfileRef = NULL;
2249
2250     // we only create the profile reference once
2251     if (cachedRGBProfileRef == NULL)
2252     {
2253         CMProfileLocation loc;
2254
2255         loc.locType = cmPathBasedProfile;
2256         strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
2257
2258         verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
2259     }
2260
2261     // clone the profile reference so that the caller has their own reference, not our cached one
2262     if (cachedRGBProfileRef)
2263         CMCloneProfileRef(cachedRGBProfileRef);
2264
2265     return cachedRGBProfileRef;
2266 }
2267
2268 /*
2269     Return the generic RGB color space. This is a 'get' function and the caller should
2270     not release the returned value unless the caller retains it first. Usually callers
2271     of this routine will immediately use the returned colorspace with CoreGraphics
2272     so they typically do not need to retain it themselves.
2273
2274     This function creates the generic RGB color space once and hangs onto it so it can
2275     return it whenever this function is called.
2276 */
2277
2278 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
2279 {
2280     static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
2281
2282     if (genericRGBColorSpace == NULL)
2283     {
2284         if ( UMAGetSystemVersion() >= 0x1040 )
2285         {
2286             genericRGBColorSpace.Set( CGColorSpaceCreateWithName( CFSTR("kCGColorSpaceGenericRGB") ) );
2287         }
2288         else
2289         {
2290             CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
2291
2292             if (genericRGBProfile)
2293             {
2294                 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) );
2295
2296                 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") );
2297
2298                 // we opened the profile so it is up to us to close it
2299                 CMCloseProfile(genericRGBProfile);
2300             }
2301         }
2302     }
2303
2304     return genericRGBColorSpace;
2305 }
2306 #endif
2307
2308 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
2309 {
2310     ::GetPort( &m_port );
2311     ::SetPort( port );
2312 }
2313
2314 wxMacPortSaver::~wxMacPortSaver()
2315 {
2316     ::SetPort( m_port );
2317 }
2318
2319 #endif // wxUSE_GUI