src/mac/carbon/window.cpp

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