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