src/mac/carbon/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/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 #include "wx/mac/uma.h"
  65
  66 #define MAC_SCROLLBAR_SIZE 15
  67 #define MAC_SMALL_SCROLLBAR_SIZE 11
  68
  69 #include <string.h>
  70
  71 #ifdef __WXUNIVERSAL__
  72     IMPLEMENT_ABSTRACT_CLASS(wxWindowMac, wxWindowBase)
  73 #else
  74     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
  75 #endif
  76
  77 BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
  78     EVT_NC_PAINT(wxWindowMac::OnNcPaint)
  79     EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
  80     EVT_PAINT(wxWindowMac::OnPaint)
  81     EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
  82 END_EVENT_TABLE()
  83
  84 #define wxMAC_DEBUG_REDRAW 0
  85 #ifndef wxMAC_DEBUG_REDRAW
  86 #define wxMAC_DEBUG_REDRAW 0
  87 #endif
  88
  89 // ---------------------------------------------------------------------------
  90 // Utility Routines to move between different coordinate systems
  91 // ---------------------------------------------------------------------------
  92
  93 /*
  94  * Right now we have the following setup :
  95  * a border that is not part of the native control is always outside the
  96  * control's border (otherwise we loose all native intelligence, future ways
  97  * may be to have a second embedding control responsible for drawing borders
  98  * and backgrounds eventually)
  99  * so all this border calculations have to be taken into account when calling
 100  * native methods or getting native oriented data
 101  * so we have three coordinate systems here
 102  * wx client coordinates
 103  * wx window coordinates (including window frames)
 104  * native coordinates
 105  */
 106
 107 //
 108 // originating from native control
 109 //
 110
 111
 112 void wxMacNativeToWindow( const wxWindow* window , RgnHandle handle )
 113 {
 114     OffsetRgn( handle , window->MacGetLeftBorderSize() , window->MacGetTopBorderSize() ) ;
 115 }
 116
 117 void wxMacNativeToWindow( const wxWindow* window , Rect *rect )
 118 {
 119     OffsetRect( rect , window->MacGetLeftBorderSize() , window->MacGetTopBorderSize() ) ;
 120 }
 121
 122 //
 123 // directed towards native control
 124 //
 125
 126 void wxMacWindowToNative( const wxWindow* window , RgnHandle handle )
 127 {
 128     OffsetRgn( handle , -window->MacGetLeftBorderSize() , -window->MacGetTopBorderSize() );
 129 }
 130
 131 void wxMacWindowToNative( const wxWindow* window , Rect *rect )
 132 {
 133     OffsetRect( rect , -window->MacGetLeftBorderSize() , -window->MacGetTopBorderSize() ) ;
 134 }
 135
 136 // ---------------------------------------------------------------------------
 137 // Carbon Events
 138 // ---------------------------------------------------------------------------
 139
 140 static const EventTypeSpec eventList[] =
 141 {
 142     { kEventClassCommand, kEventProcessCommand } ,
 143     { kEventClassCommand, kEventCommandUpdateStatus } ,
 144
 145     { kEventClassControl , kEventControlGetClickActivation } ,
 146     { kEventClassControl , kEventControlHit } ,
 147
 148     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
 149     { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
 150
 151     { kEventClassControl , kEventControlDraw } ,
 152
 153     { kEventClassControl , kEventControlVisibilityChanged } ,
 154     { kEventClassControl , kEventControlEnabledStateChanged } ,
 155     { kEventClassControl , kEventControlHiliteChanged } ,
 156
 157     { kEventClassControl , kEventControlActivate } ,
 158     { kEventClassControl , kEventControlDeactivate } ,
 159
 160     { kEventClassControl , kEventControlSetFocusPart } ,
 161     { kEventClassControl , kEventControlFocusPartChanged } ,
 162
 163     { kEventClassService , kEventServiceGetTypes },
 164     { kEventClassService , kEventServiceCopy },
 165     { kEventClassService , kEventServicePaste },
 166
 167 //    { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
 168 //    { kEventClassControl , kEventControlBoundsChanged } ,
 169 } ;
 170
 171 static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 172 {
 173     OSStatus result = eventNotHandledErr ;
 174
 175     wxMacCarbonEvent cEvent( event ) ;
 176
 177     ControlRef controlRef ;
 178     wxWindowMac* thisWindow = (wxWindowMac*) data ;
 179
 180     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 181
 182     switch ( GetEventKind( event ) )
 183     {
 184         case kEventControlDraw :
 185             {
 186                 RgnHandle updateRgn = NULL ;
 187                 RgnHandle allocatedRgn = NULL ;
 188                 wxRegion visRegion = thisWindow->MacGetVisibleRegion() ;
 189
 190                 if ( cEvent.GetParameter<RgnHandle>(kEventParamRgnHandle, &updateRgn) != noErr )
 191                 {
 192                     HIShapeGetAsQDRgn( visRegion.GetWXHRGN(), updateRgn );
 193                 }
 194                 else
 195                 {
 196                     if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
 197                     {
 198                         // as this update region is in native window locals we must adapt it to wx window local
 199                         allocatedRgn = NewRgn() ;
 200                         CopyRgn( updateRgn , allocatedRgn ) ;
 201
 202                         // hide the given region by the new region that must be shifted
 203                         wxMacNativeToWindow( thisWindow , allocatedRgn ) ;
 204                         updateRgn = allocatedRgn ;
 205                     }
 206                 }
 207
 208 #if wxMAC_DEBUG_REDRAW
 209                 if ( thisWindow->MacIsUserPane() )
 210                 {
 211                     static float color = 0.5 ;
 212                     static channel = 0 ;
 213                     HIRect bounds;
 214                     CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
 215
 216                     HIViewGetBounds( controlRef, &bounds );
 217                     CGContextSetRGBFillColor( cgContext, channel == 0 ? color : 0.5 ,
 218                         channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
 219                     CGContextFillRect( cgContext, bounds );
 220                     color += 0.1 ;
 221                     if ( color > 0.9 )
 222                     {
 223                         color = 0.5 ;
 224                         channel++ ;
 225                         if ( channel == 3 )
 226                             channel = 0 ;
 227                     }
 228                 }
 229 #endif
 230
 231                 {
 232                     bool created = false ;
 233                     CGContextRef cgContext = NULL ;
 234                     OSStatus err = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) ;
 235                     wxASSERT_MSG( err == noErr , wxT("Unable to retrieve CGContextRef") ) ;
 236                     thisWindow->MacSetCGContextRef( cgContext ) ;
 237
 238                     {
 239                         wxMacCGContextStateSaver sg( cgContext ) ;
 240                         float alpha = 1.0 ;
 241                         {
 242                             wxWindow* iter = thisWindow ;
 243                             while ( iter )
 244                             {
 245                                 alpha *= (float) iter->GetTransparent()/255.0 ;
 246                                 if ( iter->IsTopLevel() )
 247                                     iter = NULL ;
 248                                 else
 249                                     iter = iter->GetParent() ;
 250                             }
 251                         }
 252                         CGContextSetAlpha( cgContext , alpha ) ;
 253
 254                         if ( thisWindow->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
 255                         {
 256                             HIRect bounds;
 257                             HIViewGetBounds( controlRef, &bounds );
 258                             CGContextClearRect( cgContext, bounds );
 259                         }
 260
 261
 262
 263                         if ( thisWindow->MacDoRedraw( updateRgn , cEvent.GetTicks() ) )
 264                             result = noErr ;
 265
 266                         thisWindow->MacSetCGContextRef( NULL ) ;
 267                     }
 268
 269                     if ( created )
 270                         CGContextRelease( cgContext ) ;
 271                 }
 272
 273                 if ( allocatedRgn )
 274                     DisposeRgn( allocatedRgn ) ;
 275             }
 276             break ;
 277
 278         case kEventControlVisibilityChanged :
 279             // we might have two native controls attributed to the same wxWindow instance
 280             // eg a scrollview and an embedded textview, make sure we only fire for the 'outer'
 281             // control, as otherwise native and wx visibility are different
 282             if ( thisWindow->GetPeer() != NULL && thisWindow->GetPeer()->GetControlRef() == controlRef )
 283             {
 284                 thisWindow->MacVisibilityChanged() ;
 285             }
 286             break ;
 287
 288         case kEventControlEnabledStateChanged :
 289             thisWindow->MacEnabledStateChanged();
 290             break ;
 291
 292         case kEventControlHiliteChanged :
 293             thisWindow->MacHiliteChanged() ;
 294             break ;
 295
 296         case kEventControlActivate :
 297         case kEventControlDeactivate :
 298             // FIXME: we should have a virtual function for this!
 299 #if wxUSE_TREECTRL
 300             if ( thisWindow->IsKindOf( CLASSINFO( wxTreeCtrl ) ) )
 301                 thisWindow->Refresh();
 302 #endif
 303 #if wxUSE_LISTCTRL
 304             if ( thisWindow->IsKindOf( CLASSINFO( wxListCtrl ) ) )
 305                 thisWindow->Refresh();
 306 #endif
 307             break ;
 308
 309         //
 310         // focus handling
 311         // different handling on OS X
 312         //
 313
 314         case kEventControlFocusPartChanged :
 315             // the event is emulated by wxmac for systems lower than 10.5
 316             {
 317                 ControlPartCode previousControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPreviousPart , typeControlPartCode );
 318                 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlCurrentPart , typeControlPartCode );
 319
 320                 if ( thisWindow->MacGetTopLevelWindow() && thisWindow->GetPeer()->NeedsFocusRect() )
 321                 {
 322                     thisWindow->MacInvalidateBorders();
 323                 }
 324
 325                 if ( currentControlPart == 0 )
 326                 {
 327                     // kill focus
 328 #if wxUSE_CARET
 329                     if ( thisWindow->GetCaret() )
 330                         thisWindow->GetCaret()->OnKillFocus();
 331 #endif
 332
 333                     wxLogTrace(_T("Focus"), _T("focus lost(%p)"), wx_static_cast(void*, thisWindow));
 334
 335                     // remove this as soon as posting the synthesized event works properly
 336                     static bool inKillFocusEvent = false ;
 337
 338                     if ( !inKillFocusEvent )
 339                     {
 340                         inKillFocusEvent = true ;
 341                         wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
 342                         event.SetEventObject(thisWindow);
 343                         thisWindow->HandleWindowEvent(event) ;
 344                         inKillFocusEvent = false ;
 345                     }
 346                 }
 347                 else if ( previousControlPart == 0 )
 348                 {
 349                     // set focus
 350                     // panel wants to track the window which was the last to have focus in it
 351                     wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
 352                     wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
 353                     thisWindow->HandleWindowEvent(eventFocus);
 354
 355 #if wxUSE_CARET
 356                     if ( thisWindow->GetCaret() )
 357                         thisWindow->GetCaret()->OnSetFocus();
 358 #endif
 359
 360                     wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
 361                     event.SetEventObject(thisWindow);
 362                     thisWindow->HandleWindowEvent(event) ;
 363                 }
 364             }
 365             break;
 366         case kEventControlSetFocusPart :
 367             {
 368 #ifdef __WXMAC_OSX__
 369                 Boolean focusEverything = false ;
 370                 if ( cEvent.GetParameter<Boolean>(kEventParamControlFocusEverything , &focusEverything ) == noErr )
 371                 {
 372                     // put a breakpoint here to catch focus everything events
 373                 }
 374 #endif
 375                 ControlPartCode controlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
 376
 377                 ControlPartCode previousControlPart = 0;
 378                 verify_noerr( HIViewGetFocusPart(controlRef, &previousControlPart));
 379
 380                 if ( thisWindow->MacIsUserPane() )
 381                 {
 382                     if ( controlPart != kControlFocusNoPart )
 383                         cEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, 1 ) ;
 384                     result = noErr ;
 385                 }
 386                 else
 387                     result = CallNextEventHandler(handler, event);
 388
 389                 if ( UMAGetSystemVersion() < 0x1050 )
 390                 {
 391 // set back to 0 if problems arise
 392 #if 1
 393                     ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
 394                     // synthesize the event focus changed event
 395                     EventRef evRef = NULL ;
 396
 397                     OSStatus err = MacCreateEvent(
 398                                          NULL , kEventClassControl , kEventControlFocusPartChanged , TicksToEventTime( TickCount() ) ,
 399                                          kEventAttributeUserEvent , &evRef );
 400                     verify_noerr( err );
 401
 402                     wxMacCarbonEvent iEvent( evRef ) ;
 403                     iEvent.SetParameter<ControlRef>( kEventParamDirectObject , controlRef ) ;
 404                     iEvent.SetParameter<ControlPartCode>( kEventParamControlPreviousPart, typeControlPartCode, previousControlPart ) ;
 405                     iEvent.SetParameter<ControlPartCode>( kEventParamControlCurrentPart, typeControlPartCode, currentControlPart ) ;
 406
 407 #if 0
 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 #else
 415                     // old implementation, to be removed if the new one works
 416                     if ( controlPart == kControlFocusNoPart )
 417                     {
 418 #if wxUSE_CARET
 419                         if ( thisWindow->GetCaret() )
 420                             thisWindow->GetCaret()->OnKillFocus();
 421 #endif
 422
 423                         wxLogTrace(_T("Focus"), _T("focus lost(%p)"), wx_static_cast(void*, thisWindow));
 424
 425                         static bool inKillFocusEvent = false ;
 426
 427                         if ( !inKillFocusEvent )
 428                         {
 429                             inKillFocusEvent = true ;
 430                             wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
 431                             event.SetEventObject(thisWindow);
 432                             thisWindow->HandleWindowEvent(event) ;
 433                             inKillFocusEvent = false ;
 434                         }
 435                     }
 436                     else
 437                     {
 438                         // panel wants to track the window which was the last to have focus in it
 439                         wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
 440                         wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
 441                         thisWindow->HandleWindowEvent(eventFocus);
 442
 443     #if wxUSE_CARET
 444                         if ( thisWindow->GetCaret() )
 445                             thisWindow->GetCaret()->OnSetFocus();
 446     #endif
 447
 448                         wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
 449                         event.SetEventObject(thisWindow);
 450                         thisWindow->HandleWindowEvent(event) ;
 451                     }
 452 #endif
 453                 }
 454             }
 455             break ;
 456
 457         case kEventControlHit :
 458             result = thisWindow->MacControlHit( handler , event ) ;
 459             break ;
 460
 461         case kEventControlGetClickActivation :
 462             {
 463                 // fix to always have a proper activation for DataBrowser controls (stay in bkgnd otherwise)
 464                 WindowRef owner = cEvent.GetParameter<WindowRef>(kEventParamWindowRef);
 465                 if ( !IsWindowActive(owner) )
 466                 {
 467                     cEvent.SetParameter(kEventParamClickActivation,(UInt32) kActivateAndIgnoreClick) ;
 468                     result = noErr ;
 469                 }
 470             }
 471             break ;
 472
 473         default :
 474             break ;
 475     }
 476
 477     return result ;
 478 }
 479
 480 static pascal OSStatus
 481 wxMacWindowServiceEventHandler(EventHandlerCallRef WXUNUSED(handler),
 482                                EventRef event,
 483                                void *data)
 484 {
 485     OSStatus result = eventNotHandledErr ;
 486
 487     wxMacCarbonEvent cEvent( event ) ;
 488
 489     ControlRef controlRef ;
 490     wxWindowMac* thisWindow = (wxWindowMac*) data ;
 491     wxTextCtrl* textCtrl = wxDynamicCast( thisWindow , wxTextCtrl ) ;
 492     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 493
 494     switch ( GetEventKind( event ) )
 495     {
 496         case kEventServiceGetTypes :
 497             if ( textCtrl )
 498             {
 499                 long from, to ;
 500                 textCtrl->GetSelection( &from , &to ) ;
 501
 502                 CFMutableArrayRef copyTypes = 0 , pasteTypes = 0;
 503                 if ( from != to )
 504                     copyTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServiceCopyTypes , typeCFMutableArrayRef ) ;
 505                 if ( textCtrl->IsEditable() )
 506                     pasteTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServicePasteTypes , typeCFMutableArrayRef ) ;
 507
 508                 static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt', 'PICT', 'MooV', 'AIFF' */  };
 509                 for ( size_t i = 0 ; i < WXSIZEOF(textDataTypes) ; ++i )
 510                 {
 511                     CFStringRef typestring = CreateTypeStringWithOSType(textDataTypes[i]);
 512                     if ( typestring )
 513                     {
 514                         if ( copyTypes )
 515                             CFArrayAppendValue(copyTypes, typestring) ;
 516                         if ( pasteTypes )
 517                             CFArrayAppendValue(pasteTypes, typestring) ;
 518
 519                         CFRelease( typestring ) ;
 520                     }
 521                 }
 522
 523                 result = noErr ;
 524             }
 525             break ;
 526
 527         case kEventServiceCopy :
 528             if ( textCtrl )
 529             {
 530                 long from, to ;
 531
 532                 textCtrl->GetSelection( &from , &to ) ;
 533                 wxString val = textCtrl->GetValue() ;
 534                 val = val.Mid( from , to - from ) ;
 535                 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
 536                 verify_noerr( PasteboardClear( pasteboard ) ) ;
 537                 PasteboardSynchronize( pasteboard );
 538                 // TODO add proper conversion
 539                 CFDataRef data = CFDataCreate( kCFAllocatorDefault, (const UInt8*)val.c_str(), val.length() );
 540                 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) 1, CFSTR("com.apple.traditional-mac-plain-text"), data, 0);
 541                 CFRelease( data );
 542                 result = noErr ;
 543             }
 544             break ;
 545
 546         case kEventServicePaste :
 547             if ( textCtrl )
 548             {
 549                 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
 550                 PasteboardSynchronize( pasteboard );
 551                 ItemCount itemCount;
 552                 verify_noerr( PasteboardGetItemCount( pasteboard, &itemCount ) );
 553                 for( UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++ )
 554                 {
 555                     PasteboardItemID itemID;
 556                     if ( PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ) == noErr )
 557                     {
 558                         CFDataRef flavorData = NULL;
 559                         if ( PasteboardCopyItemFlavorData( pasteboard, itemID, CFSTR("com.apple.traditional-mac-plain-text"), &flavorData ) == noErr )
 560                         {
 561                             CFIndex flavorDataSize = CFDataGetLength( flavorData );
 562                             char *content = new char[flavorDataSize+1] ;
 563                             memcpy( content, CFDataGetBytePtr( flavorData ), flavorDataSize );
 564                             content[flavorDataSize]=0;
 565                             CFRelease( flavorData );
 566 #if wxUSE_UNICODE
 567                             textCtrl->WriteText( wxString( content , wxConvLocal ) );
 568 #else
 569                             textCtrl->WriteText( wxString( content ) ) ;
 570 #endif
 571
 572                             delete[] content ;
 573                             result = noErr ;
 574                         }
 575                     }
 576                 }
 577             }
 578             break ;
 579
 580         default:
 581             break ;
 582     }
 583
 584     return result ;
 585 }
 586
 587 pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 588 {
 589     OSStatus result = eventNotHandledErr ;
 590     wxWindowMac* focus = (wxWindowMac*) data ;
 591
 592     wchar_t* uniChars = NULL ;
 593     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 594
 595     UniChar* charBuf = NULL;
 596     ByteCount dataSize = 0 ;
 597     int numChars = 0 ;
 598     UniChar buf[2] ;
 599     if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
 600     {
 601         numChars = dataSize / sizeof( UniChar) + 1;
 602         charBuf = buf ;
 603
 604         if ( (size_t) numChars * 2 > sizeof(buf) )
 605             charBuf = new UniChar[ numChars ] ;
 606         else
 607             charBuf = buf ;
 608
 609         uniChars = new wchar_t[ numChars ] ;
 610         GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
 611         charBuf[ numChars - 1 ] = 0;
 612 #if SIZEOF_WCHAR_T == 2
 613         uniChars = (wchar_t*) charBuf ;
 614 /*        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...)
 615 #else
 616         // the resulting string will never have more chars than the utf16 version, so this is safe
 617         wxMBConvUTF16 converter ;
 618         numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
 619 #endif
 620     }
 621
 622     switch ( GetEventKind( event ) )
 623     {
 624         case kEventTextInputUpdateActiveInputArea :
 625             {
 626                 // An IME input event may return several characters, but we need to send one char at a time to
 627                 // EVT_CHAR
 628                 for (int pos=0 ; pos < numChars ; pos++)
 629                 {
 630                     WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 631                     WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 632                     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 633
 634                     UInt32 message = uniChars[pos] < 128 ? (char)uniChars[pos] : '?';
 635 /*
 636     NB: faking a charcode here is problematic. The kEventTextInputUpdateActiveInputArea event is sent
 637     multiple times to update the active range during inline input, so this handler will often receive
 638     uncommited text, which should usually not trigger side effects. It might be a good idea to check the
 639     kEventParamTextInputSendFixLen parameter and verify if input is being confirmed (see CarbonEvents.h).
 640     On the other hand, it can be useful for some applications to react to uncommitted text (for example,
 641     to update a status display), as long as it does not disrupt the inline input session. Ideally, wx
 642     should add new event types to support advanced text input. For now, I would keep things as they are.
 643
 644     However, the code that was being used caused additional problems:
 645                     UInt32 message = (0  << 8) + ((char)uniChars[pos] );
 646     Since it simply truncated the unichar to the last byte, it ended up causing weird bugs with inline
 647     input, such as switching to another field when one attempted to insert the character U+4E09 (the kanji
 648     for "three"), because it was truncated to 09 (kTabCharCode), which was later "converted" to WXK_TAB
 649     (still 09) in wxMacTranslateKey; or triggering the default button when one attempted to insert U+840D
 650     (the kanji for "name"), which got truncated to 0D and interpreted as a carriage return keypress.
 651     Note that even single-byte characters could have been misinterpreted, since MacRoman charcodes only
 652     overlap with Unicode within the (7-bit) ASCII range.
 653     But simply passing a NUL charcode would disable text updated events, because wxTextCtrl::OnChar checks
 654     for codes within a specific range. Therefore I went for the solution seen above, which keeps ASCII
 655     characters as they are and replaces the rest with '?', ensuring that update events are triggered.
 656     It would be better to change wxTextCtrl::OnChar to look at the actual unicode character instead, but
 657     I don't have time to look into that right now.
 658         -- CL
 659 */
 660                     if ( wxTheApp->MacSendCharEvent(
 661                                                     focus , message , 0 , when , 0 , 0 , uniChars[pos] ) )
 662                     {
 663                         result = noErr ;
 664                     }
 665
 666                     wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 667                 }
 668             }
 669             break ;
 670         case kEventTextInputUnicodeForKeyEvent :
 671             {
 672                 UInt32 keyCode, modifiers ;
 673                 Point point ;
 674                 EventRef rawEvent ;
 675                 unsigned char charCode ;
 676
 677                 GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
 678                 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
 679                 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
 680                 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
 681                 GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
 682
 683                 UInt32 message = (keyCode << 8) + charCode;
 684
 685                 // An IME input event may return several characters, but we need to send one char at a time to
 686                 // EVT_CHAR
 687                 for (int pos=0 ; pos < numChars ; pos++)
 688                 {
 689                     WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 690                     WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 691                     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 692
 693                     if ( wxTheApp->MacSendCharEvent(
 694                         focus , message , modifiers , when , point.h , point.v , uniChars[pos] ) )
 695                     {
 696                         result = noErr ;
 697                     }
 698
 699                     wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 700                 }
 701             }
 702             break;
 703         default:
 704             break ;
 705     }
 706
 707     delete [] uniChars ;
 708     if ( charBuf != buf )
 709         delete [] charBuf ;
 710
 711     return result ;
 712 }
 713
 714 static pascal OSStatus
 715 wxMacWindowCommandEventHandler(EventHandlerCallRef WXUNUSED(handler),
 716                                EventRef event,
 717                                void *data)
 718 {
 719     OSStatus result = eventNotHandledErr ;
 720     wxWindowMac* focus = (wxWindowMac*) data ;
 721
 722     HICommand command ;
 723
 724     wxMacCarbonEvent cEvent( event ) ;
 725     cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
 726
 727     wxMenuItem* item = NULL ;
 728     wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
 729     int id = wxMacCommandToId( command.commandID ) ;
 730
 731     if ( item )
 732     {
 733         wxASSERT( itemMenu != NULL ) ;
 734
 735         switch ( cEvent.GetKind() )
 736         {
 737             case kEventProcessCommand :
 738                 result = itemMenu->MacHandleCommandProcess( item, id, focus );
 739             break ;
 740
 741             case kEventCommandUpdateStatus:
 742                 result = itemMenu->MacHandleCommandUpdateStatus( item, id, focus );
 743                 break ;
 744
 745             default :
 746                 break ;
 747         }
 748     }
 749     return result ;
 750 }
 751
 752 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 753 {
 754     EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
 755     EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 756     wxTheApp->MacSetCurrentEvent( event , handler ) ;
 757     OSStatus result = eventNotHandledErr ;
 758
 759     switch ( GetEventClass( event ) )
 760     {
 761         case kEventClassCommand :
 762             result = wxMacWindowCommandEventHandler( handler , event , data ) ;
 763             break ;
 764
 765         case kEventClassControl :
 766             result = wxMacWindowControlEventHandler( handler, event, data ) ;
 767             break ;
 768
 769         case kEventClassService :
 770             result = wxMacWindowServiceEventHandler( handler, event , data ) ;
 771             break ;
 772
 773         case kEventClassTextInput :
 774             result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
 775             break ;
 776
 777         default :
 778             break ;
 779     }
 780
 781     wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
 782
 783     return result ;
 784 }
 785
 786 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
 787
 788 // ---------------------------------------------------------------------------
 789 // Scrollbar Tracking for all
 790 // ---------------------------------------------------------------------------
 791
 792 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode ) ;
 793 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode )
 794 {
 795     if ( partCode != 0)
 796     {
 797         wxWindow*  wx = wxFindControlFromMacControl( control ) ;
 798         if ( wx )
 799             wx->MacHandleControlClick( (WXWidget) control , partCode , true /* stillDown */ ) ;
 800     }
 801 }
 802 wxMAC_DEFINE_PROC_GETTER( ControlActionUPP , wxMacLiveScrollbarActionProc ) ;
 803
 804 // ===========================================================================
 805 // implementation
 806 // ===========================================================================
 807
 808 WX_DECLARE_HASH_MAP(ControlRef, wxWindow*, wxPointerHash, wxPointerEqual, MacControlMap);
 809
 810 static MacControlMap wxWinMacControlList;
 811
 812 wxWindow *wxFindControlFromMacControl(ControlRef inControl )
 813 {
 814     MacControlMap::iterator node = wxWinMacControlList.find(inControl);
 815
 816     return (node == wxWinMacControlList.end()) ? NULL : node->second;
 817 }
 818
 819 void wxAssociateControlWithMacControl(ControlRef inControl, wxWindow *control)
 820 {
 821     // adding NULL ControlRef is (first) surely a result of an error and
 822     // (secondly) breaks native event processing
 823     wxCHECK_RET( inControl != (ControlRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
 824
 825     wxWinMacControlList[inControl] = control;
 826 }
 827
 828 void wxRemoveMacControlAssociation(wxWindow *control)
 829 {
 830    // iterate over all the elements in the class
 831     // is the iterator stable ? as we might have two associations pointing to the same wxWindow
 832     // we should go on...
 833
 834     bool found = true ;
 835     while ( found )
 836     {
 837         found = false ;
 838         MacControlMap::iterator it;
 839         for ( it = wxWinMacControlList.begin(); it != wxWinMacControlList.end(); ++it )
 840         {
 841             if ( it->second == control )
 842             {
 843                 wxWinMacControlList.erase(it);
 844                 found = true ;
 845                 break;
 846             }
 847         }
 848     }
 849 }
 850
 851 // ----------------------------------------------------------------------------
 852  // constructors and such
 853 // ----------------------------------------------------------------------------
 854
 855 wxWindowMac::wxWindowMac()
 856 {
 857     Init();
 858 }
 859
 860 wxWindowMac::wxWindowMac(wxWindowMac *parent,
 861             wxWindowID id,
 862             const wxPoint& pos ,
 863             const wxSize& size ,
 864             long style ,
 865             const wxString& name )
 866 {
 867     Init();
 868     Create(parent, id, pos, size, style, name);
 869 }
 870
 871 void wxWindowMac::Init()
 872 {
 873     m_peer = NULL ;
 874     m_macAlpha = 255 ;
 875     m_cgContextRef = NULL ;
 876
 877     // as all windows are created with WS_VISIBLE style...
 878     m_isShown = true;
 879
 880     m_hScrollBar = NULL ;
 881     m_vScrollBar = NULL ;
 882     m_hScrollBarAlwaysShown = false;
 883     m_vScrollBarAlwaysShown = false;
 884
 885     m_macIsUserPane = true;
 886     m_clipChildren = false ;
 887     m_cachedClippedRectValid = false ;
 888 }
 889
 890 wxWindowMac::~wxWindowMac()
 891 {
 892     SendDestroyEvent();
 893
 894     m_isBeingDeleted = true;
 895
 896     MacInvalidateBorders() ;
 897
 898 #ifndef __WXUNIVERSAL__
 899     // VS: make sure there's no wxFrame with last focus set to us:
 900     for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
 901     {
 902         wxFrame *frame = wxDynamicCast(win, wxFrame);
 903         if ( frame )
 904         {
 905             if ( frame->GetLastFocus() == this )
 906                 frame->SetLastFocus((wxWindow*)NULL);
 907             break;
 908         }
 909     }
 910 #endif
 911
 912     // destroy children before destroying this window itself
 913     DestroyChildren();
 914
 915     // wxRemoveMacControlAssociation( this ) ;
 916     // If we delete an item, we should initialize the parent panel,
 917     // because it could now be invalid.
 918     wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
 919     if ( tlw )
 920     {
 921         if ( tlw->GetDefaultItem() == (wxButton*) this)
 922             tlw->SetDefaultItem(NULL);
 923     }
 924
 925     if ( m_peer && m_peer->Ok() )
 926     {
 927         // in case the callback might be called during destruction
 928         wxRemoveMacControlAssociation( this) ;
 929         ::RemoveEventHandler( (EventHandlerRef ) m_macControlEventHandler ) ;
 930         // we currently are not using this hook
 931         // ::SetControlColorProc( *m_peer , NULL ) ;
 932         m_peer->Dispose() ;
 933     }
 934
 935     if ( g_MacLastWindow == this )
 936         g_MacLastWindow = NULL ;
 937
 938 #ifndef __WXUNIVERSAL__
 939     wxFrame* frame = wxDynamicCast( wxGetTopLevelParent( (wxWindow*)this ) , wxFrame ) ;
 940     if ( frame )
 941     {
 942         if ( frame->GetLastFocus() == this )
 943             frame->SetLastFocus( NULL ) ;
 944     }
 945 #endif
 946
 947     // delete our drop target if we've got one
 948 #if wxUSE_DRAG_AND_DROP
 949     if ( m_dropTarget != NULL )
 950     {
 951         delete m_dropTarget;
 952         m_dropTarget = NULL;
 953     }
 954 #endif
 955
 956     delete m_peer ;
 957 }
 958
 959 WXWidget wxWindowMac::GetHandle() const
 960 {
 961     return (WXWidget) m_peer->GetControlRef() ;
 962 }
 963
 964 void wxWindowMac::MacInstallEventHandler( WXWidget control )
 965 {
 966     wxAssociateControlWithMacControl( (ControlRef) control , this ) ;
 967     InstallControlEventHandler( (ControlRef)control , GetwxMacWindowEventHandlerUPP(),
 968         GetEventTypeCount(eventList), eventList, this,
 969         (EventHandlerRef *)&m_macControlEventHandler);
 970 }
 971
 972 // Constructor
 973 bool wxWindowMac::Create(wxWindowMac *parent,
 974     wxWindowID id,
 975     const wxPoint& pos,
 976     const wxSize& size,
 977     long style,
 978     const wxString& name)
 979 {
 980     wxCHECK_MSG( parent, false, wxT("can't create wxWindowMac without parent") );
 981
 982     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 983         return false;
 984
 985     m_windowVariant = parent->GetWindowVariant() ;
 986
 987     if ( m_macIsUserPane )
 988     {
 989         Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
 990
 991         UInt32 features = 0
 992             | kControlSupportsEmbedding
 993             | kControlSupportsLiveFeedback
 994             | kControlGetsFocusOnClick
 995 //            | kControlHasSpecialBackground
 996 //            | kControlSupportsCalcBestRect
 997             | kControlHandlesTracking
 998             | kControlSupportsFocus
 999             | kControlWantsActivate
1000             | kControlWantsIdle ;
1001
1002         m_peer = new wxMacControl(this) ;
1003         OSStatus err =::CreateUserPaneControl( MAC_WXHWND(GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , m_peer->GetControlRefAddr() );
1004         verify_noerr( err );
1005
1006         MacPostControlCreate(pos, size) ;
1007     }
1008
1009 #ifndef __WXUNIVERSAL__
1010     // Don't give scrollbars to wxControls unless they ask for them
1011     if ( (! IsKindOf(CLASSINFO(wxControl)) && ! IsKindOf(CLASSINFO(wxStatusBar)))
1012          || (IsKindOf(CLASSINFO(wxControl)) && ((style & wxHSCROLL) || (style & wxVSCROLL))))
1013     {
1014         MacCreateScrollBars( style ) ;
1015     }
1016 #endif
1017
1018     wxWindowCreateEvent event(this);
1019     GetEventHandler()->AddPendingEvent(event);
1020
1021     return true;
1022 }
1023
1024 void wxWindowMac::MacChildAdded()
1025 {
1026     if ( m_vScrollBar )
1027         m_vScrollBar->Raise() ;
1028     if ( m_hScrollBar )
1029         m_hScrollBar->Raise() ;
1030 }
1031
1032 void wxWindowMac::MacPostControlCreate(const wxPoint& WXUNUSED(pos), const wxSize& size)
1033 {
1034     wxASSERT_MSG( m_peer != NULL && m_peer->Ok() , wxT("No valid mac control") ) ;
1035
1036     m_peer->SetReference( (URefCon) this ) ;
1037     GetParent()->AddChild( this );
1038
1039     MacInstallEventHandler( (WXWidget) m_peer->GetControlRef() );
1040
1041     ControlRef container = (ControlRef) GetParent()->GetHandle() ;
1042     wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
1043     ::EmbedControl( m_peer->GetControlRef() , container ) ;
1044     GetParent()->MacChildAdded() ;
1045
1046     // adjust font, controlsize etc
1047     DoSetWindowVariant( m_windowVariant ) ;
1048
1049     m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics) ) ;
1050
1051     if (!m_macIsUserPane)
1052         SetInitialSize(size);
1053
1054     SetCursor( *wxSTANDARD_CURSOR ) ;
1055 }
1056
1057 void wxWindowMac::DoSetWindowVariant( wxWindowVariant variant )
1058 {
1059     // Don't assert, in case we set the window variant before
1060     // the window is created
1061     // wxASSERT( m_peer->Ok() ) ;
1062
1063     m_windowVariant = variant ;
1064
1065     if (m_peer == NULL || !m_peer->Ok())
1066         return;
1067
1068     ControlSize size ;
1069     ThemeFontID themeFont = kThemeSystemFont ;
1070
1071     // we will get that from the settings later
1072     // and make this NORMAL later, but first
1073     // we have a few calculations that we must fix
1074
1075     switch ( variant )
1076     {
1077         case wxWINDOW_VARIANT_NORMAL :
1078             size = kControlSizeNormal;
1079             themeFont = kThemeSystemFont ;
1080             break ;
1081
1082         case wxWINDOW_VARIANT_SMALL :
1083             size = kControlSizeSmall;
1084             themeFont = kThemeSmallSystemFont ;
1085             break ;
1086
1087         case wxWINDOW_VARIANT_MINI :
1088             // not always defined in the headers
1089             size = 3 ;
1090             themeFont = 109 ;
1091             break ;
1092
1093         case wxWINDOW_VARIANT_LARGE :
1094             size = kControlSizeLarge;
1095             themeFont = kThemeSystemFont ;
1096             break ;
1097
1098         default:
1099             wxFAIL_MSG(_T("unexpected window variant"));
1100             break ;
1101     }
1102
1103     m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
1104
1105     wxFont font ;
1106     font.MacCreateFromThemeFont( themeFont ) ;
1107     SetFont( font ) ;
1108 }
1109
1110 void wxWindowMac::MacUpdateControlFont()
1111 {
1112     m_peer->SetFont( GetFont() , GetForegroundColour() , GetWindowStyle() ) ;
1113     // do not trigger refreshes upon invisible and possible partly created objects
1114     if ( IsShownOnScreen() )
1115         Refresh() ;
1116 }
1117
1118 bool wxWindowMac::SetFont(const wxFont& font)
1119 {
1120     bool retval = wxWindowBase::SetFont( font );
1121
1122     MacUpdateControlFont() ;
1123
1124     return retval;
1125 }
1126
1127 bool wxWindowMac::SetForegroundColour(const wxColour& col )
1128 {
1129     bool retval = wxWindowBase::SetForegroundColour( col );
1130
1131     if (retval)
1132         MacUpdateControlFont();
1133
1134     return retval;
1135 }
1136
1137 bool wxWindowMac::SetBackgroundColour(const wxColour& col )
1138 {
1139     if ( !wxWindowBase::SetBackgroundColour(col) && m_hasBgCol )
1140         return false ;
1141
1142     m_peer->SetBackgroundColour( col ) ;
1143
1144     return true ;
1145 }
1146
1147 bool wxWindowMac::MacCanFocus() const
1148 {
1149     // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
1150     // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning,
1151     // but the value range is nowhere documented
1152     Boolean keyExistsAndHasValidFormat ;
1153     CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue( CFSTR("AppleKeyboardUIMode" ) ,
1154         kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat );
1155
1156     if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
1157     {
1158         return true ;
1159     }
1160     else
1161     {
1162         UInt32 features = 0 ;
1163         m_peer->GetFeatures( &features ) ;
1164
1165         return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
1166     }
1167 }
1168
1169 void wxWindowMac::SetFocus()
1170 {
1171     if ( !AcceptsFocus() )
1172             return ;
1173
1174     wxWindow* former = FindFocus() ;
1175     if ( former == this )
1176         return ;
1177
1178     // as we cannot rely on the control features to find out whether we are in full keyboard mode,
1179     // we can only leave in case of an error
1180     OSStatus err = m_peer->SetFocus( kControlFocusNextPart ) ;
1181     if ( err == errCouldntSetFocus )
1182         return ;
1183
1184     SetUserFocusWindow( (WindowRef)MacGetTopLevelWindowRef() );
1185 }
1186
1187 void wxWindowMac::DoCaptureMouse()
1188 {
1189     wxApp::s_captureWindow = this ;
1190 }
1191
1192 wxWindow * wxWindowBase::GetCapture()
1193 {
1194     return wxApp::s_captureWindow ;
1195 }
1196
1197 void wxWindowMac::DoReleaseMouse()
1198 {
1199     wxApp::s_captureWindow = NULL ;
1200 }
1201
1202 #if wxUSE_DRAG_AND_DROP
1203
1204 void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
1205 {
1206     if ( m_dropTarget != NULL )
1207         delete m_dropTarget;
1208
1209     m_dropTarget = pDropTarget;
1210     if ( m_dropTarget != NULL )
1211     {
1212         // TODO:
1213     }
1214 }
1215
1216 #endif
1217
1218 // Old-style File Manager Drag & Drop
1219 void wxWindowMac::DragAcceptFiles(bool WXUNUSED(accept))
1220 {
1221     // TODO:
1222 }
1223
1224 // Returns the size of the native control. In the case of the toplevel window
1225 // this is the content area root control
1226
1227 void wxWindowMac::MacGetPositionAndSizeFromControl(int& WXUNUSED(x),
1228                                                    int& WXUNUSED(y),
1229                                                    int& WXUNUSED(w),
1230                                                    int& WXUNUSED(h)) const
1231 {
1232     wxFAIL_MSG( wxT("Not currently supported") ) ;
1233 }
1234
1235 // From a wx position / size calculate the appropriate size of the native control
1236
1237 bool wxWindowMac::MacGetBoundsForControl(
1238     const wxPoint& pos,
1239     const wxSize& size,
1240     int& x, int& y,
1241     int& w, int& h , bool adjustOrigin ) const
1242 {
1243     // the desired size, minus the border pixels gives the correct size of the control
1244     x = (int)pos.x;
1245     y = (int)pos.y;
1246
1247     // TODO: the default calls may be used as soon as PostCreateControl Is moved here
1248     w = wxMax(size.x, 0) ; // WidthDefault( size.x );
1249     h = wxMax(size.y, 0) ; // HeightDefault( size.y ) ;
1250
1251     x += MacGetLeftBorderSize() ;
1252     y += MacGetTopBorderSize() ;
1253     w -= MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1254     h -= MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1255
1256     if ( adjustOrigin )
1257         AdjustForParentClientOrigin( x , y ) ;
1258
1259     // this is in window relative coordinate, as this parent may have a border, its physical position is offset by this border
1260     if ( !GetParent()->IsTopLevel() )
1261     {
1262         x -= GetParent()->MacGetLeftBorderSize() ;
1263         y -= GetParent()->MacGetTopBorderSize() ;
1264     }
1265
1266     return true ;
1267 }
1268
1269 // Get window size (not client size)
1270 void wxWindowMac::DoGetSize(int *x, int *y) const
1271 {
1272     Rect bounds ;
1273     m_peer->GetRect( &bounds ) ;
1274
1275     if (x)
1276        *x = bounds.right - bounds.left + MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1277     if (y)
1278        *y = bounds.bottom - bounds.top + MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1279 }
1280
1281 // get the position of the bounds of this window in client coordinates of its parent
1282 void wxWindowMac::DoGetPosition(int *x, int *y) const
1283 {
1284     Rect bounds ;
1285     m_peer->GetRect( &bounds ) ;
1286
1287     int x1 = bounds.left ;
1288     int y1 = bounds.top ;
1289
1290     // get the wx window position from the native one
1291     x1 -= MacGetLeftBorderSize() ;
1292     y1 -= MacGetTopBorderSize() ;
1293
1294     if ( !IsTopLevel() )
1295     {
1296         wxWindow *parent = GetParent();
1297         if ( parent )
1298         {
1299             // we must first adjust it to be in window coordinates of the parent,
1300             // as otherwise it gets lost by the ClientAreaOrigin fix
1301             x1 += parent->MacGetLeftBorderSize() ;
1302             y1 += parent->MacGetTopBorderSize() ;
1303
1304             // and now to client coordinates
1305             wxPoint pt(parent->GetClientAreaOrigin());
1306             x1 -= pt.x ;
1307             y1 -= pt.y ;
1308         }
1309     }
1310
1311     if (x)
1312        *x = x1 ;
1313     if (y)
1314        *y = y1 ;
1315 }
1316
1317 void wxWindowMac::DoScreenToClient(int *x, int *y) const
1318 {
1319     WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
1320     wxCHECK_RET( window , wxT("TopLevel Window missing") ) ;
1321
1322     Point localwhere = { 0, 0 } ;
1323
1324     if (x)
1325         localwhere.h = *x ;
1326     if (y)
1327         localwhere.v = *y ;
1328
1329     wxMacGlobalToLocal( window , &localwhere ) ;
1330
1331     if (x)
1332        *x = localwhere.h ;
1333     if (y)
1334        *y = localwhere.v ;
1335
1336     MacRootWindowToWindow( x , y ) ;
1337
1338     wxPoint origin = GetClientAreaOrigin() ;
1339     if (x)
1340        *x -= origin.x ;
1341     if (y)
1342        *y -= origin.y ;
1343 }
1344
1345 void wxWindowMac::DoClientToScreen(int *x, int *y) const
1346 {
1347     WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
1348     wxCHECK_RET( window , wxT("TopLevel window missing") ) ;
1349
1350     wxPoint origin = GetClientAreaOrigin() ;
1351     if (x)
1352        *x += origin.x ;
1353     if (y)
1354        *y += origin.y ;
1355
1356     MacWindowToRootWindow( x , y ) ;
1357
1358     Point localwhere = { 0, 0 };
1359     if (x)
1360        localwhere.h = *x ;
1361     if (y)
1362        localwhere.v = *y ;
1363
1364     wxMacLocalToGlobal( window, &localwhere ) ;
1365
1366     if (x)
1367        *x = localwhere.h ;
1368     if (y)
1369        *y = localwhere.v ;
1370 }
1371
1372 void wxWindowMac::MacClientToRootWindow( int *x , int *y ) const
1373 {
1374     wxPoint origin = GetClientAreaOrigin() ;
1375     if (x)
1376        *x += origin.x ;
1377     if (y)
1378        *y += origin.y ;
1379
1380     MacWindowToRootWindow( x , y ) ;
1381 }
1382
1383 void wxWindowMac::MacRootWindowToClient( int *x , int *y ) const
1384 {
1385     MacRootWindowToWindow( x , y ) ;
1386
1387     wxPoint origin = GetClientAreaOrigin() ;
1388     if (x)
1389        *x -= origin.x ;
1390     if (y)
1391        *y -= origin.y ;
1392 }
1393
1394 void wxWindowMac::MacWindowToRootWindow( int *x , int *y ) const
1395 {
1396     wxPoint pt ;
1397
1398     if (x)
1399         pt.x = *x ;
1400     if (y)
1401         pt.y = *y ;
1402
1403     if ( !IsTopLevel() )
1404     {
1405         wxTopLevelWindowMac* top = MacGetTopLevelWindow();
1406         if (top)
1407         {
1408             pt.x -= MacGetLeftBorderSize() ;
1409             pt.y -= MacGetTopBorderSize() ;
1410             wxMacControl::Convert( &pt , m_peer , top->m_peer ) ;
1411         }
1412     }
1413
1414     if (x)
1415         *x = (int) pt.x ;
1416     if (y)
1417         *y = (int) pt.y ;
1418 }
1419
1420 void wxWindowMac::MacWindowToRootWindow( short *x , short *y ) const
1421 {
1422     int x1 , y1 ;
1423
1424     if (x)
1425         x1 = *x ;
1426     if (y)
1427         y1 = *y ;
1428
1429     MacWindowToRootWindow( &x1 , &y1 ) ;
1430
1431     if (x)
1432         *x = x1 ;
1433     if (y)
1434         *y = y1 ;
1435 }
1436
1437 void wxWindowMac::MacRootWindowToWindow( int *x , int *y ) const
1438 {
1439     wxPoint pt ;
1440
1441     if (x)
1442         pt.x = *x ;
1443     if (y)
1444         pt.y = *y ;
1445
1446     if ( !IsTopLevel() )
1447     {
1448         wxTopLevelWindowMac* top = MacGetTopLevelWindow();
1449         if (top)
1450         {
1451             wxMacControl::Convert( &pt , top->m_peer , m_peer ) ;
1452             pt.x += MacGetLeftBorderSize() ;
1453             pt.y += MacGetTopBorderSize() ;
1454         }
1455     }
1456
1457     if (x)
1458         *x = (int) pt.x ;
1459     if (y)
1460         *y = (int) pt.y ;
1461 }
1462
1463 void wxWindowMac::MacRootWindowToWindow( short *x , short *y ) const
1464 {
1465     int x1 , y1 ;
1466
1467     if (x)
1468         x1 = *x ;
1469     if (y)
1470         y1 = *y ;
1471
1472     MacRootWindowToWindow( &x1 , &y1 ) ;
1473
1474     if (x)
1475         *x = x1 ;
1476     if (y)
1477         *y = y1 ;
1478 }
1479
1480 void wxWindowMac::MacGetContentAreaInset( int &left , int &top , int &right , int &bottom )
1481 {
1482     RgnHandle rgn = NewRgn() ;
1483
1484     if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1485     {
1486         Rect structure, content ;
1487
1488         GetRegionBounds( rgn , &content ) ;
1489         m_peer->GetRect( &structure ) ;
1490         OffsetRect( &structure, -structure.left , -structure.top ) ;
1491
1492         left = content.left - structure.left ;
1493         top = content.top - structure.top ;
1494         right = structure.right - content.right ;
1495         bottom = structure.bottom - content.bottom ;
1496     }
1497     else
1498     {
1499         left = top = right = bottom = 0 ;
1500     }
1501
1502     DisposeRgn( rgn ) ;
1503 }
1504
1505 wxSize wxWindowMac::DoGetSizeFromClientSize( const wxSize & size )  const
1506 {
1507     wxSize sizeTotal = size;
1508
1509     RgnHandle rgn = NewRgn() ;
1510     if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1511     {
1512         Rect content, structure ;
1513         GetRegionBounds( rgn , &content ) ;
1514         m_peer->GetRect( &structure ) ;
1515
1516         // structure is in parent coordinates, but we only need width and height, so it's ok
1517
1518         sizeTotal.x += (structure.right - structure.left) - (content.right - content.left) ;
1519         sizeTotal.y += (structure.bottom - structure.top) - (content.bottom - content.top) ;
1520     }
1521
1522     DisposeRgn( rgn ) ;
1523
1524     sizeTotal.x += MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1525     sizeTotal.y += MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1526
1527     return sizeTotal;
1528 }
1529
1530 // Get size *available for subwindows* i.e. excluding menu bar etc.
1531 void wxWindowMac::DoGetClientSize( int *x, int *y ) const
1532 {
1533     int ww, hh;
1534
1535     RgnHandle rgn = NewRgn() ;
1536     Rect content ;
1537     if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1538         GetRegionBounds( rgn , &content ) ;
1539     else
1540         m_peer->GetRect( &content ) ;
1541     DisposeRgn( rgn ) ;
1542
1543     ww = content.right - content.left ;
1544     hh = content.bottom - content.top ;
1545
1546     if (m_hScrollBar  && m_hScrollBar->IsShown() )
1547         hh -= m_hScrollBar->GetSize().y ;
1548
1549     if (m_vScrollBar  && m_vScrollBar->IsShown() )
1550         ww -= m_vScrollBar->GetSize().x ;
1551
1552     if (x)
1553        *x = ww;
1554     if (y)
1555        *y = hh;
1556 }
1557
1558 bool wxWindowMac::SetCursor(const wxCursor& cursor)
1559 {
1560     if (m_cursor.IsSameAs(cursor))
1561         return false;
1562
1563     if (!cursor.IsOk())
1564     {
1565         if ( ! wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ) )
1566             return false ;
1567     }
1568     else
1569     {
1570         if ( ! wxWindowBase::SetCursor( cursor ) )
1571             return false ;
1572     }
1573
1574     wxASSERT_MSG( m_cursor.Ok(),
1575         wxT("cursor must be valid after call to the base version"));
1576
1577     wxWindowMac *mouseWin = 0 ;
1578     {
1579         wxTopLevelWindowMac *tlw = MacGetTopLevelWindow() ;
1580         WindowRef window = (WindowRef) ( tlw ? tlw->MacGetWindowRef() : 0 ) ;
1581
1582         ControlPartCode part ;
1583         ControlRef control ;
1584         Point pt ;
1585  #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1586         HIPoint hiPoint ;
1587         HIGetMousePosition(kHICoordSpaceWindow, window, &hiPoint);
1588         pt.h = hiPoint.x;
1589         pt.v = hiPoint.y;
1590  #else
1591         GetGlobalMouse( &pt );
1592         int x = pt.h;
1593         int y = pt.v;
1594         ScreenToClient(&x, &y);
1595         pt.h = x;
1596         pt.v = y;
1597 #endif
1598         control = FindControlUnderMouse( pt , window , &part ) ;
1599         if ( control )
1600             mouseWin = wxFindControlFromMacControl( control ) ;
1601
1602     }
1603
1604     if ( mouseWin == this && !wxIsBusy() )
1605         m_cursor.MacInstall() ;
1606
1607     return true ;
1608 }
1609
1610 #if wxUSE_MENUS
1611 bool wxWindowMac::DoPopupMenu(wxMenu *menu, int x, int y)
1612 {
1613 #ifndef __WXUNIVERSAL__
1614     menu->SetInvokingWindow((wxWindow*)this);
1615     menu->UpdateUI();
1616
1617     if ( x == wxDefaultCoord && y == wxDefaultCoord )
1618     {
1619         wxPoint mouse = wxGetMousePosition();
1620         x = mouse.x;
1621         y = mouse.y;
1622     }
1623     else
1624     {
1625         ClientToScreen( &x , &y ) ;
1626     }
1627
1628     menu->MacBeforeDisplay( true ) ;
1629     long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() , y, x, 0) ;
1630     if ( HiWord(menuResult) != 0 )
1631     {
1632         MenuCommand macid;
1633         GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
1634         int id = wxMacCommandToId( macid );
1635         wxMenuItem* item = NULL ;
1636         wxMenu* realmenu ;
1637         item = menu->FindItem( id, &realmenu ) ;
1638         if ( item )
1639         {
1640             if (item->IsCheckable())
1641                 item->Check( !item->IsChecked() ) ;
1642
1643             menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
1644         }
1645     }
1646
1647     menu->MacAfterDisplay( true ) ;
1648     menu->SetInvokingWindow( NULL );
1649
1650   return true;
1651 #else
1652     // actually this shouldn't be called, because universal is having its own implementation
1653     return false;
1654 #endif
1655 }
1656 #endif
1657
1658 // ----------------------------------------------------------------------------
1659 // tooltips
1660 // ----------------------------------------------------------------------------
1661
1662 #if wxUSE_TOOLTIPS
1663
1664 void wxWindowMac::DoSetToolTip(wxToolTip *tooltip)
1665 {
1666     wxWindowBase::DoSetToolTip(tooltip);
1667
1668     if ( m_tooltip )
1669         m_tooltip->SetWindow(this);
1670 }
1671
1672 #endif
1673
1674 void wxWindowMac::MacInvalidateBorders()
1675 {
1676     if ( m_peer == NULL )
1677         return ;
1678
1679     bool vis = IsShownOnScreen() ;
1680     if ( !vis )
1681         return ;
1682
1683     int outerBorder = MacGetLeftBorderSize() ;
1684     if ( m_peer->NeedsFocusRect() /* && m_peer->HasFocus() */ )
1685         outerBorder += 4 ;
1686
1687     if ( outerBorder == 0 )
1688         return ;
1689
1690     // now we know that we have something to do at all
1691
1692     // as the borders are drawn on the parent we have to properly invalidate all these areas
1693     RgnHandle updateInner , updateOuter;
1694     Rect rect ;
1695
1696     // this rectangle is in HIViewCoordinates under OSX and in Window Coordinates under Carbon
1697     updateInner = NewRgn() ;
1698     updateOuter = NewRgn() ;
1699
1700     m_peer->GetRect( &rect ) ;
1701     RectRgn( updateInner, &rect ) ;
1702     InsetRect( &rect , -outerBorder , -outerBorder ) ;
1703     RectRgn( updateOuter, &rect ) ;
1704     DiffRgn( updateOuter, updateInner , updateOuter ) ;
1705
1706     GetParent()->m_peer->SetNeedsDisplay( updateOuter ) ;
1707
1708     DisposeRgn( updateOuter ) ;
1709     DisposeRgn( updateInner ) ;
1710 }
1711
1712 void wxWindowMac::DoMoveWindow(int x, int y, int width, int height)
1713 {
1714     // this is never called for a toplevel window, so we know we have a parent
1715     int former_x , former_y , former_w, former_h ;
1716
1717     // Get true coordinates of former position
1718     DoGetPosition( &former_x , &former_y ) ;
1719     DoGetSize( &former_w , &former_h ) ;
1720
1721     wxWindow *parent = GetParent();
1722     if ( parent )
1723     {
1724         wxPoint pt(parent->GetClientAreaOrigin());
1725         former_x += pt.x ;
1726         former_y += pt.y ;
1727     }
1728
1729     int actualWidth = width ;
1730     int actualHeight = height ;
1731     int actualX = x;
1732     int actualY = y;
1733
1734     if ((m_minWidth != -1) && (actualWidth < m_minWidth))
1735         actualWidth = m_minWidth;
1736     if ((m_minHeight != -1) && (actualHeight < m_minHeight))
1737         actualHeight = m_minHeight;
1738     if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
1739         actualWidth = m_maxWidth;
1740     if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
1741         actualHeight = m_maxHeight;
1742
1743     bool doMove = false, doResize = false ;
1744
1745     if ( actualX != former_x || actualY != former_y )
1746         doMove = true ;
1747
1748     if ( actualWidth != former_w || actualHeight != former_h )
1749         doResize = true ;
1750
1751     if ( doMove || doResize )
1752     {
1753         // as the borders are drawn outside the native control, we adjust now
1754
1755         wxRect bounds( wxPoint( actualX + MacGetLeftBorderSize() ,actualY + MacGetTopBorderSize() ),
1756             wxSize( actualWidth - (MacGetLeftBorderSize() + MacGetRightBorderSize()) ,
1757                 actualHeight - (MacGetTopBorderSize() + MacGetBottomBorderSize()) ) ) ;
1758
1759         Rect r ;
1760         wxMacRectToNative( &bounds , &r ) ;
1761
1762         if ( !GetParent()->IsTopLevel() )
1763             wxMacWindowToNative( GetParent() , &r ) ;
1764
1765         MacInvalidateBorders() ;
1766
1767         m_cachedClippedRectValid = false ;
1768         m_peer->SetRect( &r ) ;
1769
1770         wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
1771
1772         MacInvalidateBorders() ;
1773
1774         MacRepositionScrollBars() ;
1775         if ( doMove )
1776         {
1777             wxPoint point(actualX, actualY);
1778             wxMoveEvent event(point, m_windowId);
1779             event.SetEventObject(this);
1780             HandleWindowEvent(event) ;
1781         }
1782
1783         if ( doResize )
1784         {
1785             MacRepositionScrollBars() ;
1786             wxSize size(actualWidth, actualHeight);
1787             wxSizeEvent event(size, m_windowId);
1788             event.SetEventObject(this);
1789             HandleWindowEvent(event);
1790         }
1791     }
1792 }
1793
1794 wxSize wxWindowMac::DoGetBestSize() const
1795 {
1796     if ( m_macIsUserPane || IsTopLevel() )
1797         return wxWindowBase::DoGetBestSize() ;
1798
1799     Rect    bestsize = { 0 , 0 , 0 , 0 } ;
1800     int bestWidth, bestHeight ;
1801
1802     m_peer->GetBestRect( &bestsize ) ;
1803     if ( EmptyRect( &bestsize ) )
1804     {
1805         bestsize.left =
1806         bestsize.top = 0 ;
1807         bestsize.right =
1808         bestsize.bottom = 16 ;
1809
1810         if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
1811         {
1812             bestsize.bottom = 16 ;
1813         }
1814 #if wxUSE_SPINBTN
1815         else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
1816         {
1817             bestsize.bottom = 24 ;
1818         }
1819 #endif
1820         else
1821         {
1822             // return wxWindowBase::DoGetBestSize() ;
1823         }
1824     }
1825
1826     bestWidth = bestsize.right - bestsize.left ;
1827     bestHeight = bestsize.bottom - bestsize.top ;
1828     if ( bestHeight < 10 )
1829         bestHeight = 13 ;
1830
1831     return wxSize(bestWidth, bestHeight);
1832 }
1833
1834 // set the size of the window: if the dimensions are positive, just use them,
1835 // but if any of them is equal to -1, it means that we must find the value for
1836 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1837 // which case -1 is a valid value for x and y)
1838 //
1839 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1840 // the width/height to best suit our contents, otherwise we reuse the current
1841 // width/height
1842 void wxWindowMac::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1843 {
1844     // get the current size and position...
1845     int currentX, currentY;
1846     int currentW, currentH;
1847
1848     GetPosition(&currentX, &currentY);
1849     GetSize(&currentW, &currentH);
1850
1851     // ... and don't do anything (avoiding flicker) if it's already ok
1852     if ( x == currentX && y == currentY &&
1853         width == currentW && height == currentH && ( height != -1 && width != -1 ) )
1854     {
1855         // TODO: REMOVE
1856         MacRepositionScrollBars() ; // we might have a real position shift
1857
1858         return;
1859     }
1860
1861     if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1862     {
1863         if ( x == wxDefaultCoord )
1864             x = currentX;
1865         if ( y == wxDefaultCoord )
1866             y = currentY;
1867     }
1868
1869     AdjustForParentClientOrigin( x, y, sizeFlags );
1870
1871     wxSize size = wxDefaultSize;
1872     if ( width == wxDefaultCoord )
1873     {
1874         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1875         {
1876             size = DoGetBestSize();
1877             width = size.x;
1878         }
1879         else
1880         {
1881             // just take the current one
1882             width = currentW;
1883         }
1884     }
1885
1886     if ( height == wxDefaultCoord )
1887     {
1888         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1889         {
1890             if ( size.x == wxDefaultCoord )
1891                 size = DoGetBestSize();
1892             // else: already called DoGetBestSize() above
1893
1894             height = size.y;
1895         }
1896         else
1897         {
1898             // just take the current one
1899             height = currentH;
1900         }
1901     }
1902
1903     DoMoveWindow( x, y, width, height );
1904 }
1905
1906 wxPoint wxWindowMac::GetClientAreaOrigin() const
1907 {
1908     RgnHandle rgn = NewRgn() ;
1909     Rect content ;
1910     if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1911     {
1912         GetRegionBounds( rgn , &content ) ;
1913     }
1914     else
1915     {
1916         content.left =
1917         content.top = 0 ;
1918     }
1919
1920     DisposeRgn( rgn ) ;
1921
1922     return wxPoint( content.left + MacGetLeftBorderSize() , content.top + MacGetTopBorderSize() );
1923 }
1924
1925 void wxWindowMac::DoSetClientSize(int clientwidth, int clientheight)
1926 {
1927     if ( clientwidth != wxDefaultCoord || clientheight != wxDefaultCoord )
1928     {
1929         int currentclientwidth , currentclientheight ;
1930         int currentwidth , currentheight ;
1931
1932         GetClientSize( &currentclientwidth , &currentclientheight ) ;
1933         GetSize( &currentwidth , &currentheight ) ;
1934
1935         DoSetSize( wxDefaultCoord , wxDefaultCoord , currentwidth + clientwidth - currentclientwidth ,
1936             currentheight + clientheight - currentclientheight , wxSIZE_USE_EXISTING ) ;
1937     }
1938 }
1939
1940 void wxWindowMac::SetLabel(const wxString& title)
1941 {
1942     m_label = title ;
1943
1944     if ( m_peer && m_peer->Ok() )
1945         m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics) ) ;
1946
1947     // do not trigger refreshes upon invisible and possible partly created objects
1948     if ( IsShownOnScreen() )
1949         Refresh() ;
1950 }
1951
1952 wxString wxWindowMac::GetLabel() const
1953 {
1954     return m_label ;
1955 }
1956
1957 bool wxWindowMac::Show(bool show)
1958 {
1959     if ( !wxWindowBase::Show(show) )
1960         return false;
1961
1962     if ( m_peer )
1963         m_peer->SetVisibility( show , true ) ;
1964
1965     return true;
1966 }
1967
1968 void wxWindowMac::DoEnable(bool enable)
1969 {
1970     m_peer->Enable( enable ) ;
1971 }
1972
1973 //
1974 // status change notifications
1975 //
1976
1977 void wxWindowMac::MacVisibilityChanged()
1978 {
1979 }
1980
1981 void wxWindowMac::MacHiliteChanged()
1982 {
1983 }
1984
1985 void wxWindowMac::MacEnabledStateChanged()
1986 {
1987     OnEnabled( m_peer->IsEnabled() );
1988 }
1989
1990 //
1991 // status queries on the inherited window's state
1992 //
1993
1994 bool wxWindowMac::MacIsReallyEnabled()
1995 {
1996     return m_peer->IsEnabled() ;
1997 }
1998
1999 bool wxWindowMac::MacIsReallyHilited()
2000 {
2001     return m_peer->IsActive();
2002 }
2003
2004 void wxWindowMac::MacFlashInvalidAreas()
2005 {
2006 #if TARGET_API_MAC_OSX
2007     HIViewFlashDirtyArea( (WindowRef) MacGetTopLevelWindowRef() ) ;
2008 #endif
2009 }
2010
2011 int wxWindowMac::GetCharHeight() const
2012 {
2013     wxClientDC dc( (wxWindowMac*)this ) ;
2014
2015     return dc.GetCharHeight() ;
2016 }
2017
2018 int wxWindowMac::GetCharWidth() const
2019 {
2020     wxClientDC dc( (wxWindowMac*)this ) ;
2021
2022     return dc.GetCharWidth() ;
2023 }
2024
2025 void wxWindowMac::GetTextExtent(const wxString& string, int *x, int *y,
2026                            int *descent, int *externalLeading, const wxFont *theFont ) const
2027 {
2028     const wxFont *fontToUse = theFont;
2029     if ( !fontToUse )
2030         fontToUse = &m_font;
2031
2032     wxClientDC dc( (wxWindowMac*) this ) ;
2033     wxCoord lx,ly,ld,le ;
2034     dc.GetTextExtent( string , &lx , &ly , &ld, &le, (wxFont *)fontToUse ) ;
2035     if ( externalLeading )
2036         *externalLeading = le ;
2037     if ( descent )
2038         *descent = ld ;
2039     if ( x )
2040         *x = lx ;
2041     if ( y )
2042         *y = ly ;
2043 }
2044
2045 /*
2046  * Rect is given in client coordinates, for further reading, read wxTopLevelWindowMac::InvalidateRect
2047  * we always intersect with the entire window, not only with the client area
2048  */
2049
2050 void wxWindowMac::Refresh(bool WXUNUSED(eraseBack), const wxRect *rect)
2051 {
2052     if ( m_peer == NULL )
2053         return ;
2054
2055     if ( !IsShownOnScreen() )
2056         return ;
2057
2058     if ( rect )
2059     {
2060         Rect r ;
2061
2062         wxMacRectToNative( rect , &r ) ;
2063         m_peer->SetNeedsDisplay( &r ) ;
2064     }
2065     else
2066     {
2067         m_peer->SetNeedsDisplay() ;
2068     }
2069 }
2070
2071 void wxWindowMac::DoFreeze()
2072 {
2073 #if TARGET_API_MAC_OSX
2074     if ( m_peer && m_peer->Ok() )
2075         m_peer->SetDrawingEnabled( false ) ;
2076 #endif
2077 }
2078
2079 void wxWindowMac::DoThaw()
2080 {
2081 #if TARGET_API_MAC_OSX
2082     if ( m_peer && m_peer->Ok() )
2083     {
2084         m_peer->SetDrawingEnabled( true ) ;
2085         m_peer->InvalidateWithChildren() ;
2086     }
2087 #endif
2088 }
2089
2090 wxWindowMac *wxGetActiveWindow()
2091 {
2092     // actually this is a windows-only concept
2093     return NULL;
2094 }
2095
2096 // Coordinates relative to the window
2097 void wxWindowMac::WarpPointer(int WXUNUSED(x_pos), int WXUNUSED(y_pos))
2098 {
2099     // We really don't move the mouse programmatically under Mac.
2100 }
2101
2102 void wxWindowMac::OnEraseBackground(wxEraseEvent& event)
2103 {
2104     if ( MacGetTopLevelWindow() == NULL )
2105         return ;
2106 /*
2107 #if TARGET_API_MAC_OSX
2108     if ( !m_backgroundColour.Ok() || GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
2109     {
2110     }
2111     else
2112 #endif
2113 */
2114     if ( GetBackgroundStyle() == wxBG_STYLE_COLOUR )
2115     {
2116         event.GetDC()->Clear() ;
2117     }
2118     else if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM )
2119     {
2120         // don't skip the event here, custom background means that the app
2121         // is drawing it itself in its OnPaint(), so don't draw it at all
2122         // now to avoid flicker
2123     }
2124     else
2125     {
2126         event.Skip() ;
2127     }
2128 }
2129
2130 void wxWindowMac::OnNcPaint( wxNcPaintEvent& event )
2131 {
2132     event.Skip() ;
2133 }
2134
2135 int wxWindowMac::GetScrollPos(int orient) const
2136 {
2137     if ( orient == wxHORIZONTAL )
2138     {
2139        if ( m_hScrollBar )
2140            return m_hScrollBar->GetThumbPosition() ;
2141     }
2142     else
2143     {
2144        if ( m_vScrollBar )
2145            return m_vScrollBar->GetThumbPosition() ;
2146     }
2147
2148     return 0;
2149 }
2150
2151 // This now returns the whole range, not just the number
2152 // of positions that we can scroll.
2153 int wxWindowMac::GetScrollRange(int orient) const
2154 {
2155     if ( orient == wxHORIZONTAL )
2156     {
2157        if ( m_hScrollBar )
2158            return m_hScrollBar->GetRange() ;
2159     }
2160     else
2161     {
2162        if ( m_vScrollBar )
2163            return m_vScrollBar->GetRange() ;
2164     }
2165
2166     return 0;
2167 }
2168
2169 int wxWindowMac::GetScrollThumb(int orient) const
2170 {
2171     if ( orient == wxHORIZONTAL )
2172     {
2173        if ( m_hScrollBar )
2174            return m_hScrollBar->GetThumbSize() ;
2175     }
2176     else
2177     {
2178        if ( m_vScrollBar )
2179            return m_vScrollBar->GetThumbSize() ;
2180     }
2181
2182     return 0;
2183 }
2184
2185 void wxWindowMac::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
2186 {
2187     if ( orient == wxHORIZONTAL )
2188     {
2189        if ( m_hScrollBar )
2190            m_hScrollBar->SetThumbPosition( pos ) ;
2191     }
2192     else
2193     {
2194        if ( m_vScrollBar )
2195            m_vScrollBar->SetThumbPosition( pos ) ;
2196     }
2197 }
2198
2199 void
2200 wxWindowMac::AlwaysShowScrollbars(bool hflag, bool vflag)
2201 {
2202     bool needVisibilityUpdate = false;
2203
2204     if ( m_hScrollBarAlwaysShown != hflag )
2205     {
2206         m_hScrollBarAlwaysShown = hflag;
2207         needVisibilityUpdate = true;
2208     }
2209
2210     if ( m_vScrollBarAlwaysShown != vflag )
2211     {
2212         m_vScrollBarAlwaysShown = vflag;
2213         needVisibilityUpdate = true;
2214     }
2215
2216     if ( needVisibilityUpdate )
2217         DoUpdateScrollbarVisibility();
2218 }
2219
2220 //
2221 // we draw borders and grow boxes, are already set up and clipped in the current port / cgContextRef
2222 // our own window origin is at leftOrigin/rightOrigin
2223 //
2224
2225 void  wxWindowMac::MacPaintGrowBox()
2226 {
2227     if ( IsTopLevel() )
2228         return ;
2229
2230     if ( MacHasScrollBarCorner() )
2231     {
2232         Rect rect ;
2233
2234         CGContextRef cgContext = (CGContextRef) MacGetCGContextRef() ;
2235         wxASSERT( cgContext ) ;
2236
2237         m_peer->GetRect( &rect ) ;
2238
2239         int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2240         CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
2241         CGPoint cgpoint = CGPointMake( rect.right - size , rect.bottom - size ) ;
2242         CGContextSaveGState( cgContext );
2243
2244         if ( m_backgroundColour.Ok() )
2245         {
2246             CGContextSetFillColorWithColor( cgContext, m_backgroundColour.GetCGColor() );
2247         }
2248         else
2249         {
2250             CGContextSetRGBFillColor( cgContext, 1.0, 1.0 , 1.0 , 1.0 );
2251         }
2252         CGContextFillRect( cgContext, cgrect );
2253         CGContextRestoreGState( cgContext );
2254     }
2255 }
2256
2257 void wxWindowMac::MacPaintBorders( int WXUNUSED(leftOrigin) , int WXUNUSED(rightOrigin) )
2258 {
2259     if ( IsTopLevel() )
2260         return ;
2261
2262     Rect rect ;
2263     bool hasFocus = m_peer->NeedsFocusRect() && m_peer->HasFocus() ;
2264
2265     // back to the surrounding frame rectangle
2266     m_peer->GetRect( &rect ) ;
2267     InsetRect( &rect, -1 , -1 ) ;
2268
2269     {
2270         CGRect cgrect = CGRectMake( rect.left , rect.top , rect.right - rect.left ,
2271             rect.bottom - rect.top ) ;
2272
2273         HIThemeFrameDrawInfo info ;
2274         memset( &info, 0 , sizeof(info) ) ;
2275
2276         info.version = 0 ;
2277         info.kind = 0 ;
2278         info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
2279         info.isFocused = hasFocus ;
2280
2281         CGContextRef cgContext = (CGContextRef) GetParent()->MacGetCGContextRef() ;
2282         wxASSERT( cgContext ) ;
2283
2284         if ( HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER) )
2285         {
2286             info.kind = kHIThemeFrameTextFieldSquare ;
2287             HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
2288         }
2289         else if ( HasFlag(wxSIMPLE_BORDER) )
2290         {
2291             info.kind = kHIThemeFrameListBox ;
2292             HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
2293         }
2294         else if ( hasFocus )
2295         {
2296             HIThemeDrawFocusRect( &cgrect , true , cgContext , kHIThemeOrientationNormal ) ;
2297         }
2298 #if 0 // TODO REMOVE now done in a separate call earlier in drawing the window itself
2299         m_peer->GetRect( &rect ) ;
2300         if ( MacHasScrollBarCorner() )
2301         {
2302             int variant = (m_hScrollBar == NULL ? m_vScrollBar : m_hScrollBar ) ->GetWindowVariant();
2303             int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2304             CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
2305             CGPoint cgpoint = CGPointMake( rect.right - size , rect.bottom - size ) ;
2306             HIThemeGrowBoxDrawInfo info ;
2307             memset( &info, 0, sizeof(info) ) ;
2308             info.version = 0 ;
2309             info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
2310             info.kind = kHIThemeGrowBoxKindNone ;
2311             // contrary to the docs ...SizeSmall does not work
2312             info.size = kHIThemeGrowBoxSizeNormal ;
2313             info.direction = 0 ;
2314             HIThemeDrawGrowBox( &cgpoint , &info , cgContext , kHIThemeOrientationNormal ) ;
2315         }
2316 #endif
2317     }
2318 }
2319
2320 void wxWindowMac::RemoveChild( wxWindowBase *child )
2321 {
2322     if ( child == m_hScrollBar )
2323         m_hScrollBar = NULL ;
2324     if ( child == m_vScrollBar )
2325         m_vScrollBar = NULL ;
2326
2327     wxWindowBase::RemoveChild( child ) ;
2328 }
2329
2330 void wxWindowMac::DoUpdateScrollbarVisibility()
2331 {
2332     bool triggerSizeEvent = false;
2333
2334     if ( m_hScrollBar )
2335     {
2336         bool showHScrollBar = m_hScrollBarAlwaysShown || m_hScrollBar->IsNeeded();
2337
2338         if ( m_hScrollBar->IsShown() != showHScrollBar )
2339         {
2340             m_hScrollBar->Show( showHScrollBar );
2341             triggerSizeEvent = true;
2342         }
2343     }
2344
2345     if ( m_vScrollBar)
2346     {
2347         bool showVScrollBar = m_vScrollBarAlwaysShown || m_vScrollBar->IsNeeded();
2348
2349         if ( m_vScrollBar->IsShown() != showVScrollBar )
2350         {
2351             m_vScrollBar->Show( showVScrollBar ) ;
2352             triggerSizeEvent = true;
2353         }
2354     }
2355
2356     MacRepositionScrollBars() ;
2357     if ( triggerSizeEvent )
2358     {
2359         wxSizeEvent event(GetSize(), m_windowId);
2360         event.SetEventObject(this);
2361         HandleWindowEvent(event);
2362     }
2363 }
2364
2365 // New function that will replace some of the above.
2366 void wxWindowMac::SetScrollbar(int orient, int pos, int thumb,
2367                                int range, bool refresh)
2368 {
2369     if ( orient == wxHORIZONTAL && m_hScrollBar )
2370         m_hScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
2371     else if ( orient == wxVERTICAL && m_vScrollBar )
2372         m_vScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
2373
2374     DoUpdateScrollbarVisibility();
2375 }
2376
2377 // Does a physical scroll
2378 void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
2379 {
2380     if ( dx == 0 && dy == 0 )
2381         return ;
2382
2383     int width , height ;
2384     GetClientSize( &width , &height ) ;
2385
2386     {
2387         // note there currently is a bug in OSX which makes inefficient refreshes in case an entire control
2388         // area is scrolled, this does not occur if width and height are 2 pixels less,
2389         // TODO: write optimal workaround
2390         wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
2391         if ( rect )
2392             scrollrect.Intersect( *rect ) ;
2393
2394         if ( m_peer->GetNeedsDisplay() )
2395         {
2396             // because HIViewScrollRect does not scroll the already invalidated area we have two options:
2397             // in case there is already a pending redraw on that area
2398             // either immediate redraw or full invalidate
2399 #if 1
2400             // is the better overall solution, as it does not slow down scrolling
2401             m_peer->SetNeedsDisplay() ;
2402 #else
2403             // this would be the preferred version for fast drawing controls
2404             HIViewRender(m_peer->GetControlRef()) ;
2405 #endif
2406         }
2407
2408         // as the native control might be not a 0/0 wx window coordinates, we have to offset
2409         scrollrect.Offset( -MacGetLeftBorderSize() , -MacGetTopBorderSize() ) ;
2410         m_peer->ScrollRect( &scrollrect , dx , dy ) ;
2411
2412 #if 0
2413         // this would be the preferred version for fast drawing controls
2414         HIViewRender(m_peer->GetControlRef()) ;
2415 #endif
2416     }
2417
2418     wxWindowMac *child;
2419     int x, y, w, h;
2420     for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
2421     {
2422         child = node->GetData();
2423         if (child == NULL)
2424             continue;
2425         if (child == m_vScrollBar)
2426             continue;
2427         if (child == m_hScrollBar)
2428             continue;
2429         if (child->IsTopLevel())
2430             continue;
2431
2432         child->GetPosition( &x, &y );
2433         child->GetSize( &w, &h );
2434         if (rect)
2435         {
2436             wxRect rc( x, y, w, h );
2437             if (rect->Intersects( rc ))
2438                 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
2439         }
2440         else
2441         {
2442             child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
2443         }
2444     }
2445 }
2446
2447 void wxWindowMac::MacOnScroll( wxScrollEvent &event )
2448 {
2449     if ( event.GetEventObject() == m_vScrollBar || event.GetEventObject() == m_hScrollBar )
2450     {
2451         wxScrollWinEvent wevent;
2452         wevent.SetPosition(event.GetPosition());
2453         wevent.SetOrientation(event.GetOrientation());
2454         wevent.SetEventObject(this);
2455
2456         if (event.GetEventType() == wxEVT_SCROLL_TOP)
2457             wevent.SetEventType( wxEVT_SCROLLWIN_TOP );
2458         else if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
2459             wevent.SetEventType( wxEVT_SCROLLWIN_BOTTOM );
2460         else if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
2461             wevent.SetEventType( wxEVT_SCROLLWIN_LINEUP );
2462         else if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
2463             wevent.SetEventType( wxEVT_SCROLLWIN_LINEDOWN );
2464         else if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
2465             wevent.SetEventType( wxEVT_SCROLLWIN_PAGEUP );
2466         else if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
2467             wevent.SetEventType( wxEVT_SCROLLWIN_PAGEDOWN );
2468         else if (event.GetEventType() == wxEVT_SCROLL_THUMBTRACK)
2469             wevent.SetEventType( wxEVT_SCROLLWIN_THUMBTRACK );
2470         else if (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE)
2471             wevent.SetEventType( wxEVT_SCROLLWIN_THUMBRELEASE );
2472
2473         HandleWindowEvent(wevent);
2474     }
2475 }
2476
2477 // Get the window with the focus
2478 wxWindowMac *wxWindowBase::DoFindFocus()
2479 {
2480     ControlRef control ;
2481     GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
2482     return wxFindControlFromMacControl( control ) ;
2483 }
2484
2485 void wxWindowMac::OnInternalIdle()
2486 {
2487     // This calls the UI-update mechanism (querying windows for
2488     // menu/toolbar/control state information)
2489     if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2490         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2491 }
2492
2493 // Raise the window to the top of the Z order
2494 void wxWindowMac::Raise()
2495 {
2496     m_peer->SetZOrder( true , NULL ) ;
2497 }
2498
2499 // Lower the window to the bottom of the Z order
2500 void wxWindowMac::Lower()
2501 {
2502     m_peer->SetZOrder( false , NULL ) ;
2503 }
2504
2505 // static wxWindow *gs_lastWhich = NULL;
2506
2507 bool wxWindowMac::MacSetupCursor( const wxPoint& pt )
2508 {
2509     // first trigger a set cursor event
2510
2511     wxPoint clientorigin = GetClientAreaOrigin() ;
2512     wxSize clientsize = GetClientSize() ;
2513     wxCursor cursor ;
2514     if ( wxRect2DInt( clientorigin.x , clientorigin.y , clientsize.x , clientsize.y ).Contains( wxPoint2DInt( pt ) ) )
2515     {
2516         wxSetCursorEvent event( pt.x , pt.y );
2517
2518         bool processedEvtSetCursor = HandleWindowEvent(event);
2519         if ( processedEvtSetCursor && event.HasCursor() )
2520         {
2521             cursor = event.GetCursor() ;
2522         }
2523         else
2524         {
2525             // the test for processedEvtSetCursor is here to prevent using m_cursor
2526             // if the user code caught EVT_SET_CURSOR() and returned nothing from
2527             // it - this is a way to say that our cursor shouldn't be used for this
2528             // point
2529             if ( !processedEvtSetCursor && m_cursor.Ok() )
2530                 cursor = m_cursor ;
2531
2532             if ( !wxIsBusy() && !GetParent() )
2533                 cursor = *wxSTANDARD_CURSOR ;
2534         }
2535
2536         if ( cursor.Ok() )
2537             cursor.MacInstall() ;
2538     }
2539
2540     return cursor.Ok() ;
2541 }
2542
2543 wxString wxWindowMac::MacGetToolTipString( wxPoint &WXUNUSED(pt) )
2544 {
2545 #if wxUSE_TOOLTIPS
2546     if ( m_tooltip )
2547         return m_tooltip->GetTip() ;
2548 #endif
2549
2550     return wxEmptyString ;
2551 }
2552
2553 void wxWindowMac::ClearBackground()
2554 {
2555     Refresh() ;
2556     Update() ;
2557 }
2558
2559 void wxWindowMac::Update()
2560 {
2561     wxTopLevelWindowMac* top = MacGetTopLevelWindow();
2562     if (top)
2563         top->MacPerformUpdates() ;
2564 }
2565
2566 wxTopLevelWindowMac* wxWindowMac::MacGetTopLevelWindow() const
2567 {
2568     wxTopLevelWindowMac* win = NULL ;
2569     WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
2570     if ( window )
2571         win = wxFindWinFromMacWindow( window ) ;
2572
2573     return win ;
2574 }
2575
2576 const wxRect& wxWindowMac::MacGetClippedClientRect() const
2577 {
2578     MacUpdateClippedRects() ;
2579
2580     return m_cachedClippedClientRect ;
2581 }
2582
2583 const wxRect& wxWindowMac::MacGetClippedRect() const
2584 {
2585     MacUpdateClippedRects() ;
2586
2587     return m_cachedClippedRect ;
2588 }
2589
2590 const wxRect&wxWindowMac:: MacGetClippedRectWithOuterStructure() const
2591 {
2592     MacUpdateClippedRects() ;
2593
2594     return m_cachedClippedRectWithOuterStructure ;
2595 }
2596
2597 const wxRegion& wxWindowMac::MacGetVisibleRegion( bool includeOuterStructures )
2598 {
2599     static wxRegion emptyrgn ;
2600
2601     if ( !m_isBeingDeleted && IsShownOnScreen() )
2602     {
2603         MacUpdateClippedRects() ;
2604         if ( includeOuterStructures )
2605             return m_cachedClippedRegionWithOuterStructure ;
2606         else
2607             return m_cachedClippedRegion ;
2608     }
2609     else
2610     {
2611         return emptyrgn ;
2612     }
2613 }
2614
2615 void wxWindowMac::MacUpdateClippedRects() const
2616 {
2617     if ( m_cachedClippedRectValid )
2618         return ;
2619
2620     // includeOuterStructures is true if we try to draw somthing like a focus ring etc.
2621     // also a window dc uses this, in this case we only clip in the hierarchy for hard
2622     // borders like a scrollwindow, splitter etc otherwise we end up in a paranoia having
2623     // to add focus borders everywhere
2624
2625     Rect r, rIncludingOuterStructures ;
2626
2627     m_peer->GetRect( &r ) ;
2628     r.left -= MacGetLeftBorderSize() ;
2629     r.top -= MacGetTopBorderSize() ;
2630     r.bottom += MacGetBottomBorderSize() ;
2631     r.right += MacGetRightBorderSize() ;
2632
2633     r.right -= r.left ;
2634     r.bottom -= r.top ;
2635     r.left = 0 ;
2636     r.top = 0 ;
2637
2638     rIncludingOuterStructures = r ;
2639     InsetRect( &rIncludingOuterStructures , -4 , -4 ) ;
2640
2641     wxRect cl = GetClientRect() ;
2642     Rect rClient = { cl.y , cl.x , cl.y + cl.height , cl.x + cl.width } ;
2643
2644     int x , y ;
2645     wxSize size ;
2646     const wxWindow* child = this ;
2647     const wxWindow* parent = NULL ;
2648
2649     while ( !child->IsTopLevel() && ( parent = child->GetParent() ) != NULL )
2650     {
2651         if ( parent->MacIsChildOfClientArea(child) )
2652         {
2653             size = parent->GetClientSize() ;
2654             wxPoint origin = parent->GetClientAreaOrigin() ;
2655             x = origin.x ;
2656             y = origin.y ;
2657         }
2658         else
2659         {
2660             // this will be true for scrollbars, toolbars etc.
2661             size = parent->GetSize() ;
2662             y = parent->MacGetTopBorderSize() ;
2663             x = parent->MacGetLeftBorderSize() ;
2664             size.x -= parent->MacGetLeftBorderSize() + parent->MacGetRightBorderSize() ;
2665             size.y -= parent->MacGetTopBorderSize() + parent->MacGetBottomBorderSize() ;
2666         }
2667
2668         parent->MacWindowToRootWindow( &x, &y ) ;
2669         MacRootWindowToWindow( &x , &y ) ;
2670
2671         Rect rparent = { y , x , y + size.y , x + size.x } ;
2672
2673         // the wxwindow and client rects will always be clipped
2674         SectRect( &r , &rparent , &r ) ;
2675         SectRect( &rClient , &rparent , &rClient ) ;
2676
2677         // the structure only at 'hard' borders
2678         if ( parent->MacClipChildren() ||
2679             ( parent->GetParent() && parent->GetParent()->MacClipGrandChildren() ) )
2680         {
2681             SectRect( &rIncludingOuterStructures , &rparent , &rIncludingOuterStructures ) ;
2682         }
2683
2684         child = parent ;
2685     }
2686
2687     m_cachedClippedRect = wxRect( r.left , r.top , r.right - r.left , r.bottom - r.top ) ;
2688     m_cachedClippedClientRect = wxRect( rClient.left , rClient.top ,
2689         rClient.right - rClient.left , rClient.bottom - rClient.top ) ;
2690     m_cachedClippedRectWithOuterStructure = wxRect(
2691         rIncludingOuterStructures.left , rIncludingOuterStructures.top ,
2692         rIncludingOuterStructures.right - rIncludingOuterStructures.left ,
2693         rIncludingOuterStructures.bottom - rIncludingOuterStructures.top ) ;
2694
2695     m_cachedClippedRegionWithOuterStructure = wxRegion( m_cachedClippedRectWithOuterStructure ) ;
2696     m_cachedClippedRegion = wxRegion( m_cachedClippedRect ) ;
2697     m_cachedClippedClientRegion = wxRegion( m_cachedClippedClientRect ) ;
2698
2699     m_cachedClippedRectValid = true ;
2700 }
2701
2702 /*
2703     This function must not change the updatergn !
2704  */
2705 bool wxWindowMac::MacDoRedraw( void* updatergnr , long time )
2706 {
2707     bool handled = false ;
2708     Rect updatebounds ;
2709     RgnHandle updatergn = (RgnHandle) updatergnr ;
2710     GetRegionBounds( updatergn , &updatebounds ) ;
2711
2712     // wxLogDebug(wxT("update for %s bounds %d, %d, %d, %d"), wxString(GetClassInfo()->GetClassName()).c_str(), updatebounds.left, updatebounds.top , updatebounds.right , updatebounds.bottom ) ;
2713
2714     if ( !EmptyRgn(updatergn) )
2715     {
2716         RgnHandle newupdate = NewRgn() ;
2717         wxSize point = GetClientSize() ;
2718         wxPoint origin = GetClientAreaOrigin() ;
2719         SetRectRgn( newupdate , origin.x , origin.y , origin.x + point.x , origin.y + point.y ) ;
2720         SectRgn( newupdate , updatergn , newupdate ) ;
2721
2722         // first send an erase event to the entire update area
2723         {
2724             // for the toplevel window this really is the entire area
2725             // for all the others only their client area, otherwise they
2726             // might be drawing with full alpha and eg put blue into
2727             // the grow-box area of a scrolled window (scroll sample)
2728             wxDC* dc = new wxWindowDC(this);
2729             if ( IsTopLevel() )
2730                 dc->SetClippingRegion(wxRegion(HIShapeCreateWithQDRgn(updatergn)));
2731             else
2732                 dc->SetClippingRegion(wxRegion(HIShapeCreateWithQDRgn(newupdate)));
2733
2734             wxEraseEvent eevent( GetId(), dc );
2735             eevent.SetEventObject( this );
2736             HandleWindowEvent( eevent );
2737             delete dc ;
2738         }
2739
2740         MacPaintGrowBox();
2741
2742         // calculate a client-origin version of the update rgn and set m_updateRegion to that
2743         OffsetRgn( newupdate , -origin.x , -origin.y ) ;
2744         m_updateRegion = wxRegion(HIShapeCreateWithQDRgn(newupdate)) ;
2745         DisposeRgn( newupdate ) ;
2746
2747         if ( !m_updateRegion.Empty() )
2748         {
2749             // paint the window itself
2750
2751             wxPaintEvent event;
2752             event.SetTimestamp(time);
2753             event.SetEventObject(this);
2754             HandleWindowEvent(event);
2755             handled = true ;
2756         }
2757
2758         // now we cannot rely on having its borders drawn by a window itself, as it does not
2759         // get the updateRgn wide enough to always do so, so we do it from the parent
2760         // this would also be the place to draw any custom backgrounds for native controls
2761         // in Composited windowing
2762         wxPoint clientOrigin = GetClientAreaOrigin() ;
2763
2764         wxWindowMac *child;
2765         int x, y, w, h;
2766         for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
2767         {
2768             child = node->GetData();
2769             if (child == NULL)
2770                 continue;
2771             if (child == m_vScrollBar)
2772                 continue;
2773             if (child == m_hScrollBar)
2774                 continue;
2775             if (child->IsTopLevel())
2776                 continue;
2777             if (!child->IsShown())
2778                 continue;
2779
2780             // only draw those in the update region (add a safety margin of 10 pixels for shadow effects
2781
2782             child->GetPosition( &x, &y );
2783             child->GetSize( &w, &h );
2784             Rect childRect = { y , x , y + h , x + w } ;
2785             OffsetRect( &childRect , clientOrigin.x , clientOrigin.y ) ;
2786             InsetRect( &childRect , -10 , -10) ;
2787
2788             if ( RectInRgn( &childRect , updatergn ) )
2789             {
2790                 // paint custom borders
2791                 wxNcPaintEvent eventNc( child->GetId() );
2792                 eventNc.SetEventObject( child );
2793                 if ( !child->HandleWindowEvent( eventNc ) )
2794                 {
2795                     child->MacPaintBorders(0, 0) ;
2796                 }
2797             }
2798         }
2799     }
2800
2801     return handled ;
2802 }
2803
2804
2805 WXWindow wxWindowMac::MacGetTopLevelWindowRef() const
2806 {
2807     wxWindowMac *iter = (wxWindowMac*)this ;
2808
2809     while ( iter )
2810     {
2811         if ( iter->IsTopLevel() )
2812         {
2813             wxTopLevelWindow* toplevel = wxDynamicCast(iter,wxTopLevelWindow);
2814             if ( toplevel )
2815                 return toplevel->MacGetWindowRef();
2816 #if wxUSE_POPUPWIN
2817             wxPopupWindow* popupwin = wxDynamicCast(iter,wxPopupWindow);
2818             if ( popupwin )
2819                 return popupwin->MacGetPopupWindowRef();
2820 #endif
2821         }
2822         iter = iter->GetParent() ;
2823     }
2824
2825     return NULL ;
2826 }
2827
2828 bool wxWindowMac::MacHasScrollBarCorner() const
2829 {
2830     /* Returns whether the scroll bars in a wxScrolledWindow should be
2831      * shortened. Scroll bars should be shortened if either:
2832      *
2833      * - both scroll bars are visible, or
2834      *
2835      * - there is a resize box in the parent frame's corner and this
2836      *   window shares the bottom and right edge with the parent
2837      *   frame.
2838      */
2839
2840     if ( m_hScrollBar == NULL && m_vScrollBar == NULL )
2841         return false;
2842
2843     if ( ( m_hScrollBar && m_hScrollBar->IsShown() )
2844          && ( m_vScrollBar && m_vScrollBar->IsShown() ) )
2845     {
2846         // Both scroll bars visible
2847         return true;
2848     }
2849     else
2850     {
2851         wxPoint thisWindowBottomRight = GetScreenRect().GetBottomRight();
2852
2853         for ( const wxWindow *win = this; win; win = win->GetParent() )
2854         {
2855             const wxFrame *frame = wxDynamicCast( win, wxFrame ) ;
2856             if ( frame )
2857             {
2858                 if ( frame->GetWindowStyleFlag() & wxRESIZE_BORDER )
2859                 {
2860                     // Parent frame has resize handle
2861                     wxPoint frameBottomRight = frame->GetScreenRect().GetBottomRight();
2862
2863                     // Note: allow for some wiggle room here as wxMac's
2864                     // window rect calculations seem to be imprecise
2865                     if ( abs( thisWindowBottomRight.x - frameBottomRight.x ) <= 2
2866                         && abs( thisWindowBottomRight.y - frameBottomRight.y ) <= 2 )
2867                     {
2868                         // Parent frame has resize handle and shares
2869                         // right bottom corner
2870                         return true ;
2871                     }
2872                     else
2873                     {
2874                         // Parent frame has resize handle but doesn't
2875                         // share right bottom corner
2876                         return false ;
2877                     }
2878                 }
2879                 else
2880                 {
2881                     // Parent frame doesn't have resize handle
2882                     return false ;
2883                 }
2884             }
2885         }
2886
2887         // No parent frame found
2888         return false ;
2889     }
2890 }
2891
2892 void wxWindowMac::MacCreateScrollBars( long style )
2893 {
2894     wxASSERT_MSG( m_vScrollBar == NULL && m_hScrollBar == NULL , wxT("attempt to create window twice") ) ;
2895
2896     if ( style & ( wxVSCROLL | wxHSCROLL ) )
2897     {
2898         int scrlsize = MAC_SCROLLBAR_SIZE ;
2899         if ( GetWindowVariant() == wxWINDOW_VARIANT_SMALL || GetWindowVariant() == wxWINDOW_VARIANT_MINI )
2900         {
2901             scrlsize = MAC_SMALL_SCROLLBAR_SIZE ;
2902         }
2903
2904         int adjust = MacHasScrollBarCorner() ? scrlsize - 1: 0 ;
2905         int width, height ;
2906         GetClientSize( &width , &height ) ;
2907
2908         wxPoint vPoint(width - scrlsize, 0) ;
2909         wxSize vSize(scrlsize, height - adjust) ;
2910         wxPoint hPoint(0, height - scrlsize) ;
2911         wxSize hSize(width - adjust, scrlsize) ;
2912
2913         // we have to set the min size to a smaller value, otherwise they cannot get smaller (InitialSize sets MinSize)
2914         if ( style & wxVSCROLL )
2915         {
2916             m_vScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, vPoint, vSize , wxVERTICAL);
2917             m_vScrollBar->SetMinSize( wxDefaultSize );
2918         }
2919
2920         if ( style  & wxHSCROLL )
2921         {
2922             m_hScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, hPoint, hSize , wxHORIZONTAL);
2923             m_hScrollBar->SetMinSize( wxDefaultSize );
2924         }
2925     }
2926
2927     // because the create does not take into account the client area origin
2928     // we might have a real position shift
2929     MacRepositionScrollBars() ;
2930 }
2931
2932 bool wxWindowMac::MacIsChildOfClientArea( const wxWindow* child ) const
2933 {
2934     bool result = ((child == NULL) || ((child != m_hScrollBar) && (child != m_vScrollBar)));
2935
2936     return result ;
2937 }
2938
2939 void wxWindowMac::MacRepositionScrollBars()
2940 {
2941     if ( !m_hScrollBar && !m_vScrollBar )
2942         return ;
2943
2944     int scrlsize = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2945     int adjust = MacHasScrollBarCorner() ? scrlsize - 1 : 0 ;
2946
2947     // get real client area
2948     int width, height ;
2949     GetSize( &width , &height );
2950
2951     width -= MacGetLeftBorderSize() + MacGetRightBorderSize();
2952     height -= MacGetTopBorderSize() + MacGetBottomBorderSize();
2953
2954     wxPoint vPoint( width - scrlsize, 0 ) ;
2955     wxSize vSize( scrlsize, height - adjust ) ;
2956     wxPoint hPoint( 0 , height - scrlsize ) ;
2957     wxSize hSize( width - adjust, scrlsize ) ;
2958
2959 #if 0
2960     int x = 0, y = 0, w, h ;
2961     GetSize( &w , &h ) ;
2962
2963     MacClientToRootWindow( &x , &y ) ;
2964     MacClientToRootWindow( &w , &h ) ;
2965
2966     wxWindowMac *iter = (wxWindowMac*)this ;
2967
2968     int totW = 10000 , totH = 10000;
2969     while ( iter )
2970     {
2971         if ( iter->IsTopLevel() )
2972         {
2973             iter->GetSize( &totW , &totH ) ;
2974             break ;
2975         }
2976
2977         iter = iter->GetParent() ;
2978     }
2979
2980     if ( x == 0 )
2981     {
2982         hPoint.x = -1 ;
2983         hSize.x += 1 ;
2984     }
2985     if ( y == 0 )
2986     {
2987         vPoint.y = -1 ;
2988         vSize.y += 1 ;
2989     }
2990
2991     if ( w - x >= totW )
2992     {
2993         hSize.x += 1 ;
2994         vPoint.x += 1 ;
2995     }
2996     if ( h - y >= totH )
2997     {
2998         vSize.y += 1 ;
2999         hPoint.y += 1 ;
3000     }
3001 #endif
3002
3003     if ( m_vScrollBar )
3004         m_vScrollBar->SetSize( vPoint.x , vPoint.y, vSize.x, vSize.y , wxSIZE_ALLOW_MINUS_ONE );
3005     if ( m_hScrollBar )
3006         m_hScrollBar->SetSize( hPoint.x , hPoint.y, hSize.x, hSize.y, wxSIZE_ALLOW_MINUS_ONE );
3007 }
3008
3009 bool wxWindowMac::AcceptsFocus() const
3010 {
3011     return MacCanFocus() && wxWindowBase::AcceptsFocus();
3012 }
3013
3014 void wxWindowMac::MacSuperChangedPosition()
3015 {
3016     // only window-absolute structures have to be moved i.e. controls
3017
3018     m_cachedClippedRectValid = false ;
3019
3020     wxWindowMac *child;
3021     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3022     while ( node )
3023     {
3024         child = node->GetData();
3025         child->MacSuperChangedPosition() ;
3026
3027         node = node->GetNext();
3028     }
3029 }
3030
3031 void wxWindowMac::MacTopLevelWindowChangedPosition()
3032 {
3033     // only screen-absolute structures have to be moved i.e. glcanvas
3034
3035     wxWindowMac *child;
3036     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3037     while ( node )
3038     {
3039         child = node->GetData();
3040         child->MacTopLevelWindowChangedPosition() ;
3041
3042         node = node->GetNext();
3043     }
3044 }
3045
3046 long wxWindowMac::MacGetLeftBorderSize() const
3047 {
3048     if ( IsTopLevel() )
3049         return 0 ;
3050
3051     SInt32 border = 0 ;
3052
3053     if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER))
3054     {
3055         // this metric is only the 'outset' outside the simple frame rect
3056         GetThemeMetric( kThemeMetricEditTextFrameOutset , &border ) ;
3057         border += 1 ;
3058     }
3059     else if (HasFlag(wxSIMPLE_BORDER))
3060     {
3061         // this metric is only the 'outset' outside the simple frame rect
3062         GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
3063         border += 1 ;
3064     }
3065
3066     return border ;
3067 }
3068
3069 long wxWindowMac::MacGetRightBorderSize() const
3070 {
3071     // they are all symmetric in mac themes
3072     return MacGetLeftBorderSize() ;
3073 }
3074
3075 long wxWindowMac::MacGetTopBorderSize() const
3076 {
3077     // they are all symmetric in mac themes
3078     return MacGetLeftBorderSize() ;
3079 }
3080
3081 long wxWindowMac::MacGetBottomBorderSize() const
3082 {
3083     // they are all symmetric in mac themes
3084     return MacGetLeftBorderSize() ;
3085 }
3086
3087 long wxWindowMac::MacRemoveBordersFromStyle( long style )
3088 {
3089     return style & ~wxBORDER_MASK ;
3090 }
3091
3092 // Find the wxWindowMac at the current mouse position, returning the mouse
3093 // position.
3094 wxWindowMac * wxFindWindowAtPointer( wxPoint& pt )
3095 {
3096     pt = wxGetMousePosition();
3097     wxWindowMac* found = wxFindWindowAtPoint(pt);
3098
3099     return found;
3100 }
3101
3102 // Get the current mouse position.
3103 wxPoint wxGetMousePosition()
3104 {
3105     int x, y;
3106
3107     wxGetMousePosition( &x, &y );
3108
3109     return wxPoint(x, y);
3110 }
3111
3112 void wxWindowMac::OnMouseEvent( wxMouseEvent &event )
3113 {
3114     if ( event.GetEventType() == wxEVT_RIGHT_DOWN )
3115     {
3116         // copied from wxGTK : CS
3117         // VZ: shouldn't we move this to base class then?
3118
3119         // generate a "context menu" event: this is similar to wxEVT_RIGHT_DOWN
3120         // except that:
3121         //
3122         // (a) it's a command event and so is propagated to the parent
3123         // (b) under MSW it can be generated from kbd too
3124         // (c) it uses screen coords (because of (a))
3125         wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
3126                                   this->GetId(),
3127                                   this->ClientToScreen(event.GetPosition()));
3128         evtCtx.SetEventObject(this);
3129         if ( ! HandleWindowEvent(evtCtx) )
3130             event.Skip() ;
3131     }
3132     else
3133     {
3134         event.Skip() ;
3135     }
3136 }
3137
3138 void wxWindowMac::OnPaint( wxPaintEvent & WXUNUSED(event) )
3139 {
3140     if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL
3141          && GetBackgroundStyle() != wxBG_STYLE_TRANSPARENT )
3142         CallNextEventHandler(
3143             (EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() ,
3144             (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
3145 }
3146
3147 void wxWindowMac::MacHandleControlClick(WXWidget WXUNUSED(control),
3148                                         wxInt16 WXUNUSED(controlpart),
3149                                         bool WXUNUSED(mouseStillDown))
3150 {
3151 }
3152
3153 Rect wxMacGetBoundsForControl( wxWindow* window , const wxPoint& pos , const wxSize &size , bool adjustForOrigin )
3154 {
3155     int x, y, w, h ;
3156
3157     window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin ) ;
3158     Rect bounds = { y, x, y + h, x + w };
3159
3160     return bounds ;
3161 }
3162
3163 wxInt32 wxWindowMac::MacControlHit(WXEVENTHANDLERREF WXUNUSED(handler) , WXEVENTREF WXUNUSED(event) )
3164 {
3165     return eventNotHandledErr ;
3166 }
3167
3168 bool wxWindowMac::Reparent(wxWindowBase *newParentBase)
3169 {
3170     wxWindowMac *newParent = (wxWindowMac *)newParentBase;
3171     if ( !wxWindowBase::Reparent(newParent) )
3172         return false;
3173
3174     // copied from MacPostControlCreate
3175     ControlRef container = (ControlRef) GetParent()->GetHandle() ;
3176
3177     wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
3178
3179     ::EmbedControl( m_peer->GetControlRef() , container ) ;
3180
3181     return true;
3182 }
3183
3184 bool wxWindowMac::SetTransparent(wxByte alpha)
3185 {
3186     SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
3187
3188     if ( alpha != m_macAlpha )
3189     {
3190         m_macAlpha = alpha ;
3191         Refresh() ;
3192     }
3193     return true ;
3194 }
3195
3196
3197 bool wxWindowMac::CanSetTransparent()
3198 {
3199     return true ;
3200 }
3201
3202 wxByte wxWindowMac::GetTransparent() const
3203 {
3204     return m_macAlpha ;
3205 }
3206
3207 bool wxWindowMac::IsShownOnScreen() const
3208 {
3209 #if TARGET_API_MAC_OSX
3210     if ( m_peer && m_peer->Ok() )
3211     {
3212         bool peerVis = m_peer->IsVisible();
3213         bool wxVis = wxWindowBase::IsShownOnScreen();
3214         if( peerVis != wxVis )
3215         {
3216             // CS : put a breakpoint here to investigate differences
3217             // between native an wx visibilities
3218             // the only place where I've encountered them until now
3219             // are the hiding/showing sequences where the vis-changed event is
3220             // first sent to the innermost control, while wx does things
3221             // from the outmost control
3222             wxVis = wxWindowBase::IsShownOnScreen();
3223             return wxVis;
3224         }
3225
3226         return m_peer->IsVisible();
3227     }
3228 #endif
3229
3230     return wxWindowBase::IsShownOnScreen();
3231 }