src/osx/carbon/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/carbon/window.cpp
   3 // Purpose:     wxWindowMac
   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/window.h"
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/log.h"
  18     #include "wx/app.h"
  19     #include "wx/utils.h"
  20     #include "wx/panel.h"
  21     #include "wx/frame.h"
  22     #include "wx/dc.h"
  23     #include "wx/dcclient.h"
  24     #include "wx/button.h"
  25     #include "wx/menu.h"
  26     #include "wx/dialog.h"
  27     #include "wx/settings.h"
  28     #include "wx/msgdlg.h"
  29     #include "wx/scrolbar.h"
  30     #include "wx/statbox.h"
  31     #include "wx/textctrl.h"
  32     #include "wx/toolbar.h"
  33     #include "wx/layout.h"
  34     #include "wx/statusbr.h"
  35     #include "wx/menuitem.h"
  36     #include "wx/treectrl.h"
  37     #include "wx/listctrl.h"
  38 #endif
  39
  40 #include "wx/tooltip.h"
  41 #include "wx/spinctrl.h"
  42 #include "wx/geometry.h"
  43
  44 #if wxUSE_LISTCTRL
  45     #include "wx/listctrl.h"
  46 #endif
  47
  48 #if wxUSE_TREECTRL
  49     #include "wx/treectrl.h"
  50 #endif
  51
  52 #if wxUSE_CARET
  53     #include "wx/caret.h"
  54 #endif
  55
  56 #if wxUSE_POPUPWIN
  57     #include "wx/popupwin.h"
  58 #endif
  59
  60 #if wxUSE_DRAG_AND_DROP
  61 #include "wx/dnd.h"
  62 #endif
  63
  64 #if wxOSX_USE_CARBON
  65 #include "wx/osx/uma.h"
  66 #else
  67 #include "wx/osx/private.h"
  68 // bring in themeing
  69 #include <Carbon/Carbon.h>
  70 #endif
  71
  72 #define MAC_SCROLLBAR_SIZE 15
  73 #define MAC_SMALL_SCROLLBAR_SIZE 11
  74
  75 #include <string.h>
  76
  77 #define wxMAC_DEBUG_REDRAW 0
  78 #ifndef wxMAC_DEBUG_REDRAW
  79 #define wxMAC_DEBUG_REDRAW 0
  80 #endif
  81
  82 // Get the window with the focus
  83 WXWidget wxWidgetImpl::FindFocus()
  84 {
  85     ControlRef control = NULL ;
  86     GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
  87     return control;
  88 }
  89
  90 // ---------------------------------------------------------------------------
  91 // Carbon Events
  92 // ---------------------------------------------------------------------------
  93
  94 static const EventTypeSpec eventList[] =
  95 {
  96     { kEventClassCommand, kEventProcessCommand } ,
  97     { kEventClassCommand, kEventCommandUpdateStatus } ,
  98
  99     { kEventClassControl , kEventControlGetClickActivation } ,
 100     { kEventClassControl , kEventControlHit } ,
 101
 102     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
 103     { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
 104
 105     { kEventClassControl , kEventControlDraw } ,
 106
 107     { kEventClassControl , kEventControlVisibilityChanged } ,
 108     { kEventClassControl , kEventControlEnabledStateChanged } ,
 109     { kEventClassControl , kEventControlHiliteChanged } ,
 110
 111     { kEventClassControl , kEventControlActivate } ,
 112     { kEventClassControl , kEventControlDeactivate } ,
 113
 114     { kEventClassControl , kEventControlSetFocusPart } ,
 115     { kEventClassControl , kEventControlFocusPartChanged } ,
 116
 117     { kEventClassService , kEventServiceGetTypes },
 118     { kEventClassService , kEventServiceCopy },
 119     { kEventClassService , kEventServicePaste },
 120
 121 //    { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
 122 //    { kEventClassControl , kEventControlBoundsChanged } ,
 123 } ;
 124
 125 static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 126 {
 127     OSStatus result = eventNotHandledErr ;
 128     static wxWindowMac* targetFocusWindow = NULL;
 129     static wxWindowMac* formerFocusWindow = NULL;
 130
 131     wxMacCarbonEvent cEvent( event ) ;
 132
 133     ControlRef controlRef ;
 134     wxWindowMac* thisWindow = (wxWindowMac*) data ;
 135
 136     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 137
 138     switch ( GetEventKind( event ) )
 139     {
 140         case kEventControlDraw :
 141             {
 142                 HIShapeRef updateRgn = NULL ;
 143                 HIMutableShapeRef allocatedRgn = NULL ;
 144                 wxRegion visRegion = thisWindow->MacGetVisibleRegion() ;
 145
 146                 // according to the docs: redraw entire control if param not present
 147                 if ( cEvent.GetParameter<HIShapeRef>(kEventParamShape, &updateRgn) != noErr )
 148                 {
 149                     updateRgn = visRegion.GetWXHRGN();
 150                 }
 151                 else
 152                 {
 153                     if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
 154                     {
 155                         // as this update region is in native window locals we must adapt it to wx window local
 156                         allocatedRgn = HIShapeCreateMutableCopy(updateRgn);
 157                         HIShapeOffset(allocatedRgn, thisWindow->MacGetLeftBorderSize() , thisWindow->MacGetTopBorderSize());
 158                         // hide the given region by the new region that must be shifted
 159                         updateRgn = allocatedRgn ;
 160                     }
 161                 }
 162
 163 #if wxMAC_DEBUG_REDRAW
 164                 if ( thisWindow->MacIsUserPane() )
 165                 {
 166                     static float color = 0.5 ;
 167                     static int channel = 0 ;
 168                     HIRect bounds;
 169                     CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
 170
 171                     HIViewGetBounds( controlRef, &bounds );
 172                     CGContextSetRGBFillColor( cgContext, channel == 0 ? color : 0.5 ,
 173                         channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
 174                     CGContextFillRect( cgContext, bounds );
 175                     color += 0.1 ;
 176                     if ( color > 0.9 )
 177                     {
 178                         color = 0.5 ;
 179                         channel++ ;
 180                         if ( channel == 3 )
 181                             channel = 0 ;
 182                     }
 183                 }
 184 #endif
 185
 186                 {
 187                     bool created = false ;
 188                     CGContextRef cgContext = NULL ;
 189                     OSStatus err = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) ;
 190                     if ( err != noErr )
 191                     {
 192                         wxFAIL_MSG("Unable to retrieve CGContextRef");
 193                     }
 194
 195                     thisWindow->MacSetCGContextRef( cgContext ) ;
 196
 197                     {
 198                         wxMacCGContextStateSaver sg( cgContext ) ;
 199                         CGFloat alpha = (CGFloat)1.0 ;
 200                         {
 201                             wxWindow* iter = thisWindow ;
 202                             while ( iter )
 203                             {
 204                                 alpha *= (CGFloat)( iter->GetTransparent()/255.0 ) ;
 205                                 if ( iter->IsTopLevel() )
 206                                     iter = NULL ;
 207                                 else
 208                                     iter = iter->GetParent() ;
 209                             }
 210                         }
 211                         CGContextSetAlpha( cgContext , alpha ) ;
 212
 213                         if ( thisWindow->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
 214                         {
 215                             HIRect bounds;
 216                             HIViewGetBounds( controlRef, &bounds );
 217                             CGContextClearRect( cgContext, bounds );
 218                         }
 219
 220                         if ( !HIShapeIsEmpty(updateRgn) )
 221                         {
 222                             // refcount increase because wxRegion constructor takes ownership of the native region
 223                             CFRetain(updateRgn);
 224                             thisWindow->GetUpdateRegion() = wxRegion(updateRgn);
 225                             if ( !thisWindow->MacDoRedraw( cEvent.GetTicks() ) )
 226                             {
 227                                // for native controls: call their native paint method
 228                                 if ( !thisWindow->MacIsUserPane() ||
 229                                     ( thisWindow->IsTopLevel() && thisWindow->GetBackgroundStyle() == wxBG_STYLE_SYSTEM ) )
 230                                 {
 231                                     if ( thisWindow->GetBackgroundStyle() != wxBG_STYLE_TRANSPARENT )
 232                                         CallNextEventHandler( handler ,event ) ;
 233                                 }
 234                             }
 235                             thisWindow->MacPaintChildrenBorders();
 236                         }
 237                         thisWindow->MacSetCGContextRef( NULL ) ;
 238                     }
 239
 240                     if ( created )
 241                         CGContextRelease( cgContext ) ;
 242                 }
 243
 244                 if ( allocatedRgn )
 245                     CFRelease( allocatedRgn ) ;
 246             }
 247             break ;
 248
 249         case kEventControlVisibilityChanged :
 250             // we might have two native controls attributed to the same wxWindow instance
 251             // eg a scrollview and an embedded textview, make sure we only fire for the 'outer'
 252             // control, as otherwise native and wx visibility are different
 253             if ( thisWindow->GetPeer() != NULL && thisWindow->GetPeer()->GetControlRef() == controlRef )
 254             {
 255                 thisWindow->MacVisibilityChanged() ;
 256             }
 257             break ;
 258
 259         case kEventControlEnabledStateChanged :
 260             thisWindow->MacEnabledStateChanged();
 261             break ;
 262
 263         case kEventControlHiliteChanged :
 264             thisWindow->MacHiliteChanged() ;
 265             break ;
 266
 267         case kEventControlActivate :
 268         case kEventControlDeactivate :
 269             // FIXME: we should have a virtual function for this!
 270 #if wxUSE_TREECTRL
 271             if ( thisWindow->IsKindOf( CLASSINFO( wxTreeCtrl ) ) )
 272                 thisWindow->Refresh();
 273 #endif
 274 #if wxUSE_LISTCTRL
 275             if ( thisWindow->IsKindOf( CLASSINFO( wxListCtrl ) ) )
 276                 thisWindow->Refresh();
 277 #endif
 278             break ;
 279
 280         //
 281         // focus handling
 282         // different handling on OS X
 283         //
 284
 285         case kEventControlFocusPartChanged :
 286             // the event is emulated by wxmac for systems lower than 10.5
 287             {
 288                 if ( UMAGetSystemVersion() < 0x1050 )
 289                 {
 290                     // as it is synthesized here, we have to manually avoid propagation
 291                     result = noErr;
 292                 }
 293                 ControlPartCode previousControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPreviousPart , typeControlPartCode );
 294                 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlCurrentPart , typeControlPartCode );
 295
 296                 if ( thisWindow->MacGetTopLevelWindow() && thisWindow->GetPeer()->NeedsFocusRect() )
 297                 {
 298                     thisWindow->MacInvalidateBorders();
 299                 }
 300
 301                 if ( currentControlPart == 0 )
 302                 {
 303                     // kill focus
 304 #if wxUSE_CARET
 305                     if ( thisWindow->GetCaret() )
 306                         thisWindow->GetCaret()->OnKillFocus();
 307 #endif
 308
 309                     wxLogTrace(_T("Focus"), _T("focus lost(%p)"), static_cast<void*>(thisWindow));
 310
 311                     // remove this as soon as posting the synthesized event works properly
 312                     static bool inKillFocusEvent = false ;
 313
 314                     if ( !inKillFocusEvent )
 315                     {
 316                         inKillFocusEvent = true ;
 317                         wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
 318                         event.SetEventObject(thisWindow);
 319                         event.SetWindow(targetFocusWindow);
 320                         thisWindow->HandleWindowEvent(event) ;
 321                         inKillFocusEvent = false ;
 322                         targetFocusWindow = NULL;
 323                     }
 324                 }
 325                 else if ( previousControlPart == 0 )
 326                 {
 327                     // set focus
 328                     // panel wants to track the window which was the last to have focus in it
 329                     wxLogTrace(_T("Focus"), _T("focus set(%p)"), static_cast<void*>(thisWindow));
 330                     wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
 331                     thisWindow->HandleWindowEvent(eventFocus);
 332
 333 #if wxUSE_CARET
 334                     if ( thisWindow->GetCaret() )
 335                         thisWindow->GetCaret()->OnSetFocus();
 336 #endif
 337
 338                     wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
 339                     event.SetEventObject(thisWindow);
 340                     event.SetWindow(formerFocusWindow);
 341                     thisWindow->HandleWindowEvent(event) ;
 342                     formerFocusWindow = NULL;
 343                 }
 344             }
 345             break;
 346         case kEventControlSetFocusPart :
 347             {
 348                 Boolean focusEverything = false ;
 349                 if ( cEvent.GetParameter<Boolean>(kEventParamControlFocusEverything , &focusEverything ) == noErr )
 350                 {
 351                     // put a breakpoint here to catch focus everything events
 352                 }
 353                 ControlPartCode controlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
 354                 if ( controlPart != kControlFocusNoPart )
 355                 {
 356                     targetFocusWindow = thisWindow;
 357                     wxLogTrace(_T("Focus"), _T("focus to be set(%p)"), static_cast<void*>(thisWindow));
 358                 }
 359                 else
 360                 {
 361                     formerFocusWindow = thisWindow;
 362                     wxLogTrace(_T("Focus"), _T("focus to be lost(%p)"), static_cast<void*>(thisWindow));
 363                 }
 364
 365                 ControlPartCode previousControlPart = 0;
 366                 verify_noerr( HIViewGetFocusPart(controlRef, &previousControlPart));
 367
 368                 if ( thisWindow->MacIsUserPane() )
 369                 {
 370                     if ( controlPart != kControlFocusNoPart )
 371                         cEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, 1 ) ;
 372                     result = noErr ;
 373                 }
 374                 else
 375                     result = CallNextEventHandler(handler, event);
 376
 377                 if ( UMAGetSystemVersion() < 0x1050 )
 378                 {
 379 // set back to 0 if problems arise
 380 #if 1
 381                     if ( result == noErr )
 382                     {
 383                         ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
 384                         // synthesize the event focus changed event
 385                         EventRef evRef = NULL ;
 386
 387                         OSStatus err = MacCreateEvent(
 388                                              NULL , kEventClassControl , kEventControlFocusPartChanged , TicksToEventTime( TickCount() ) ,
 389                                              kEventAttributeUserEvent , &evRef );
 390                         verify_noerr( err );
 391
 392                         wxMacCarbonEvent iEvent( evRef ) ;
 393                         iEvent.SetParameter<ControlRef>( kEventParamDirectObject , controlRef );
 394                         iEvent.SetParameter<EventTargetRef>( kEventParamPostTarget, typeEventTargetRef, GetControlEventTarget( controlRef ) );
 395                         iEvent.SetParameter<ControlPartCode>( kEventParamControlPreviousPart, typeControlPartCode, previousControlPart );
 396                         iEvent.SetParameter<ControlPartCode>( kEventParamControlCurrentPart, typeControlPartCode, currentControlPart );
 397
 398 #if 1
 399                         // TODO test this first, avoid double posts etc...
 400                         PostEventToQueue( GetMainEventQueue(), evRef , kEventPriorityHigh );
 401 #else
 402                         wxMacWindowControlEventHandler( NULL , evRef , data ) ;
 403 #endif
 404                         ReleaseEvent( evRef ) ;
 405                     }
 406 #else
 407                     // old implementation, to be removed if the new one works
 408                     if ( controlPart == kControlFocusNoPart )
 409                     {
 410 #if wxUSE_CARET
 411                         if ( thisWindow->GetCaret() )
 412                             thisWindow->GetCaret()->OnKillFocus();
 413 #endif
 414
 415                         wxLogTrace(_T("Focus"), _T("focus lost(%p)"), static_cast<void*>(thisWindow));
 416
 417                         static bool inKillFocusEvent = false ;
 418
 419                         if ( !inKillFocusEvent )
 420                         {
 421                             inKillFocusEvent = true ;
 422                             wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
 423                             event.SetEventObject(thisWindow);
 424                             thisWindow->HandleWindowEvent(event) ;
 425                             inKillFocusEvent = false ;
 426                         }
 427                     }
 428                     else
 429                     {
 430                         // panel wants to track the window which was the last to have focus in it
 431                         wxLogTrace(_T("Focus"), _T("focus set(%p)"), static_cast<void*>(thisWindow));
 432                         wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
 433                         thisWindow->HandleWindowEvent(eventFocus);
 434
 435     #if wxUSE_CARET
 436                         if ( thisWindow->GetCaret() )
 437                             thisWindow->GetCaret()->OnSetFocus();
 438     #endif
 439
 440                         wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
 441                         event.SetEventObject(thisWindow);
 442                         thisWindow->HandleWindowEvent(event) ;
 443                     }
 444 #endif
 445                 }
 446             }
 447             break ;
 448
 449         case kEventControlHit :
 450             result = thisWindow->MacControlHit( handler , event ) ;
 451             break ;
 452
 453         case kEventControlGetClickActivation :
 454             {
 455                 // fix to always have a proper activation for DataBrowser controls (stay in bkgnd otherwise)
 456                 WindowRef owner = cEvent.GetParameter<WindowRef>(kEventParamWindowRef);
 457                 if ( !IsWindowActive(owner) )
 458                 {
 459                     cEvent.SetParameter(kEventParamClickActivation,typeClickActivationResult, (UInt32) kActivateAndIgnoreClick) ;
 460                     result = noErr ;
 461                 }
 462             }
 463             break ;
 464
 465         default :
 466             break ;
 467     }
 468
 469     return result ;
 470 }
 471
 472 static pascal OSStatus
 473 wxMacWindowServiceEventHandler(EventHandlerCallRef WXUNUSED(handler),
 474                                EventRef event,
 475                                void *data)
 476 {
 477     OSStatus result = eventNotHandledErr ;
 478
 479     wxMacCarbonEvent cEvent( event ) ;
 480
 481     ControlRef controlRef ;
 482     wxWindowMac* thisWindow = (wxWindowMac*) data ;
 483     wxTextCtrl* textCtrl = wxDynamicCast( thisWindow , wxTextCtrl ) ;
 484     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 485
 486     switch ( GetEventKind( event ) )
 487     {
 488         case kEventServiceGetTypes :
 489             if ( textCtrl )
 490             {
 491                 long from, to ;
 492                 textCtrl->GetSelection( &from , &to ) ;
 493
 494                 CFMutableArrayRef copyTypes = 0 , pasteTypes = 0;
 495                 if ( from != to )
 496                     copyTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServiceCopyTypes , typeCFMutableArrayRef ) ;
 497                 if ( textCtrl->IsEditable() )
 498                     pasteTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServicePasteTypes , typeCFMutableArrayRef ) ;
 499
 500                 static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt', 'PICT', 'MooV', 'AIFF' */  };
 501                 for ( size_t i = 0 ; i < WXSIZEOF(textDataTypes) ; ++i )
 502                 {
 503                     CFStringRef typestring = CreateTypeStringWithOSType(textDataTypes[i]);
 504                     if ( typestring )
 505                     {
 506                         if ( copyTypes )
 507                             CFArrayAppendValue(copyTypes, typestring) ;
 508                         if ( pasteTypes )
 509                             CFArrayAppendValue(pasteTypes, typestring) ;
 510
 511                         CFRelease( typestring ) ;
 512                     }
 513                 }
 514
 515                 result = noErr ;
 516             }
 517             break ;
 518
 519         case kEventServiceCopy :
 520             if ( textCtrl )
 521             {
 522                 long from, to ;
 523
 524                 textCtrl->GetSelection( &from , &to ) ;
 525                 wxString val = textCtrl->GetValue() ;
 526                 val = val.Mid( from , to - from ) ;
 527                 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
 528                 verify_noerr( PasteboardClear( pasteboard ) ) ;
 529                 PasteboardSynchronize( pasteboard );
 530                 // TODO add proper conversion
 531                 CFDataRef data = CFDataCreate( kCFAllocatorDefault, (const UInt8*)val.c_str(), val.length() );
 532                 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) 1, CFSTR("com.apple.traditional-mac-plain-text"), data, 0);
 533                 CFRelease( data );
 534                 result = noErr ;
 535             }
 536             break ;
 537
 538         case kEventServicePaste :
 539             if ( textCtrl )
 540             {
 541                 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
 542                 PasteboardSynchronize( pasteboard );
 543                 ItemCount itemCount;
 544                 verify_noerr( PasteboardGetItemCount( pasteboard, &itemCount ) );
 545                 for( UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++ )
 546                 {
 547                     PasteboardItemID itemID;
 548                     if ( PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ) == noErr )
 549                     {
 550                         CFDataRef flavorData = NULL;
 551                         if ( PasteboardCopyItemFlavorData( pasteboard, itemID, CFSTR("com.apple.traditional-mac-plain-text"), &flavorData ) == noErr )
 552                         {
 553                             CFIndex flavorDataSize = CFDataGetLength( flavorData );
 554                             char *content = new char[flavorDataSize+1] ;
 555                             memcpy( content, CFDataGetBytePtr( flavorData ), flavorDataSize );
 556                             content[flavorDataSize]=0;
 557                             CFRelease( flavorData );
 558 #if wxUSE_UNICODE
 559                             textCtrl->WriteText( wxString( content , wxConvLocal ) );
 560 #else
 561                             textCtrl->WriteText( wxString( content ) ) ;
 562 #endif
 563
 564                             delete[] content ;
 565                             result = noErr ;
 566                         }
 567                     }
 568                 }
 569             }
 570             break ;
 571
 572         default:
 573             break ;
 574     }
 575
 576     return result ;
 577 }
 578
 579 pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 580 {
 581     OSStatus result = eventNotHandledErr ;
 582     wxWindowMac* focus = (wxWindowMac*) data ;
 583
 584     wchar_t* uniChars = NULL ;
 585     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 586
 587     UniChar* charBuf = NULL;
 588     ByteCount dataSize = 0 ;
 589     int numChars = 0 ;
 590     UniChar buf[2] ;
 591     if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
 592     {
 593         numChars = dataSize / sizeof( UniChar) + 1;
 594         charBuf = buf ;
 595
 596         if ( (size_t) numChars * 2 > sizeof(buf) )
 597             charBuf = new UniChar[ numChars ] ;
 598         else
 599             charBuf = buf ;
 600
 601         uniChars = new wchar_t[ numChars ] ;
 602         GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
 603         charBuf[ numChars - 1 ] = 0;
 604 #if SIZEOF_WCHAR_T == 2
 605         uniChars = (wchar_t*) charBuf ;
 606 /*        memcpy( uniChars , charBuf , numChars * 2 ) ;*/   // is there any point in copying charBuf over itself? (in fact, memcpy isn't even guaranteed to work correctly if the source and destination ranges overlap...)
 607 #else
 608         // the resulting string will never have more chars than the utf16 version, so this is safe
 609         wxMBConvUTF16 converter ;
 610         numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
 611 #endif
 612     }
 613
 614     switch ( GetEventKind( event ) )
 615     {
 616         case kEventTextInputUpdateActiveInputArea :
 617             {
 618                 // An IME input event may return several characters, but we need to send one char at a time to
 619                 // EVT_CHAR
 620                 for (int pos=0 ; pos < numChars ; pos++)
 621                 {
 622                     WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 623                     WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 624                     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 625
 626                     UInt32 message = uniChars[pos] < 128 ? (char)uniChars[pos] : '?';
 627 /*
 628     NB: faking a charcode here is problematic. The kEventTextInputUpdateActiveInputArea event is sent
 629     multiple times to update the active range during inline input, so this handler will often receive
 630     uncommited text, which should usually not trigger side effects. It might be a good idea to check the
 631     kEventParamTextInputSendFixLen parameter and verify if input is being confirmed (see CarbonEvents.h).
 632     On the other hand, it can be useful for some applications to react to uncommitted text (for example,
 633     to update a status display), as long as it does not disrupt the inline input session. Ideally, wx
 634     should add new event types to support advanced text input. For now, I would keep things as they are.
 635
 636     However, the code that was being used caused additional problems:
 637                     UInt32 message = (0  << 8) + ((char)uniChars[pos] );
 638     Since it simply truncated the unichar to the last byte, it ended up causing weird bugs with inline
 639     input, such as switching to another field when one attempted to insert the character U+4E09 (the kanji
 640     for "three"), because it was truncated to 09 (kTabCharCode), which was later "converted" to WXK_TAB
 641     (still 09) in wxMacTranslateKey; or triggering the default button when one attempted to insert U+840D
 642     (the kanji for "name"), which got truncated to 0D and interpreted as a carriage return keypress.
 643     Note that even single-byte characters could have been misinterpreted, since MacRoman charcodes only
 644     overlap with Unicode within the (7-bit) ASCII range.
 645     But simply passing a NUL charcode would disable text updated events, because wxTextCtrl::OnChar checks
 646     for codes within a specific range. Therefore I went for the solution seen above, which keeps ASCII
 647     characters as they are and replaces the rest with '?', ensuring that update events are triggered.
 648     It would be better to change wxTextCtrl::OnChar to look at the actual unicode character instead, but
 649     I don't have time to look into that right now.
 650         -- CL
 651 */
 652                     if ( wxTheApp->MacSendCharEvent(
 653                                                     focus , message , 0 , when , 0 , 0 , uniChars[pos] ) )
 654                     {
 655                         result = noErr ;
 656                     }
 657
 658                     wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 659                 }
 660             }
 661             break ;
 662         case kEventTextInputUnicodeForKeyEvent :
 663             {
 664                 UInt32 keyCode, modifiers ;
 665                 Point point ;
 666                 EventRef rawEvent ;
 667                 unsigned char charCode ;
 668
 669                 GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
 670                 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
 671                 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
 672                 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
 673                 GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
 674
 675                 UInt32 message = (keyCode << 8) + charCode;
 676
 677                 // An IME input event may return several characters, but we need to send one char at a time to
 678                 // EVT_CHAR
 679                 for (int pos=0 ; pos < numChars ; pos++)
 680                 {
 681                     WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 682                     WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 683                     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 684
 685                     if ( wxTheApp->MacSendCharEvent(
 686                         focus , message , modifiers , when , point.h , point.v , uniChars[pos] ) )
 687                     {
 688                         result = noErr ;
 689                     }
 690
 691                     wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 692                 }
 693             }
 694             break;
 695         default:
 696             break ;
 697     }
 698
 699     delete [] uniChars ;
 700     if ( charBuf != buf )
 701         delete [] charBuf ;
 702
 703     return result ;
 704 }
 705
 706 static pascal OSStatus
 707 wxMacWindowCommandEventHandler(EventHandlerCallRef WXUNUSED(handler),
 708                                EventRef event,
 709                                void *data)
 710 {
 711     OSStatus result = eventNotHandledErr ;
 712     wxWindowMac* focus = (wxWindowMac*) data ;
 713
 714     HICommand command ;
 715
 716     wxMacCarbonEvent cEvent( event ) ;
 717     cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
 718
 719     wxMenuItem* item = NULL ;
 720     wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
 721
 722     if ( item )
 723     {
 724         wxASSERT( itemMenu != NULL ) ;
 725
 726         switch ( cEvent.GetKind() )
 727         {
 728             case kEventProcessCommand :
 729                 if ( itemMenu->HandleCommandProcess( item, focus ) )
 730                     result = noErr;
 731             break ;
 732
 733             case kEventCommandUpdateStatus:
 734                 if ( itemMenu->HandleCommandUpdateStatus( item, focus ) )
 735                     result = noErr;
 736                 break ;
 737
 738             default :
 739                 break ;
 740         }
 741     }
 742     return result ;
 743 }
 744
 745 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 746 {
 747     EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
 748     EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 749     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 750     OSStatus result = eventNotHandledErr ;
 751
 752     switch ( GetEventClass( event ) )
 753     {
 754         case kEventClassCommand :
 755             result = wxMacWindowCommandEventHandler( handler , event , data ) ;
 756             break ;
 757
 758         case kEventClassControl :
 759             result = wxMacWindowControlEventHandler( handler, event, data ) ;
 760             break ;
 761
 762         case kEventClassService :
 763             result = wxMacWindowServiceEventHandler( handler, event , data ) ;
 764             break ;
 765
 766         case kEventClassTextInput :
 767             result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
 768             break ;
 769
 770         default :
 771             break ;
 772     }
 773
 774     wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
 775
 776     return result ;
 777 }
 778
 779 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
 780
 781 // ---------------------------------------------------------------------------
 782 // Scrollbar Tracking for all
 783 // ---------------------------------------------------------------------------
 784
 785 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode ) ;
 786 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode )
 787 {
 788     if ( partCode != 0)
 789     {
 790         wxWindow*  wx = wxFindWindowFromWXWidget(  (WXWidget) control ) ;
 791         if ( wx )
 792         {
 793             wxEventType scrollEvent = wxEVT_NULL;
 794             switch ( partCode )
 795             {
 796             case kControlUpButtonPart:
 797                 scrollEvent = wxEVT_SCROLL_LINEUP;
 798                 break;
 799
 800             case kControlDownButtonPart:
 801                 scrollEvent = wxEVT_SCROLL_LINEDOWN;
 802                 break;
 803
 804             case kControlPageUpPart:
 805                 scrollEvent = wxEVT_SCROLL_PAGEUP;
 806                 break;
 807
 808             case kControlPageDownPart:
 809                 scrollEvent = wxEVT_SCROLL_PAGEDOWN;
 810                 break;
 811
 812             case kControlIndicatorPart:
 813                 scrollEvent = wxEVT_SCROLL_THUMBTRACK;
 814                 // when this is called as a live proc, mouse is always still down
 815                 // so no need for thumbrelease
 816                 // scrollEvent = wxEVT_SCROLL_THUMBRELEASE;
 817                 break;
 818             }
 819             wx->TriggerScrollEvent(scrollEvent) ;
 820         }
 821     }
 822 }
 823 wxMAC_DEFINE_PROC_GETTER( ControlActionUPP , wxMacLiveScrollbarActionProc ) ;
 824
 825 wxWidgetImplType* wxWidgetImpl::CreateUserPane( wxWindowMac* wxpeer, wxWindowMac* parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
 826                             long style, long extraStyle)
 827 {
 828     OSStatus err = noErr;
 829     Rect bounds = wxMacGetBoundsForControl( wxpeer , pos , size ) ;
 830     wxMacControl* c = new wxMacControl(wxpeer) ;
 831     UInt32 features = 0
 832         | kControlSupportsEmbedding
 833         | kControlSupportsLiveFeedback
 834         | kControlGetsFocusOnClick
 835 //            | kControlHasSpecialBackground
 836 //            | kControlSupportsCalcBestRect
 837         | kControlHandlesTracking
 838         | kControlSupportsFocus
 839         | kControlWantsActivate
 840         | kControlWantsIdle ;
 841
 842     err =::CreateUserPaneControl( MAC_WXHWND(wxpeer->GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , c->GetControlRefAddr() );
 843     verify_noerr( err );
 844     return c;
 845 }
 846
 847
 848 void wxMacControl::InstallEventHandler( WXWidget control )
 849 {
 850     wxWidgetImpl::Associate( control ? control : (WXWidget) m_controlRef , this ) ;
 851     ::InstallControlEventHandler( control ? (ControlRef) control : m_controlRef , GetwxMacWindowEventHandlerUPP(),
 852         GetEventTypeCount(eventList), eventList, GetWXPeer(), NULL);
 853 }
 854
 855 IMPLEMENT_DYNAMIC_CLASS( wxMacControl , wxWidgetImpl )
 856
 857 wxMacControl::wxMacControl()
 858 {
 859     Init();
 860 }
 861
 862 wxMacControl::wxMacControl(wxWindowMac* peer , bool isRootControl ) :
 863     wxWidgetImpl( peer, isRootControl )
 864 {
 865     Init();
 866 }
 867
 868 wxMacControl::~wxMacControl()
 869 {
 870     if ( m_controlRef && !IsRootControl() )
 871     {
 872         wxASSERT_MSG( m_controlRef != NULL , wxT("Control Handle already NULL, Dispose called twice ?") );
 873         wxASSERT_MSG( IsValidControlHandle(m_controlRef) , wxT("Invalid Control Handle (maybe already released) in Dispose") );
 874
 875         wxWidgetImpl::RemoveAssociations( this ) ;
 876         // we cannot check the ref count here anymore, as autorelease objects might delete their refs later
 877         // we can have situations when being embedded, where the control gets deleted behind our back, so only
 878         // CFRelease if we are safe
 879         if ( IsValidControlHandle(m_controlRef) )
 880             CFRelease(m_controlRef);
 881     }
 882     m_controlRef = NULL;
 883 }
 884
 885 void wxMacControl::Init()
 886 {
 887     m_controlRef = NULL;
 888     m_macControlEventHandler = NULL;
 889 }
 890
 891 void wxMacControl::RemoveFromParent()
 892 {
 893     // nothing to do here for carbon
 894     HIViewRemoveFromSuperview(m_controlRef);
 895 }
 896
 897 void wxMacControl::Embed( wxWidgetImpl *parent )
 898 {
 899     HIViewAddSubview((ControlRef)parent->GetWXWidget(), m_controlRef);
 900 }
 901
 902 void wxMacControl::SetNeedsDisplay( const wxRect* rect )
 903 {
 904     if ( !IsVisible() )
 905         return;
 906
 907     if ( rect != NULL )
 908     {
 909         HIRect updatearea = CGRectMake( rect->x , rect->y , rect->width , rect->height);
 910         HIViewSetNeedsDisplayInRect( m_controlRef, &updatearea, true );
 911     }
 912     else
 913         HIViewSetNeedsDisplay( m_controlRef , true );
 914 }
 915
 916 void wxMacControl::Raise()
 917 {
 918     verify_noerr( HIViewSetZOrder( m_controlRef, kHIViewZOrderAbove, NULL ) );
 919 }
 920
 921 void wxMacControl::Lower()
 922 {
 923     verify_noerr( HIViewSetZOrder( m_controlRef, kHIViewZOrderBelow, NULL ) );
 924 }
 925
 926 void wxMacControl::GetContentArea(int &left , int &top , int &width , int &height) const
 927 {
 928     HIShapeRef rgn = NULL;
 929     Rect content ;
 930
 931     if ( HIViewCopyShape(m_controlRef, kHIViewContentMetaPart, &rgn) == noErr)
 932     {
 933         CGRect cgrect;
 934         HIShapeGetBounds(rgn, &cgrect);
 935         content = (Rect){ cgrect.origin.y, cgrect.origin.x, cgrect.origin.y+cgrect.size.height, cgrect.origin.x+cgrect.size.width };
 936         CFRelease(rgn);
 937     }
 938     else
 939     {
 940         GetControlBounds(m_controlRef, &content);
 941         content.right -= content.left;
 942         content.left = 0;
 943         content.bottom -= content.top;
 944         content.top = 0;
 945     }
 946
 947     left = content.left;
 948     top = content.top;
 949
 950     width = content.right - content.left ;
 951     height = content.bottom - content.top ;
 952 }
 953
 954 void wxMacControl::Move(int x, int y, int width, int height)
 955 {
 956     HIRect hir = CGRectMake(x,y,width,height);
 957     HIViewSetFrame ( m_controlRef , &hir );
 958 }
 959
 960 void wxMacControl::GetPosition( int &x, int &y ) const
 961 {
 962     Rect r;
 963     GetControlBounds( m_controlRef , &r );
 964     x = r.left;
 965     y = r.top;
 966 }
 967
 968 void wxMacControl::GetSize( int &width, int &height ) const
 969 {
 970     Rect r;
 971     GetControlBounds( m_controlRef , &r );
 972     width = r.right - r.left;
 973     height = r.bottom - r.top;
 974 }
 975
 976 void wxMacControl::SetControlSize( wxWindowVariant variant )
 977 {
 978     ControlSize size ;
 979     switch ( variant )
 980     {
 981         case wxWINDOW_VARIANT_NORMAL :
 982             size = kControlSizeNormal;
 983             break ;
 984
 985         case wxWINDOW_VARIANT_SMALL :
 986             size = kControlSizeSmall;
 987             break ;
 988
 989         case wxWINDOW_VARIANT_MINI :
 990             // not always defined in the headers
 991             size = 3 ;
 992             break ;
 993
 994         case wxWINDOW_VARIANT_LARGE :
 995             size = kControlSizeLarge;
 996             break ;
 997
 998         default:
 999             wxFAIL_MSG(_T("unexpected window variant"));
1000             break ;
1001     }
1002
1003     SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
1004 }
1005
1006 void wxMacControl::ScrollRect( const wxRect *rect, int dx, int dy )
1007 {
1008     if (GetNeedsDisplay() )
1009     {
1010         // because HIViewScrollRect does not scroll the already invalidated area we have two options:
1011         // in case there is already a pending redraw on that area
1012         // either immediate redraw or full invalidate
1013 #if 1
1014         // is the better overall solution, as it does not slow down scrolling
1015         SetNeedsDisplay() ;
1016 #else
1017         // this would be the preferred version for fast drawing controls
1018         HIViewRender(GetControlRef()) ;
1019 #endif
1020     }
1021
1022     // note there currently is a bug in OSX (10.3 +?) which makes inefficient refreshes in case an entire control
1023     // area is scrolled, this does not occur if width and height are 2 pixels less,
1024     // TODO: write optimal workaround
1025
1026     HIRect scrollarea = CGRectMake( rect->x , rect->y , rect->width , rect->height);
1027     HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1028
1029 #if 0
1030     // this would be the preferred version for fast drawing controls
1031     HIViewRender(GetControlRef()) ;
1032 #endif
1033 }
1034
1035 bool wxMacControl::CanFocus() const
1036 {
1037     // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
1038     // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning,
1039     // but the value range is nowhere documented
1040     Boolean keyExistsAndHasValidFormat ;
1041     CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue( CFSTR("AppleKeyboardUIMode" ) ,
1042         kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat );
1043
1044     if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
1045     {
1046         return true ;
1047     }
1048     else
1049     {
1050         UInt32 features = 0 ;
1051         GetControlFeatures( m_controlRef, &features ) ;
1052
1053         return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
1054     }
1055 }
1056
1057 bool wxMacControl::GetNeedsDisplay() const
1058 {
1059     return HIViewGetNeedsDisplay( m_controlRef );
1060 }
1061
1062 void  wxWidgetImpl::Convert( wxPoint *pt , wxWidgetImpl *from , wxWidgetImpl *to )
1063 {
1064     HIPoint hiPoint;
1065
1066     hiPoint.x = pt->x;
1067     hiPoint.y = pt->y;
1068     HIViewConvertPoint( &hiPoint , (ControlRef) from->GetWXWidget() , (ControlRef) to->GetWXWidget()  );
1069     pt->x = (int)hiPoint.x;
1070     pt->y = (int)hiPoint.y;
1071 }
1072
1073 bool wxMacControl::SetFocus()
1074 {
1075     // as we cannot rely on the control features to find out whether we are in full keyboard mode,
1076     // we can only leave in case of an error
1077
1078     OSStatus err = SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, kControlFocusNextPart );
1079     if ( err == errCouldntSetFocus )
1080         return false ;
1081     SetUserFocusWindow(GetControlOwner( m_controlRef ) );
1082
1083     return true;
1084 }
1085
1086 bool wxMacControl::HasFocus() const
1087 {
1088     ControlRef control;
1089     GetKeyboardFocus( GetUserFocusWindow() , &control );
1090     return control == m_controlRef;
1091 }
1092
1093 void wxMacControl::SetCursor(const wxCursor& cursor)
1094 {
1095     wxWindowMac *mouseWin = 0 ;
1096     WindowRef window = GetControlOwner( m_controlRef ) ;
1097
1098     wxNonOwnedWindow* tlwwx = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) window ) ;
1099     if ( tlwwx != NULL )
1100     {
1101         ControlPartCode part ;
1102         ControlRef control ;
1103         Point pt ;
1104 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1105         HIPoint hiPoint ;
1106         HIGetMousePosition(kHICoordSpaceWindow, window, &hiPoint);
1107         pt.h = hiPoint.x;
1108         pt.v = hiPoint.y;
1109 #else
1110         GetGlobalMouse( &pt );
1111         int x = pt.h;
1112         int y = pt.v;
1113         tlwwx->ScreenToClient(&x, &y);
1114         pt.h = x;
1115         pt.v = y;
1116 #endif
1117         control = FindControlUnderMouse( pt , window , &part ) ;
1118         if ( control )
1119             mouseWin = wxFindWindowFromWXWidget( (WXWidget) control ) ;
1120     }
1121
1122     if ( mouseWin == tlwwx && !wxIsBusy() )
1123         cursor.MacInstall() ;
1124 }
1125
1126 void wxMacControl::CaptureMouse()
1127 {
1128 }
1129
1130 void wxMacControl::ReleaseMouse()
1131 {
1132 }
1133
1134 //
1135 // subclass specifics
1136 //
1137
1138 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
1139 {
1140     return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
1141 }
1142
1143 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
1144 {
1145     return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
1146 }
1147
1148 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
1149 {
1150     return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
1151 }
1152
1153 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
1154 {
1155     return SendEventToEventTargetWithOptions( event,
1156         HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
1157 }
1158
1159 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
1160 {
1161     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
1162
1163     event.SetParameter<HICommand>(kEventParamDirectObject,command);
1164
1165     return SendEvent( event , inOptions );
1166 }
1167
1168 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions  )
1169 {
1170     HICommand command;
1171
1172     memset( &command, 0 , sizeof(command) );
1173     command.commandID = commandID;
1174     return SendHICommand( command , inOptions );
1175 }
1176
1177 void wxMacControl::PerformClick()
1178 {
1179     HIViewSimulateClick (m_controlRef, kControlButtonPart, 0, NULL );
1180 }
1181
1182 wxInt32 wxMacControl::GetValue() const
1183 {
1184     return ::GetControl32BitValue( m_controlRef );
1185 }
1186
1187 wxInt32 wxMacControl::GetMaximum() const
1188 {
1189     return ::GetControl32BitMaximum( m_controlRef );
1190 }
1191
1192 wxInt32 wxMacControl::GetMinimum() const
1193 {
1194     return ::GetControl32BitMinimum( m_controlRef );
1195 }
1196
1197 void wxMacControl::SetValue( wxInt32 v )
1198 {
1199     ::SetControl32BitValue( m_controlRef , v );
1200 }
1201
1202 void wxMacControl::SetMinimum( wxInt32 v )
1203 {
1204     ::SetControl32BitMinimum( m_controlRef , v );
1205 }
1206
1207 void wxMacControl::SetMaximum( wxInt32 v )
1208 {
1209     ::SetControl32BitMaximum( m_controlRef , v );
1210 }
1211
1212 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
1213 {
1214     ::SetControl32BitMinimum( m_controlRef , minimum );
1215     ::SetControl32BitMaximum( m_controlRef , maximum );
1216     ::SetControl32BitValue( m_controlRef , value );
1217 }
1218
1219 void wxMacControl::VisibilityChanged(bool WXUNUSED(shown))
1220 {
1221 }
1222
1223 void wxMacControl::SuperChangedPosition()
1224 {
1225 }
1226
1227 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack )
1228 {
1229     m_font = font;
1230 #if wxOSX_USE_CORE_TEXT
1231     if ( UMAGetSystemVersion() >= 0x1050 )
1232     {
1233         HIViewPartCode part = 0;
1234         HIThemeTextHorizontalFlush flush = kHIThemeTextHorizontalFlushDefault;
1235         if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1236             flush = kHIThemeTextHorizontalFlushCenter;
1237         else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1238             flush = kHIThemeTextHorizontalFlushRight;
1239         HIViewSetTextFont( m_controlRef , part , (CTFontRef) font.OSXGetCTFont() );
1240         HIViewSetTextHorizontalFlush( m_controlRef, part, flush );
1241
1242         if ( foreground != *wxBLACK || ignoreBlack == false )
1243         {
1244             ControlFontStyleRec fontStyle;
1245             foreground.GetRGBColor( &fontStyle.foreColor );
1246             fontStyle.flags = kControlUseForeColorMask;
1247             ::SetControlFontStyle( m_controlRef , &fontStyle );
1248         }
1249     }
1250 #endif
1251 #if wxOSX_USE_ATSU_TEXT
1252     ControlFontStyleRec fontStyle;
1253     if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
1254     {
1255         switch ( font.MacGetThemeFontID() )
1256         {
1257             case kThemeSmallSystemFont :
1258                 fontStyle.font = kControlFontSmallSystemFont;
1259                 break;
1260
1261             case 109 : // mini font
1262                 fontStyle.font = -5;
1263                 break;
1264
1265             case kThemeSystemFont :
1266                 fontStyle.font = kControlFontBigSystemFont;
1267                 break;
1268
1269             default :
1270                 fontStyle.font = kControlFontBigSystemFont;
1271                 break;
1272         }
1273
1274         fontStyle.flags = kControlUseFontMask;
1275     }
1276     else
1277     {
1278         fontStyle.font = font.MacGetFontNum();
1279         fontStyle.style = font.MacGetFontStyle();
1280         fontStyle.size = font.GetPointSize();
1281         fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
1282     }
1283
1284     fontStyle.just = teJustLeft;
1285     fontStyle.flags |= kControlUseJustMask;
1286     if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1287         fontStyle.just = teJustCenter;
1288     else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1289         fontStyle.just = teJustRight;
1290
1291
1292     // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1293     // won't get grayed out by the system anymore
1294
1295     if ( foreground != *wxBLACK || ignoreBlack == false )
1296     {
1297         foreground.GetRGBColor( &fontStyle.foreColor );
1298         fontStyle.flags |= kControlUseForeColorMask;
1299     }
1300
1301     ::SetControlFontStyle( m_controlRef , &fontStyle );
1302 #endif
1303 }
1304
1305 void wxMacControl::SetBackgroundColour( const wxColour &WXUNUSED(col) )
1306 {
1307 //    HITextViewSetBackgroundColor( m_textView , color );
1308 }
1309
1310 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1311 {
1312     ::SetControl32BitMinimum( m_controlRef , minimum );
1313     ::SetControl32BitMaximum( m_controlRef , maximum );
1314 }
1315
1316 short wxMacControl::HandleKey( SInt16 keyCode,  SInt16 charCode, EventModifiers modifiers )
1317 {
1318     return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1319 }
1320
1321 void wxMacControl::SetActionProc( ControlActionUPP   actionProc )
1322 {
1323     SetControlAction( m_controlRef , actionProc );
1324 }
1325
1326 SInt32 wxMacControl::GetViewSize() const
1327 {
1328     return GetControlViewSize( m_controlRef );
1329 }
1330
1331 bool wxMacControl::IsVisible() const
1332 {
1333     return IsControlVisible( m_controlRef );
1334 }
1335
1336 void wxMacControl::SetVisibility( bool visible )
1337 {
1338     SetControlVisibility( m_controlRef , visible, true );
1339 }
1340
1341 bool wxMacControl::IsEnabled() const
1342 {
1343     return IsControlEnabled( m_controlRef );
1344 }
1345
1346 bool wxMacControl::IsActive() const
1347 {
1348     return IsControlActive( m_controlRef );
1349 }
1350
1351 void wxMacControl::Enable( bool enable )
1352 {
1353     if ( enable )
1354         EnableControl( m_controlRef );
1355     else
1356         DisableControl( m_controlRef );
1357 }
1358
1359 void wxMacControl::SetDrawingEnabled( bool enable )
1360 {
1361     HIViewSetDrawingEnabled( m_controlRef , enable );
1362 }
1363
1364 void wxMacControl::GetRectInWindowCoords( Rect *r )
1365 {
1366     GetControlBounds( m_controlRef , r ) ;
1367
1368     WindowRef tlwref = GetControlOwner( m_controlRef ) ;
1369
1370     wxNonOwnedWindow* tlwwx = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) tlwref ) ;
1371     if ( tlwwx != NULL )
1372     {
1373         ControlRef rootControl = tlwwx->GetPeer()->GetControlRef() ;
1374         HIPoint hiPoint = CGPointMake( 0 , 0 ) ;
1375         HIViewConvertPoint( &hiPoint , HIViewGetSuperview(m_controlRef) , rootControl ) ;
1376         OffsetRect( r , (short) hiPoint.x , (short) hiPoint.y ) ;
1377     }
1378 }
1379
1380 void wxMacControl::GetBestRect( wxRect *rect ) const
1381 {
1382     short   baselineoffset;
1383     Rect r = {0,0,0,0};
1384
1385     GetBestControlRect( m_controlRef , &r , &baselineoffset );
1386     *rect = wxRect( r.left, r.top, r.right - r.left, r.bottom-r.top );
1387 }
1388
1389 void wxMacControl::GetBestRect( Rect *r ) const
1390 {
1391     short   baselineoffset;
1392     GetBestControlRect( m_controlRef , r , &baselineoffset );
1393 }
1394
1395 void wxMacControl::SetLabel( const wxString &title , wxFontEncoding encoding)
1396 {
1397     SetControlTitleWithCFString( m_controlRef , wxCFStringRef( title , encoding ) );
1398 }
1399
1400 void wxMacControl::GetFeatures( UInt32 * features )
1401 {
1402     GetControlFeatures( m_controlRef , features );
1403 }
1404
1405 void wxMacControl::PulseGauge()
1406 {
1407 }
1408
1409 // SetNeedsDisplay would not invalidate the children
1410 static void InvalidateControlAndChildren( HIViewRef control )
1411 {
1412     HIViewSetNeedsDisplay( control , true );
1413     UInt16 childrenCount = 0;
1414     OSStatus err = CountSubControls( control , &childrenCount );
1415     if ( err == errControlIsNotEmbedder )
1416         return;
1417
1418     wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1419
1420     for ( UInt16 i = childrenCount; i >=1; --i )
1421     {
1422         HIViewRef child;
1423
1424         err = GetIndexedSubControl( control , i , & child );
1425         if ( err == errControlIsNotEmbedder )
1426             return;
1427
1428         InvalidateControlAndChildren( child );
1429     }
1430 }
1431
1432 void wxMacControl::InvalidateWithChildren()
1433 {
1434     InvalidateControlAndChildren( m_controlRef );
1435 }
1436
1437 OSType wxMacCreator = 'WXMC';
1438 OSType wxMacControlProperty = 'MCCT';
1439
1440 void wxMacControl::SetReferenceInNativeControl()
1441 {
1442     void * data = this;
1443     verify_noerr( SetControlProperty ( m_controlRef ,
1444         wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1445 }
1446
1447 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1448 {
1449     wxMacControl* ctl = NULL;
1450     ByteCount actualSize;
1451     if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1452         &actualSize , &ctl ) == noErr )
1453     {
1454         return ctl;
1455     }
1456     return NULL;
1457 }
1458
1459 void wxMacControl::SetBitmap( const wxBitmap& WXUNUSED(bmp) )
1460 {
1461     // implemented in the respective subclasses
1462 }
1463
1464 void wxMacControl::SetScrollThumb( wxInt32 WXUNUSED(pos), wxInt32 WXUNUSED(viewsize) )
1465 {
1466     // implemented in respective subclass
1467 }
1468
1469 //
1470 // Tab Control
1471 //
1472
1473 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1474 {
1475     return ::SetTabEnabled( m_controlRef , tabNo , enable );
1476 }
1477
1478
1479
1480 // Control Factory
1481
1482 wxWidgetImplType* wxWidgetImpl::CreateContentView( wxNonOwnedWindow* now )
1483 {
1484     // There is a bug in 10.2.X for ::GetRootControl returning the window view instead of
1485     // the content view, so we have to retrieve it explicitly
1486
1487     wxMacControl* contentview = new wxMacControl(now , true /*isRootControl*/);
1488     HIViewFindByID( HIViewGetRoot( (WindowRef) now->GetWXWindow() ) , kHIViewWindowContentID ,
1489         contentview->GetControlRefAddr() ) ;
1490     if ( !contentview->IsOk() )
1491     {
1492         // compatibility mode fallback
1493         GetRootControl( (WindowRef) now->GetWXWindow() , contentview->GetControlRefAddr() ) ;
1494     }
1495
1496     // the root control level handler
1497     contentview->InstallEventHandler() ;
1498     return contentview;
1499 }