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