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