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