src/osx/carbon/nonownedwnd.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/carbon/nonownedwnd.cpp
   3 // Purpose:     implementation of wxNonOwnedWindow
   4 // Author:      Stefan Csomor
   5 // Created:     2008-03-24
   6 // RCS-ID:      $Id: nonownedwnd.cpp 50329 2007-11-29 17:00:58Z VS $
   7 // Copyright:   (c) Stefan Csomor 2008
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifndef WX_PRECOMP
  15     #include "wx/app.h"
  16 #endif // WX_PRECOMP
  17
  18 #include "wx/hashmap.h"
  19 #include "wx/evtloop.h"
  20 #include "wx/tooltip.h"
  21 #include "wx/nonownedwnd.h"
  22
  23 #include "wx/osx/private.h"
  24 #include "wx/settings.h"
  25 #include "wx/frame.h"
  26
  27 #if wxUSE_SYSTEM_OPTIONS
  28     #include "wx/sysopt.h"
  29 #endif
  30
  31 // ============================================================================
  32 // wxNonOwnedWindow implementation
  33 // ============================================================================
  34
  35 // unified title and toolbar constant - not in Tiger headers, so we duplicate it here
  36 #define kWindowUnifiedTitleAndToolbarAttribute (1 << 7)
  37
  38 IMPLEMENT_DYNAMIC_CLASS( wxNonOwnedWindowCarbonImpl , wxNonOwnedWindowImpl )
  39
  40 WXWindow wxNonOwnedWindowCarbonImpl::GetWXWindow() const
  41 {
  42     return (WXWindow) m_macWindow;
  43 }
  44 void wxNonOwnedWindowCarbonImpl::Raise()
  45 {
  46     ::SelectWindow( m_macWindow ) ;
  47 }
  48
  49 void wxNonOwnedWindowCarbonImpl::Lower()
  50 {
  51     ::SendBehind( m_macWindow , NULL ) ;
  52 }
  53
  54 bool wxNonOwnedWindowCarbonImpl::Show(bool show)
  55 {
  56     bool plainTransition = true;
  57
  58 #if wxUSE_SYSTEM_OPTIONS
  59     if ( wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION) )
  60         plainTransition = ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION ) == 1 ) ;
  61 #endif
  62
  63     if (show)
  64     {
  65 #if wxOSX_USE_CARBON
  66         if ( plainTransition )
  67            ::ShowWindow( (WindowRef)m_macWindow );
  68         else
  69            ::TransitionWindow( (WindowRef)m_macWindow, kWindowZoomTransitionEffect, kWindowShowTransitionAction, NULL );
  70
  71         ::SelectWindow( (WindowRef)m_macWindow ) ;
  72 #endif
  73     }
  74     else
  75     {
  76 #if wxOSX_USE_CARBON
  77         if ( plainTransition )
  78            ::HideWindow( (WindowRef)m_macWindow );
  79         else
  80            ::TransitionWindow( (WindowRef)m_macWindow, kWindowZoomTransitionEffect, kWindowHideTransitionAction, NULL );
  81 #endif
  82     }
  83     return true;
  84 }
  85
  86 void wxNonOwnedWindowCarbonImpl::Update()
  87 {
  88     HIWindowFlush(m_macWindow) ;
  89 }
  90
  91 bool wxNonOwnedWindowCarbonImpl::SetTransparent(wxByte alpha)
  92 {
  93     OSStatus result = SetWindowAlpha((WindowRef)m_macWindow, (CGFloat)((alpha)/255.0));
  94     return result == noErr;
  95 }
  96
  97 bool wxNonOwnedWindowCarbonImpl::SetBackgroundColour(const wxColour& col )
  98 {
  99     if ( col == wxColour(wxMacCreateCGColorFromHITheme(kThemeBrushDocumentWindowBackground)) )
 100     {
 101         SetThemeWindowBackground( (WindowRef) m_macWindow,  kThemeBrushDocumentWindowBackground, false ) ;
 102         SetBackgroundStyle(wxBG_STYLE_SYSTEM);
 103     }
 104     else if ( col == wxColour(wxMacCreateCGColorFromHITheme(kThemeBrushDialogBackgroundActive)) )
 105     {
 106         SetThemeWindowBackground( (WindowRef) m_macWindow,  kThemeBrushDialogBackgroundActive, false ) ;
 107         SetBackgroundStyle(wxBG_STYLE_SYSTEM);
 108     }
 109     return true;
 110 }
 111
 112 void wxNonOwnedWindowCarbonImpl::SetExtraStyle( long exStyle )
 113 {
 114     if ( m_macWindow != NULL )
 115     {
 116         bool metal = exStyle & wxFRAME_EX_METAL ;
 117
 118         if ( MacGetMetalAppearance() != metal )
 119         {
 120             if ( MacGetUnifiedAppearance() )
 121                 MacSetUnifiedAppearance( !metal ) ;
 122
 123             MacSetMetalAppearance( metal ) ;
 124         }
 125     }
 126 }
 127
 128 bool wxNonOwnedWindowCarbonImpl::SetBackgroundStyle(wxBackgroundStyle style)
 129 {
 130     if ( style == wxBG_STYLE_TRANSPARENT )
 131     {
 132         OSStatus err = HIWindowChangeFeatures( m_macWindow, 0, kWindowIsOpaque );
 133         verify_noerr( err );
 134         err = ReshapeCustomWindow( m_macWindow );
 135         verify_noerr( err );
 136     }
 137
 138     return true ;
 139 }
 140
 141 bool wxNonOwnedWindowCarbonImpl::CanSetTransparent()
 142 {
 143     return true;
 144 }
 145
 146 void wxNonOwnedWindowCarbonImpl::GetContentArea( int &left , int &top , int &width , int &height ) const
 147 {
 148     Rect content, structure ;
 149
 150     GetWindowBounds( m_macWindow, kWindowStructureRgn , &structure ) ;
 151     GetWindowBounds( m_macWindow, kWindowContentRgn , &content ) ;
 152
 153     left = content.left - structure.left ;
 154     top = content.top  - structure.top ;
 155     width = content.right - content.left ;
 156     height = content.bottom - content.top ;
 157 }
 158
 159 void wxNonOwnedWindowCarbonImpl::MoveWindow(int x, int y, int width, int height)
 160 {
 161     Rect bounds = { y , x , y + height , x + width } ;
 162     verify_noerr(SetWindowBounds( (WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
 163 }
 164
 165 void wxNonOwnedWindowCarbonImpl::GetPosition( int &x, int &y ) const
 166 {
 167     Rect bounds ;
 168
 169     verify_noerr(GetWindowBounds((WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
 170
 171     x = bounds.left ;
 172     y = bounds.top ;
 173 }
 174
 175 void wxNonOwnedWindowCarbonImpl::GetSize( int &width, int &height ) const
 176 {
 177     Rect bounds ;
 178
 179     verify_noerr(GetWindowBounds((WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
 180
 181     width = bounds.right - bounds.left ;
 182     height = bounds.bottom - bounds.top ;
 183 }
 184
 185 bool wxNonOwnedWindowCarbonImpl::MacGetUnifiedAppearance() const
 186 {
 187     return MacGetWindowAttributes() & kWindowUnifiedTitleAndToolbarAttribute ;
 188 }
 189
 190 void wxNonOwnedWindowCarbonImpl::MacChangeWindowAttributes( wxUint32 attributesToSet , wxUint32 attributesToClear )
 191 {
 192     ChangeWindowAttributes( m_macWindow, attributesToSet, attributesToClear ) ;
 193 }
 194
 195 wxUint32 wxNonOwnedWindowCarbonImpl::MacGetWindowAttributes() const
 196 {
 197     UInt32 attr = 0 ;
 198     GetWindowAttributes( m_macWindow, &attr ) ;
 199     return attr ;
 200 }
 201
 202 void wxNonOwnedWindowCarbonImpl::MacSetMetalAppearance( bool set )
 203 {
 204     if ( MacGetUnifiedAppearance() )
 205         MacSetUnifiedAppearance( false ) ;
 206
 207     MacChangeWindowAttributes( set ? kWindowMetalAttribute : kWindowNoAttributes ,
 208         set ? kWindowNoAttributes : kWindowMetalAttribute ) ;
 209 }
 210
 211 bool wxNonOwnedWindowCarbonImpl::MacGetMetalAppearance() const
 212 {
 213     return MacGetWindowAttributes() & kWindowMetalAttribute ;
 214 }
 215
 216 void wxNonOwnedWindowCarbonImpl::MacSetUnifiedAppearance( bool set )
 217 {
 218     if ( MacGetMetalAppearance() )
 219         MacSetMetalAppearance( false ) ;
 220
 221     MacChangeWindowAttributes( set ? kWindowUnifiedTitleAndToolbarAttribute : kWindowNoAttributes ,
 222         set ? kWindowNoAttributes : kWindowUnifiedTitleAndToolbarAttribute) ;
 223
 224     // For some reason, Tiger uses white as the background color for this appearance,
 225     // while most apps using it use the typical striped background. Restore that behavior
 226     // for wx.
 227     // TODO: Determine if we need this on Leopard as well. (should be harmless either way,
 228     // though)
 229     // since when creating the peering is not yet completely set-up we call both setters
 230     // explicitely
 231     m_wxPeer->SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) ) ;
 232     SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) ) ;
 233 }
 234
 235
 236 // ----------------------------------------------------------------------------
 237 // globals
 238 // ----------------------------------------------------------------------------
 239
 240 static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param);
 241
 242
 243 // ---------------------------------------------------------------------------
 244 // Carbon Events
 245 // ---------------------------------------------------------------------------
 246
 247 static const EventTypeSpec eventList[] =
 248 {
 249     // TODO: remove control related event like key and mouse (except for WindowLeave events)
 250
 251     { kEventClassKeyboard, kEventRawKeyDown } ,
 252     { kEventClassKeyboard, kEventRawKeyRepeat } ,
 253     { kEventClassKeyboard, kEventRawKeyUp } ,
 254     { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
 255
 256     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
 257     { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
 258
 259     { kEventClassWindow , kEventWindowShown } ,
 260     { kEventClassWindow , kEventWindowActivated } ,
 261     { kEventClassWindow , kEventWindowDeactivated } ,
 262     { kEventClassWindow , kEventWindowBoundsChanging } ,
 263     { kEventClassWindow , kEventWindowBoundsChanged } ,
 264     { kEventClassWindow , kEventWindowClose } ,
 265     { kEventClassWindow , kEventWindowGetRegion } ,
 266
 267     // we have to catch these events on the toplevel window level,
 268     // as controls don't get the raw mouse events anymore
 269
 270     { kEventClassMouse , kEventMouseDown } ,
 271     { kEventClassMouse , kEventMouseUp } ,
 272     { kEventClassMouse , kEventMouseWheelMoved } ,
 273     { kEventClassMouse , kEventMouseMoved } ,
 274     { kEventClassMouse , kEventMouseDragged } ,
 275 } ;
 276
 277 static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 278 {
 279     OSStatus result = eventNotHandledErr ;
 280     // call DoFindFocus instead of FindFocus, because for Composite Windows(like WxGenericListCtrl)
 281     // FindFocus does not return the actual focus window, but the enclosing window
 282     wxWindow* focus = wxWindow::DoFindFocus();
 283     if ( focus == NULL )
 284         focus = data ? ((wxNonOwnedWindowImpl*) data)->GetWXPeer() : NULL ;
 285
 286     unsigned char charCode ;
 287     wxChar uniChar[2] ;
 288     uniChar[0] = 0;
 289     uniChar[1] = 0;
 290
 291     UInt32 keyCode ;
 292     UInt32 modifiers ;
 293     Point point ;
 294     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 295
 296 #if wxUSE_UNICODE
 297     ByteCount dataSize = 0 ;
 298     if ( GetEventParameter( event, kEventParamKeyUnicodes, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
 299     {
 300         UniChar buf[2] ;
 301         int numChars = dataSize / sizeof( UniChar) + 1;
 302
 303         UniChar* charBuf = buf ;
 304
 305         if ( numChars * 2 > 4 )
 306             charBuf = new UniChar[ numChars ] ;
 307         GetEventParameter( event, kEventParamKeyUnicodes, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
 308         charBuf[ numChars - 1 ] = 0;
 309
 310 #if SIZEOF_WCHAR_T == 2
 311         uniChar = charBuf[0] ;
 312 #else
 313         wxMBConvUTF16 converter ;
 314         converter.MB2WC( uniChar , (const char*)charBuf , 2 ) ;
 315 #endif
 316
 317         if ( numChars * 2 > 4 )
 318             delete[] charBuf ;
 319     }
 320 #endif
 321
 322     GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
 323     GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
 324     GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
 325     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
 326
 327     UInt32 message = (keyCode << 8) + charCode;
 328     switch ( GetEventKind( event ) )
 329     {
 330         case kEventRawKeyRepeat :
 331         case kEventRawKeyDown :
 332             {
 333                 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 334                 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 335                 wxTheApp->MacSetCurrentEvent( event , handler ) ;
 336                 if ( /* focus && */ wxTheApp->MacSendKeyDownEvent(
 337                     focus , message , modifiers , when , point.h , point.v , uniChar[0] ) )
 338                 {
 339                     result = noErr ;
 340                 }
 341                 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 342             }
 343             break ;
 344
 345         case kEventRawKeyUp :
 346             if ( /* focus && */ wxTheApp->MacSendKeyUpEvent(
 347                 focus , message , modifiers , when , point.h , point.v , uniChar[0] ) )
 348             {
 349                 result = noErr ;
 350             }
 351             break ;
 352
 353         case kEventRawKeyModifiersChanged :
 354             {
 355                 wxKeyEvent event(wxEVT_KEY_DOWN);
 356
 357                 event.m_shiftDown = modifiers & shiftKey;
 358                 event.m_controlDown = modifiers & controlKey;
 359                 event.m_altDown = modifiers & optionKey;
 360                 event.m_metaDown = modifiers & cmdKey;
 361                 event.m_x = point.h;
 362                 event.m_y = point.v;
 363
 364 #if wxUSE_UNICODE
 365                 event.m_uniChar = uniChar[0] ;
 366 #endif
 367
 368                 event.SetTimestamp(when);
 369                 event.SetEventObject(focus);
 370
 371                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & controlKey )
 372                 {
 373                     event.m_keyCode = WXK_CONTROL ;
 374                     event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 375                     focus->HandleWindowEvent( event ) ;
 376                 }
 377                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & shiftKey )
 378                 {
 379                     event.m_keyCode = WXK_SHIFT ;
 380                     event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 381                     focus->HandleWindowEvent( event ) ;
 382                 }
 383                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & optionKey )
 384                 {
 385                     event.m_keyCode = WXK_ALT ;
 386                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 387                     focus->HandleWindowEvent( event ) ;
 388                 }
 389                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & cmdKey )
 390                 {
 391                     event.m_keyCode = WXK_COMMAND ;
 392                     event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 393                     focus->HandleWindowEvent( event ) ;
 394                 }
 395
 396                 wxApp::s_lastModifiers = modifiers ;
 397             }
 398             break ;
 399
 400         default:
 401             break;
 402     }
 403
 404     return result ;
 405 }
 406
 407 // we don't interfere with foreign controls on our toplevel windows, therefore we always give back eventNotHandledErr
 408 // for windows that we didn't create (like eg Scrollbars in a databrowser), or for controls where we did not handle the
 409 // mouse down at all
 410 //
 411 // This handler can also be called from app level where data (ie target window) may be null or a non wx window
 412
 413 EventMouseButton g_lastButton = 0 ;
 414 bool g_lastButtonWasFakeRight = false ;
 415
 416 void SetupMouseEvent( wxMouseEvent &wxevent , wxMacCarbonEvent &cEvent )
 417 {
 418     UInt32 modifiers = cEvent.GetParameter<UInt32>(kEventParamKeyModifiers, typeUInt32) ;
 419     Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
 420
 421     // these parameters are not given for all events
 422     EventMouseButton button = 0 ;
 423     UInt32 clickCount = 0 ;
 424     UInt32 mouseChord = 0;
 425
 426     cEvent.GetParameter<EventMouseButton>( kEventParamMouseButton, typeMouseButton , &button ) ;
 427     cEvent.GetParameter<UInt32>( kEventParamClickCount, typeUInt32 , &clickCount ) ;
 428     // the chord is the state of the buttons pressed currently
 429     cEvent.GetParameter<UInt32>( kEventParamMouseChord, typeUInt32 , &mouseChord ) ;
 430
 431     wxevent.m_x = screenMouseLocation.h;
 432     wxevent.m_y = screenMouseLocation.v;
 433     wxevent.m_shiftDown = modifiers & shiftKey;
 434     wxevent.m_controlDown = modifiers & controlKey;
 435     wxevent.m_altDown = modifiers & optionKey;
 436     wxevent.m_metaDown = modifiers & cmdKey;
 437     wxevent.m_clickCount = clickCount;
 438     wxevent.SetTimestamp( cEvent.GetTicks() ) ;
 439
 440     // a control click is interpreted as a right click
 441     bool thisButtonIsFakeRight = false ;
 442     if ( button == kEventMouseButtonPrimary && (modifiers & controlKey) )
 443     {
 444         button = kEventMouseButtonSecondary ;
 445         thisButtonIsFakeRight = true ;
 446     }
 447
 448     // otherwise we report double clicks by connecting a left click with a ctrl-left click
 449     if ( clickCount > 1 && button != g_lastButton )
 450         clickCount = 1 ;
 451
 452     // we must make sure that our synthetic 'right' button corresponds in
 453     // mouse down, moved and mouse up, and does not deliver a right down and left up
 454
 455     if ( cEvent.GetKind() == kEventMouseDown )
 456     {
 457         g_lastButton = button ;
 458         g_lastButtonWasFakeRight = thisButtonIsFakeRight ;
 459     }
 460
 461     if ( button == 0 )
 462     {
 463         g_lastButton = 0 ;
 464         g_lastButtonWasFakeRight = false ;
 465     }
 466     else if ( g_lastButton == kEventMouseButtonSecondary && g_lastButtonWasFakeRight )
 467         button = g_lastButton ;
 468
 469     // Adjust the chord mask to remove the primary button and add the
 470     // secondary button.  It is possible that the secondary button is
 471     // already pressed, e.g. on a mouse connected to a laptop, but this
 472     // possibility is ignored here:
 473     if( thisButtonIsFakeRight && ( mouseChord & 1U ) )
 474         mouseChord = ((mouseChord & ~1U) | 2U);
 475
 476     if(mouseChord & 1U)
 477                 wxevent.m_leftDown = true ;
 478     if(mouseChord & 2U)
 479                 wxevent.m_rightDown = true ;
 480     if(mouseChord & 4U)
 481                 wxevent.m_middleDown = true ;
 482
 483     // translate into wx types
 484     switch ( cEvent.GetKind() )
 485     {
 486         case kEventMouseDown :
 487             switch ( button )
 488             {
 489                 case kEventMouseButtonPrimary :
 490                     wxevent.SetEventType( clickCount > 1 ? wxEVT_LEFT_DCLICK : wxEVT_LEFT_DOWN )  ;
 491                     break ;
 492
 493                 case kEventMouseButtonSecondary :
 494                     wxevent.SetEventType( clickCount > 1 ? wxEVT_RIGHT_DCLICK : wxEVT_RIGHT_DOWN ) ;
 495                     break ;
 496
 497                 case kEventMouseButtonTertiary :
 498                     wxevent.SetEventType( clickCount > 1 ? wxEVT_MIDDLE_DCLICK : wxEVT_MIDDLE_DOWN ) ;
 499                     break ;
 500
 501                 default:
 502                     break ;
 503             }
 504             break ;
 505
 506         case kEventMouseUp :
 507             switch ( button )
 508             {
 509                 case kEventMouseButtonPrimary :
 510                     wxevent.SetEventType( wxEVT_LEFT_UP )  ;
 511                     break ;
 512
 513                 case kEventMouseButtonSecondary :
 514                     wxevent.SetEventType( wxEVT_RIGHT_UP ) ;
 515                     break ;
 516
 517                 case kEventMouseButtonTertiary :
 518                     wxevent.SetEventType( wxEVT_MIDDLE_UP ) ;
 519                     break ;
 520
 521                 default:
 522                     break ;
 523             }
 524             break ;
 525
 526      case kEventMouseWheelMoved :
 527         {
 528             wxevent.SetEventType( wxEVT_MOUSEWHEEL ) ;
 529
 530             EventMouseWheelAxis axis = cEvent.GetParameter<EventMouseWheelAxis>(kEventParamMouseWheelAxis, typeMouseWheelAxis) ;
 531             SInt32 delta = cEvent.GetParameter<SInt32>(kEventParamMouseWheelDelta, typeSInt32) ;
 532
 533             wxevent.m_wheelRotation = delta;
 534             wxevent.m_wheelDelta = 1;
 535             wxevent.m_linesPerAction = 1;
 536             if ( axis == kEventMouseWheelAxisX )
 537                 wxevent.m_wheelAxis = 1;
 538         }
 539         break ;
 540
 541         case kEventMouseEntered :
 542         case kEventMouseExited :
 543         case kEventMouseDragged :
 544         case kEventMouseMoved :
 545             wxevent.SetEventType( wxEVT_MOTION ) ;
 546             break;
 547         default :
 548             break ;
 549     }
 550 }
 551
 552 #define NEW_CAPTURE_HANDLING 1
 553
 554 pascal OSStatus
 555 wxMacTopLevelMouseEventHandler(EventHandlerCallRef WXUNUSED(handler),
 556                                EventRef event,
 557                                void *data)
 558 {
 559     wxNonOwnedWindow* toplevelWindow = data ? ((wxNonOwnedWindowImpl*) data)->GetWXPeer() : NULL ;
 560
 561     OSStatus result = eventNotHandledErr ;
 562
 563     wxMacCarbonEvent cEvent( event ) ;
 564
 565     Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
 566     Point windowMouseLocation = screenMouseLocation ;
 567
 568     WindowRef window = NULL;
 569     short windowPart = ::FindWindow(screenMouseLocation, &window);
 570
 571     wxWindow* currentMouseWindow = NULL ;
 572     ControlRef control = NULL ;
 573
 574 #if NEW_CAPTURE_HANDLING
 575     if ( wxApp::s_captureWindow )
 576     {
 577         window = (WindowRef) wxApp::s_captureWindow->MacGetTopLevelWindowRef() ;
 578         windowPart = inContent ;
 579     }
 580 #endif
 581
 582     if ( window )
 583     {
 584         QDGlobalToLocalPoint( GetWindowPort( window ), &windowMouseLocation );
 585
 586         if ( wxApp::s_captureWindow
 587 #if !NEW_CAPTURE_HANDLING
 588              && wxApp::s_captureWindow->MacGetTopLevelWindowRef() == (WXWindow) window && windowPart == inContent
 589 #endif
 590              )
 591         {
 592             currentMouseWindow = wxApp::s_captureWindow ;
 593         }
 594         else if ( (IsWindowActive(window) && windowPart == inContent) )
 595         {
 596             ControlPartCode part ;
 597             control = FindControlUnderMouse( windowMouseLocation , window , &part ) ;
 598             // if there is no control below the mouse position, send the event to the toplevel window itself
 599             if ( control == 0 )
 600             {
 601                 currentMouseWindow = (wxWindow*) toplevelWindow ;
 602             }
 603             else
 604             {
 605                 currentMouseWindow = (wxWindow*) wxFindWindowFromWXWidget( (WXWidget) control ) ;
 606 #ifndef __WXUNIVERSAL__
 607                 if ( currentMouseWindow == NULL && cEvent.GetKind() == kEventMouseMoved )
 608                 {
 609 #if wxUSE_TOOLBAR
 610                     // for wxToolBar to function we have to send certaint events to it
 611                     // instead of its children (wxToolBarTools)
 612                     ControlRef parent ;
 613                     GetSuperControl(control, &parent );
 614                     wxWindow *wxparent = (wxWindow*) wxFindWindowFromWXWidget((WXWidget) parent ) ;
 615                     if ( wxparent && wxparent->IsKindOf( CLASSINFO( wxToolBar ) ) )
 616                         currentMouseWindow = wxparent ;
 617 #endif
 618                 }
 619 #endif
 620             }
 621
 622             // disabled windows must not get any input messages
 623             if ( currentMouseWindow && !currentMouseWindow->MacIsReallyEnabled() )
 624                 currentMouseWindow = NULL;
 625         }
 626     }
 627
 628     wxMouseEvent wxevent(wxEVT_LEFT_DOWN);
 629     SetupMouseEvent( wxevent , cEvent ) ;
 630
 631     // handle all enter / leave events
 632
 633     if ( currentMouseWindow != g_MacLastWindow )
 634     {
 635         if ( g_MacLastWindow )
 636         {
 637             wxMouseEvent eventleave(wxevent);
 638             eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
 639             g_MacLastWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
 640             eventleave.SetEventObject( g_MacLastWindow ) ;
 641             wxevent.SetId( g_MacLastWindow->GetId() ) ;
 642
 643 #if wxUSE_TOOLTIPS
 644             wxToolTip::RelayEvent( g_MacLastWindow , eventleave);
 645 #endif
 646
 647             g_MacLastWindow->HandleWindowEvent(eventleave);
 648         }
 649
 650         if ( currentMouseWindow )
 651         {
 652             wxMouseEvent evententer(wxevent);
 653             evententer.SetEventType( wxEVT_ENTER_WINDOW );
 654             currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
 655             evententer.SetEventObject( currentMouseWindow ) ;
 656             wxevent.SetId( currentMouseWindow->GetId() ) ;
 657
 658 #if wxUSE_TOOLTIPS
 659             wxToolTip::RelayEvent( currentMouseWindow , evententer );
 660 #endif
 661
 662             currentMouseWindow->HandleWindowEvent(evententer);
 663         }
 664
 665         g_MacLastWindow = currentMouseWindow ;
 666     }
 667
 668     if ( windowPart == inMenuBar )
 669     {
 670         // special case menu bar, as we are having a low-level runloop we must do it ourselves
 671         if ( cEvent.GetKind() == kEventMouseDown )
 672         {
 673             ::MenuSelect( screenMouseLocation ) ;
 674             ::HiliteMenu(0);
 675             result = noErr ;
 676         }
 677     }
 678     else if ( window && windowPart == inProxyIcon )
 679     {
 680         // special case proxy icon bar, as we are having a low-level runloop we must do it ourselves
 681         if ( cEvent.GetKind() == kEventMouseDown )
 682         {
 683             if ( ::TrackWindowProxyDrag( window, screenMouseLocation ) != errUserWantsToDragWindow )
 684             {
 685                 // TODO Track change of file path and report back
 686                 result = noErr ;
 687             }
 688         }
 689     }
 690     else if ( currentMouseWindow )
 691     {
 692         wxWindow *currentMouseWindowParent = currentMouseWindow->GetParent();
 693
 694         currentMouseWindow->ScreenToClient( &wxevent.m_x , &wxevent.m_y ) ;
 695
 696         wxevent.SetEventObject( currentMouseWindow ) ;
 697         wxevent.SetId( currentMouseWindow->GetId() ) ;
 698
 699         // make tooltips current
 700
 701 #if wxUSE_TOOLTIPS
 702         if ( wxevent.GetEventType() == wxEVT_MOTION )
 703             wxToolTip::RelayEvent( currentMouseWindow , wxevent );
 704 #endif
 705
 706         if ( currentMouseWindow->HandleWindowEvent(wxevent) )
 707         {
 708             if ((currentMouseWindowParent != NULL) &&
 709                 (currentMouseWindowParent->GetChildren().Find(currentMouseWindow) == NULL))
 710                 currentMouseWindow = NULL;
 711
 712             result = noErr;
 713         }
 714         else
 715         {
 716             // if the user code did _not_ handle the event, then perform the
 717             // default processing
 718             if ( wxevent.GetEventType() == wxEVT_LEFT_DOWN )
 719             {
 720                 // ... that is set focus to this window
 721                 if (currentMouseWindow->CanAcceptFocus() && wxWindow::FindFocus()!=currentMouseWindow)
 722                     currentMouseWindow->SetFocus();
 723             }
 724         }
 725
 726         if ( cEvent.GetKind() == kEventMouseUp && wxApp::s_captureWindow )
 727         {
 728             wxApp::s_captureWindow = NULL ;
 729             // update cursor ?
 730          }
 731
 732         // update cursor
 733
 734         wxWindow* cursorTarget = currentMouseWindow ;
 735         wxPoint cursorPoint( wxevent.m_x , wxevent.m_y ) ;
 736
 737         extern wxCursor gGlobalCursor;
 738
 739         if (!gGlobalCursor.IsOk())
 740         {
 741             while ( cursorTarget && !cursorTarget->MacSetupCursor( cursorPoint ) )
 742             {
 743                 cursorTarget = cursorTarget->GetParent() ;
 744                 if ( cursorTarget )
 745                     cursorPoint += cursorTarget->GetPosition();
 746             }
 747         }
 748
 749     }
 750     else // currentMouseWindow == NULL
 751     {
 752         if (toplevelWindow && !control)
 753         {
 754            extern wxCursor gGlobalCursor;
 755            if (!gGlobalCursor.IsOk())
 756            {
 757                 // update cursor when over toolbar and titlebar etc.
 758                 wxPoint cursorPoint( wxevent.m_x , wxevent.m_y ) ;
 759                 toplevelWindow->MacSetupCursor( cursorPoint );
 760            }
 761         }
 762
 763         // don't mess with controls we don't know about
 764         // for some reason returning eventNotHandledErr does not lead to the correct behaviour
 765         // so we try sending them the correct control directly
 766         if ( cEvent.GetKind() == kEventMouseDown && toplevelWindow && control )
 767         {
 768             EventModifiers modifiers = cEvent.GetParameter<EventModifiers>(kEventParamKeyModifiers, typeUInt32) ;
 769             Point clickLocation = windowMouseLocation ;
 770
 771             HIPoint hiPoint ;
 772             hiPoint.x = clickLocation.h ;
 773             hiPoint.y = clickLocation.v ;
 774             HIViewConvertPoint( &hiPoint , (ControlRef) toplevelWindow->GetHandle() , control  ) ;
 775             clickLocation.h = (int)hiPoint.x ;
 776             clickLocation.v = (int)hiPoint.y ;
 777
 778             HandleControlClick( control , clickLocation , modifiers , (ControlActionUPP ) -1 ) ;
 779             result = noErr ;
 780         }
 781     }
 782
 783     return result ;
 784 }
 785
 786 static pascal OSStatus
 787 wxNonOwnedWindowEventHandler(EventHandlerCallRef WXUNUSED(handler),
 788                                 EventRef event,
 789                                 void *data)
 790 {
 791     OSStatus result = eventNotHandledErr ;
 792
 793     wxMacCarbonEvent cEvent( event ) ;
 794
 795     // WindowRef windowRef = cEvent.GetParameter<WindowRef>(kEventParamDirectObject) ;
 796     wxNonOwnedWindow* toplevelWindow = data ? ((wxNonOwnedWindowImpl*) data)->GetWXPeer() : NULL;
 797
 798     switch ( GetEventKind( event ) )
 799     {
 800         case kEventWindowActivated :
 801         {
 802             toplevelWindow->HandleActivated( cEvent.GetTicks() , true) ;
 803             // we still sending an eventNotHandledErr in order to allow for default processing
 804         }
 805             break ;
 806
 807         case kEventWindowDeactivated :
 808         {
 809             toplevelWindow->HandleActivated( cEvent.GetTicks() , false) ;
 810             // we still sending an eventNotHandledErr in order to allow for default processing
 811         }
 812             break ;
 813
 814         case kEventWindowShown :
 815             toplevelWindow->Refresh() ;
 816             result = noErr ;
 817             break ;
 818
 819         case kEventWindowClose :
 820             toplevelWindow->Close() ;
 821             result = noErr ;
 822             break ;
 823
 824         case kEventWindowBoundsChanged :
 825         {
 826             UInt32 attributes = cEvent.GetParameter<UInt32>(kEventParamAttributes, typeUInt32) ;
 827             Rect newRect = cEvent.GetParameter<Rect>(kEventParamCurrentBounds) ;
 828             wxRect r( newRect.left , newRect.top , newRect.right - newRect.left , newRect.bottom - newRect.top ) ;
 829             if ( attributes & kWindowBoundsChangeSizeChanged )
 830             {
 831                 toplevelWindow->HandleResized(cEvent.GetTicks() ) ;
 832             }
 833
 834             if ( attributes & kWindowBoundsChangeOriginChanged )
 835             {
 836                 toplevelWindow->HandleMoved(cEvent.GetTicks() ) ;
 837             }
 838
 839             result = noErr ;
 840         }
 841             break ;
 842
 843         case kEventWindowBoundsChanging :
 844         {
 845             UInt32 attributes = cEvent.GetParameter<UInt32>(kEventParamAttributes,typeUInt32) ;
 846             Rect newRect = cEvent.GetParameter<Rect>(kEventParamCurrentBounds) ;
 847
 848             if ( (attributes & kWindowBoundsChangeSizeChanged) || (attributes & kWindowBoundsChangeOriginChanged) )
 849             {
 850                 // all (Mac) rects are in content area coordinates, all wxRects in structure coordinates
 851                 int left , top , width , height ;
 852                 // structure width
 853                 int swidth, sheight;
 854
 855                 toplevelWindow->GetNonOwnedPeer()->GetContentArea(left, top, width, height);
 856                 toplevelWindow->GetNonOwnedPeer()->GetSize(swidth, sheight);
 857                 int deltawidth = swidth - width;
 858                 int deltaheight = sheight - height;
 859                 wxRect adjustR(
 860                     newRect.left - left,
 861                     newRect.top - top,
 862                     newRect.right - newRect.left + deltawidth,
 863                     newRect.bottom - newRect.top + deltaheight ) ;
 864
 865                 toplevelWindow->HandleResizing( cEvent.GetTicks(), &adjustR );
 866
 867                 const Rect adjustedRect = { adjustR.y + top  , adjustR.x + left , adjustR.y + top + adjustR.height - deltaheight ,
 868                     adjustR.x + left + adjustR.width - deltawidth } ;
 869                 if ( !EqualRect( &newRect , &adjustedRect ) )
 870                     cEvent.SetParameter<Rect>( kEventParamCurrentBounds , &adjustedRect ) ;
 871             }
 872
 873             result = noErr ;
 874         }
 875             break ;
 876
 877         case kEventWindowGetRegion :
 878             {
 879                 if ( toplevelWindow->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
 880                 {
 881                     WindowRegionCode windowRegionCode ;
 882
 883                     // Fetch the region code that is being queried
 884                     GetEventParameter( event,
 885                                        kEventParamWindowRegionCode,
 886                                        typeWindowRegionCode, NULL,
 887                                        sizeof windowRegionCode, NULL,
 888                                        &windowRegionCode ) ;
 889
 890                     // If it is the opaque region code then set the
 891                     // region to empty and return noErr to stop event
 892                     // propagation
 893                     if ( windowRegionCode == kWindowOpaqueRgn ) {
 894                         RgnHandle region;
 895                         GetEventParameter( event,
 896                                            kEventParamRgnHandle,
 897                                            typeQDRgnHandle, NULL,
 898                                            sizeof region, NULL,
 899                                            &region) ;
 900                         SetEmptyRgn(region) ;
 901                         result = noErr ;
 902                     }
 903                 }
 904             }
 905             break ;
 906
 907         default :
 908             break ;
 909     }
 910
 911     return result ;
 912 }
 913
 914 // mix this in from window.cpp
 915 pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) ;
 916
 917 pascal OSStatus wxNonOwnedEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 918 {
 919     OSStatus result = eventNotHandledErr ;
 920
 921     switch ( GetEventClass( event ) )
 922     {
 923         case kEventClassTextInput :
 924         {
 925             // TODO remove as soon as all events are on implementation classes only
 926             wxNonOwnedWindow* toplevelWindow = data ? ((wxNonOwnedWindowImpl*) data)->GetWXPeer() : NULL;
 927
 928             result = wxMacUnicodeTextEventHandler( handler, event , toplevelWindow ) ;
 929         }
 930             break ;
 931
 932         case kEventClassKeyboard :
 933             result = KeyboardEventHandler( handler, event , data ) ;
 934             break ;
 935
 936         case kEventClassWindow :
 937             result = wxNonOwnedWindowEventHandler( handler, event , data ) ;
 938             break ;
 939
 940         case kEventClassMouse :
 941             result = wxMacTopLevelMouseEventHandler( handler, event , data ) ;
 942             break ;
 943
 944         default :
 945             break ;
 946     }
 947
 948     return result ;
 949 }
 950
 951 DEFINE_ONE_SHOT_HANDLER_GETTER( wxNonOwnedEventHandler )
 952
 953 // ---------------------------------------------------------------------------
 954 // Support functions for shaped windows, based on Apple's CustomWindow sample at
 955 // http://developer.apple.com/samplecode/Sample_Code/Human_Interface_Toolbox/Mac_OS_High_Level_Toolbox/CustomWindow.htm
 956 // ---------------------------------------------------------------------------
 957
 958 static void wxShapedMacWindowGetPos(WindowRef window, Rect* inRect)
 959 {
 960     GetWindowPortBounds(window, inRect);
 961     Point pt = { inRect->top ,inRect->left };
 962     QDLocalToGlobalPoint( GetWindowPort( window ), &pt );
 963     inRect->bottom += pt.v - inRect->top;
 964     inRect->right += pt.h - inRect->left;
 965     inRect->top = pt.v;
 966     inRect->left = pt.h;
 967 }
 968
 969 static SInt32 wxShapedMacWindowGetFeatures(WindowRef WXUNUSED(window), SInt32 param)
 970 {
 971     /*------------------------------------------------------
 972         Define which options your custom window supports.
 973     --------------------------------------------------------*/
 974     //just enable everything for our demo
 975     *(OptionBits*)param =
 976         //kWindowCanGrow |
 977         //kWindowCanZoom |
 978         kWindowCanCollapse |
 979         //kWindowCanGetWindowRegion |
 980         //kWindowHasTitleBar |
 981         //kWindowSupportsDragHilite |
 982         kWindowCanDrawInCurrentPort |
 983         //kWindowCanMeasureTitle |
 984         kWindowWantsDisposeAtProcessDeath |
 985         kWindowSupportsGetGrowImageRegion |
 986         kWindowDefSupportsColorGrafPort;
 987
 988     return 1;
 989 }
 990
 991 // The content region is left as a rectangle matching the window size, this is
 992 // so the origin in the paint event, and etc. still matches what the
 993 // programmer expects.
 994 static void wxShapedMacWindowContentRegion(WindowRef window, RgnHandle rgn)
 995 {
 996     SetEmptyRgn(rgn);
 997     wxNonOwnedWindow* win = wxNonOwnedWindow::GetFromWXWindow((WXWindow)window);
 998     if (win)
 999     {
1000         Rect r ;
1001         wxShapedMacWindowGetPos( window, &r ) ;
1002         RectRgn( rgn , &r ) ;
1003     }
1004 }
1005
1006 // The structure region is set to the shape given to the SetShape method.
1007 static void wxShapedMacWindowStructureRegion(WindowRef window, RgnHandle rgn)
1008 {
1009     RgnHandle cachedRegion = (RgnHandle) GetWRefCon(window);
1010
1011     SetEmptyRgn(rgn);
1012     if (cachedRegion)
1013     {
1014         Rect windowRect;
1015         wxShapedMacWindowGetPos(window, &windowRect);    // how big is the window
1016         CopyRgn(cachedRegion, rgn);                      // make a copy of our cached region
1017         OffsetRgn(rgn, windowRect.left, windowRect.top); // position it over window
1018         //MapRgn(rgn, &mMaskSize, &windowRect);          //scale it to our actual window size
1019     }
1020 }
1021
1022 static SInt32 wxShapedMacWindowGetRegion(WindowRef window, SInt32 param)
1023 {
1024     GetWindowRegionPtr rgnRec = (GetWindowRegionPtr)param;
1025
1026     if (rgnRec == NULL)
1027         return paramErr;
1028
1029     switch (rgnRec->regionCode)
1030     {
1031         case kWindowStructureRgn:
1032             wxShapedMacWindowStructureRegion(window, rgnRec->winRgn);
1033             break;
1034
1035         case kWindowContentRgn:
1036             wxShapedMacWindowContentRegion(window, rgnRec->winRgn);
1037             break;
1038
1039         default:
1040             SetEmptyRgn(rgnRec->winRgn);
1041             break;
1042     }
1043
1044     return noErr;
1045 }
1046
1047 // Determine the region of the window which was hit
1048 //
1049 static SInt32 wxShapedMacWindowHitTest(WindowRef window, SInt32 param)
1050 {
1051     Point hitPoint;
1052     static RgnHandle tempRgn = NULL;
1053
1054     if (tempRgn == NULL)
1055         tempRgn = NewRgn();
1056
1057     // get the point clicked
1058     SetPt( &hitPoint, LoWord(param), HiWord(param) );
1059
1060      // Mac OS 8.5 or later
1061     wxShapedMacWindowStructureRegion(window, tempRgn);
1062     if (PtInRgn( hitPoint, tempRgn )) //in window content region?
1063         return wInContent;
1064
1065     // no significant area was hit
1066     return wNoHit;
1067 }
1068
1069 static pascal long wxShapedMacWindowDef(short WXUNUSED(varCode), WindowRef window, SInt16 message, SInt32 param)
1070 {
1071     switch (message)
1072     {
1073         case kWindowMsgHitTest:
1074             return wxShapedMacWindowHitTest(window, param);
1075
1076         case kWindowMsgGetFeatures:
1077             return wxShapedMacWindowGetFeatures(window, param);
1078
1079         // kWindowMsgGetRegion is sent during CreateCustomWindow and ReshapeCustomWindow
1080         case kWindowMsgGetRegion:
1081             return wxShapedMacWindowGetRegion(window, param);
1082
1083         default:
1084             break;
1085     }
1086
1087     return 0;
1088 }
1089
1090 // implementation
1091
1092 typedef struct
1093 {
1094     wxPoint m_position ;
1095     wxSize m_size ;
1096     bool m_wasResizable ;
1097 } FullScreenData ;
1098
1099 wxNonOwnedWindowCarbonImpl::wxNonOwnedWindowCarbonImpl()
1100 {
1101 }
1102
1103 wxNonOwnedWindowCarbonImpl::wxNonOwnedWindowCarbonImpl( wxNonOwnedWindow* nonownedwnd) : wxNonOwnedWindowImpl( nonownedwnd)
1104 {
1105     m_macEventHandler = NULL;
1106     m_macWindow = NULL;
1107     m_macFullScreenData = NULL ;
1108 }
1109
1110 wxNonOwnedWindowCarbonImpl::~wxNonOwnedWindowCarbonImpl()
1111 {
1112 #if wxUSE_TOOLTIPS
1113         wxToolTip::NotifyWindowDelete(m_macWindow) ;
1114 #endif
1115
1116     if ( m_macEventHandler )
1117     {
1118         ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
1119         m_macEventHandler = NULL ;
1120     }
1121
1122     if ( m_macWindow )
1123         DisposeWindow( m_macWindow );
1124
1125     FullScreenData *data = (FullScreenData *) m_macFullScreenData ;
1126     delete data ;
1127     m_macFullScreenData = NULL ;
1128
1129     m_macWindow = NULL;
1130
1131 }
1132
1133 void wxNonOwnedWindowCarbonImpl::Destroy()
1134 {
1135     if ( m_macEventHandler )
1136     {
1137         ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
1138         m_macEventHandler = NULL ;
1139     }
1140
1141     wxPendingDelete.Append( new wxDeferredObjectDeleter( this ) ) ;
1142 }
1143
1144 void wxNonOwnedWindowInstallTopLevelWindowEventHandler(WindowRef window, EventHandlerRef* handler, void *ref)
1145 {
1146     InstallWindowEventHandler(window, GetwxNonOwnedEventHandlerUPP(),
1147         GetEventTypeCount(eventList), eventList, ref, handler );
1148 }
1149
1150 bool wxNonOwnedWindowCarbonImpl::SetShape(const wxRegion& region)
1151 {
1152     // Make a copy of the region
1153     RgnHandle  shapeRegion = NewRgn();
1154     HIShapeGetAsQDRgn( region.GetWXHRGN(), shapeRegion );
1155
1156     // Dispose of any shape region we may already have
1157     RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef) m_wxPeer->GetWXWindow() );
1158     if ( oldRgn )
1159         DisposeRgn(oldRgn);
1160
1161     // Save the region so we can use it later
1162     SetWRefCon((WindowRef) m_wxPeer->GetWXWindow(), (URefCon)shapeRegion);
1163
1164     // inform the window manager that the window has changed shape
1165     ReshapeCustomWindow((WindowRef) m_wxPeer->GetWXWindow());
1166
1167     return true;
1168 }
1169
1170
1171 void wxNonOwnedWindowCarbonImpl::MacInstallTopLevelWindowEventHandler()
1172 {
1173     if ( m_macEventHandler != NULL )
1174     {
1175         verify_noerr( ::RemoveEventHandler( (EventHandlerRef) m_macEventHandler ) ) ;
1176     }
1177     wxNonOwnedWindowInstallTopLevelWindowEventHandler(MAC_WXHWND(m_macWindow),(EventHandlerRef *)&m_macEventHandler,this);
1178 }
1179
1180 void wxNonOwnedWindowCarbonImpl::Create(
1181     wxWindow* parent,
1182     const wxPoint& pos,
1183     const wxSize& size,
1184     long style, long extraStyle,
1185     const wxString& name )
1186 {
1187
1188     OSStatus err = noErr ;
1189     Rect theBoundsRect;
1190
1191     int x = (int)pos.x;
1192     int y = (int)pos.y;
1193
1194     int w = size.x;
1195     int h = size.y;
1196
1197     ::SetRect(&theBoundsRect, x, y , x + w, y + h);
1198
1199     // translate the window attributes in the appropriate window class and attributes
1200     WindowClass wclass = 0;
1201     WindowAttributes attr = kWindowNoAttributes ;
1202     WindowGroupRef group = NULL ;
1203     bool activationScopeSet = false;
1204     WindowActivationScope activationScope = kWindowActivationScopeNone;
1205
1206     if ( style & wxFRAME_TOOL_WINDOW )
1207     {
1208         if (
1209             ( style & wxMINIMIZE_BOX ) || ( style & wxMAXIMIZE_BOX ) ||
1210             ( style & wxSYSTEM_MENU ) || ( style & wxCAPTION ) ||
1211             ( style &wxTINY_CAPTION_HORIZ) ||  ( style &wxTINY_CAPTION_VERT)
1212             )
1213         {
1214             if ( ( style & wxSTAY_ON_TOP ) )
1215                 wclass = kUtilityWindowClass;
1216             else
1217                 wclass = kFloatingWindowClass ;
1218
1219             if ( ( style &wxTINY_CAPTION_VERT) )
1220                 attr |= kWindowSideTitlebarAttribute ;
1221         }
1222         else
1223         {
1224             if ( style & wxNO_BORDER )
1225             {
1226                 wclass = kSimpleWindowClass ;
1227             }
1228             else
1229             {
1230                 wclass = kPlainWindowClass ;
1231             }
1232             activationScopeSet = true;
1233             activationScope = kWindowActivationScopeNone;
1234         }
1235     }
1236     else if ( ( style & wxPOPUP_WINDOW ) )
1237     {
1238         if ( ( style & wxBORDER_NONE ) )
1239         {
1240             wclass = kHelpWindowClass ;   // has no border
1241             attr |= kWindowNoShadowAttribute;
1242         }
1243         else
1244         {
1245             wclass = kPlainWindowClass ;  // has a single line border, it will have to do for now
1246         }
1247         group = GetWindowGroupOfClass(kFloatingWindowClass) ;
1248         // make sure we don't deactivate something
1249         activationScopeSet = true;
1250         activationScope = kWindowActivationScopeNone;
1251     }
1252     else if ( ( style & wxCAPTION ) )
1253     {
1254         wclass = kDocumentWindowClass ;
1255         attr |= kWindowInWindowMenuAttribute ;
1256     }
1257     else if ( ( style & wxFRAME_DRAWER ) )
1258     {
1259         wclass = kDrawerWindowClass;
1260     }
1261     else
1262     {
1263         if ( ( style & wxMINIMIZE_BOX ) || ( style & wxMAXIMIZE_BOX ) ||
1264             ( style & wxCLOSE_BOX ) || ( style & wxSYSTEM_MENU ) )
1265         {
1266             wclass = kDocumentWindowClass ;
1267         }
1268         else if ( ( style & wxNO_BORDER ) )
1269         {
1270             wclass = kSimpleWindowClass ;
1271         }
1272         else
1273         {
1274             wclass = kPlainWindowClass ;
1275         }
1276     }
1277
1278     if ( wclass != kPlainWindowClass )
1279     {
1280         if ( ( style & wxMINIMIZE_BOX ) )
1281             attr |= kWindowCollapseBoxAttribute ;
1282
1283         if ( ( style & wxMAXIMIZE_BOX ) )
1284             attr |= kWindowFullZoomAttribute ;
1285
1286         if ( ( style & wxRESIZE_BORDER ) )
1287             attr |= kWindowResizableAttribute ;
1288
1289         if ( ( style & wxCLOSE_BOX) )
1290             attr |= kWindowCloseBoxAttribute ;
1291     }
1292     attr |= kWindowLiveResizeAttribute;
1293
1294     if ( ( style &wxSTAY_ON_TOP) )
1295         group = GetWindowGroupOfClass(kUtilityWindowClass) ;
1296
1297     if ( ( style & wxFRAME_FLOAT_ON_PARENT ) )
1298         group = GetWindowGroupOfClass(kFloatingWindowClass) ;
1299
1300     if ( group == NULL && parent != NULL )
1301     {
1302         WindowRef parenttlw = (WindowRef) parent->MacGetTopLevelWindowRef();
1303         if( parenttlw )
1304             group = GetWindowGroupParent( GetWindowGroup( parenttlw ) );
1305     }
1306
1307     attr |= kWindowCompositingAttribute;
1308 #if 0 // TODO : decide on overall handling of high dpi screens (pixel vs userscale)
1309     attr |= kWindowFrameworkScaledAttribute;
1310 #endif
1311
1312     if ( ( style &wxFRAME_SHAPED) )
1313     {
1314         WindowDefSpec customWindowDefSpec;
1315         customWindowDefSpec.defType = kWindowDefProcPtr;
1316         customWindowDefSpec.u.defProc =
1317 #ifdef __LP64__
1318             (WindowDefUPP) wxShapedMacWindowDef;
1319 #else
1320             NewWindowDefUPP(wxShapedMacWindowDef);
1321 #endif
1322         err = ::CreateCustomWindow( &customWindowDefSpec, wclass,
1323                               attr, &theBoundsRect,
1324                               (WindowRef*) &m_macWindow);
1325     }
1326     else
1327     {
1328         err = ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
1329     }
1330
1331     if ( err == noErr && m_macWindow != NULL && group != NULL )
1332         SetWindowGroup( (WindowRef) m_macWindow , group ) ;
1333
1334     wxCHECK_RET( err == noErr, wxT("Mac OS error when trying to create new window") );
1335
1336     // setup a separate group for each window, so that overlays can be handled easily
1337
1338     WindowGroupRef overlaygroup = NULL;
1339     verify_noerr( CreateWindowGroup( kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrHideOnCollapse, &overlaygroup ));
1340     verify_noerr( SetWindowGroupParent( overlaygroup, GetWindowGroup( (WindowRef) m_macWindow )));
1341     verify_noerr( SetWindowGroup( (WindowRef) m_macWindow , overlaygroup ));
1342
1343     if ( activationScopeSet )
1344     {
1345         verify_noerr( SetWindowActivationScope( (WindowRef) m_macWindow , activationScope ));
1346     }
1347
1348     // the create commands are only for content rect,
1349     // so we have to set the size again as structure bounds
1350     SetWindowBounds( m_macWindow , kWindowStructureRgn , &theBoundsRect ) ;
1351
1352     // Causes the inner part of the window not to be metal
1353     // if the style is used before window creation.
1354 #if 0 // TARGET_API_MAC_OSX
1355     if ( m_macUsesCompositing && m_macWindow != NULL )
1356     {
1357         if ( GetExtraStyle() & wxFRAME_EX_METAL )
1358             MacSetMetalAppearance( true ) ;
1359     }
1360 #endif
1361
1362     if ( m_macWindow != NULL )
1363     {
1364         MacSetUnifiedAppearance( true ) ;
1365     }
1366
1367     HIViewRef growBoxRef = 0 ;
1368     err = HIViewFindByID( HIViewGetRoot( m_macWindow ), kHIViewWindowGrowBoxID, &growBoxRef  );
1369     if ( err == noErr && growBoxRef != 0 )
1370         HIGrowBoxViewSetTransparent( growBoxRef, true ) ;
1371
1372     // the frame window event handler
1373     InstallStandardEventHandler( GetWindowEventTarget(m_macWindow) ) ;
1374     MacInstallTopLevelWindowEventHandler() ;
1375
1376     if ( extraStyle & wxFRAME_EX_METAL)
1377         MacSetMetalAppearance(true);
1378
1379     if ( ( style &wxFRAME_SHAPED) )
1380     {
1381         // default shape matches the window size
1382         wxRegion rgn( 0, 0, w, h );
1383         SetShape( rgn );
1384     }
1385 }
1386
1387 bool wxNonOwnedWindowCarbonImpl::ShowWithEffect(bool show,
1388                                          wxShowEffect effect,
1389                                          unsigned timeout)
1390 {
1391     WindowTransitionEffect transition = 0 ;
1392     switch( effect )
1393     {
1394         case wxSHOW_EFFECT_ROLL_TO_LEFT:
1395         case wxSHOW_EFFECT_ROLL_TO_RIGHT:
1396         case wxSHOW_EFFECT_ROLL_TO_TOP:
1397         case wxSHOW_EFFECT_ROLL_TO_BOTTOM:
1398         case wxSHOW_EFFECT_SLIDE_TO_LEFT:
1399         case wxSHOW_EFFECT_SLIDE_TO_RIGHT:
1400         case wxSHOW_EFFECT_SLIDE_TO_TOP:
1401         case wxSHOW_EFFECT_SLIDE_TO_BOTTOM:
1402             transition = kWindowGenieTransitionEffect;
1403             break;
1404         case wxSHOW_EFFECT_BLEND:
1405             transition = kWindowFadeTransitionEffect;
1406             break;
1407         case wxSHOW_EFFECT_EXPAND:
1408             // having sheets would be fine, but this might lead to a repositioning
1409 #if 0
1410             if ( GetParent() )
1411                 transition = kWindowSheetTransitionEffect;
1412             else
1413 #endif
1414                 transition = kWindowZoomTransitionEffect;
1415             break;
1416
1417         case wxSHOW_EFFECT_MAX:
1418             wxFAIL_MSG( "invalid effect flag" );
1419             return false;
1420     }
1421
1422     TransitionWindowOptions options;
1423     options.version = 0;
1424     options.duration = timeout / 1000.0;
1425     options.window = transition == kWindowSheetTransitionEffect ? (WindowRef) m_wxPeer->GetParent()->MacGetTopLevelWindowRef() :0;
1426     options.userData = 0;
1427
1428     wxSize size = wxGetDisplaySize();
1429     Rect bounds;
1430     GetWindowBounds( (WindowRef)m_macWindow, kWindowStructureRgn, &bounds );
1431     CGRect hiBounds = CGRectMake( bounds.left, bounds.top, bounds.right - bounds.left, bounds.bottom - bounds.top );
1432
1433     switch ( effect )
1434     {
1435         case wxSHOW_EFFECT_ROLL_TO_RIGHT:
1436         case wxSHOW_EFFECT_SLIDE_TO_RIGHT:
1437             hiBounds.origin.x = 0;
1438             hiBounds.size.width = 0;
1439             break;
1440
1441         case wxSHOW_EFFECT_ROLL_TO_LEFT:
1442         case wxSHOW_EFFECT_SLIDE_TO_LEFT:
1443             hiBounds.origin.x = size.x;
1444             hiBounds.size.width = 0;
1445             break;
1446
1447         case wxSHOW_EFFECT_ROLL_TO_TOP:
1448         case wxSHOW_EFFECT_SLIDE_TO_TOP:
1449             hiBounds.origin.y = size.y;
1450             hiBounds.size.height = 0;
1451             break;
1452
1453         case wxSHOW_EFFECT_ROLL_TO_BOTTOM:
1454         case wxSHOW_EFFECT_SLIDE_TO_BOTTOM:
1455             hiBounds.origin.y = 0;
1456             hiBounds.size.height = 0;
1457             break;
1458
1459         default:
1460             break; // direction doesn't make sense
1461     }
1462
1463     ::TransitionWindowWithOptions
1464     (
1465         (WindowRef)m_macWindow,
1466         transition,
1467         show ? kWindowShowTransitionAction : kWindowHideTransitionAction,
1468         transition == kWindowGenieTransitionEffect ? &hiBounds : NULL,
1469         false,
1470         &options
1471     );
1472
1473     if ( show )
1474     {
1475         ::SelectWindow( (WindowRef)m_macWindow ) ;
1476     }
1477
1478     return true;
1479 }
1480
1481 void wxNonOwnedWindowCarbonImpl::SetTitle( const wxString& title, wxFontEncoding encoding )
1482 {
1483     SetWindowTitleWithCFString( m_macWindow , wxCFStringRef( title , encoding ) ) ;
1484 }
1485
1486 bool wxNonOwnedWindowCarbonImpl::IsMaximized() const
1487 {
1488     return IsWindowInStandardState( m_macWindow , NULL , NULL ) ;
1489 }
1490
1491 bool wxNonOwnedWindowCarbonImpl::IsIconized() const
1492 {
1493     return IsWindowCollapsed((WindowRef)GetWXWindow() ) ;
1494 }
1495
1496 void wxNonOwnedWindowCarbonImpl::Iconize( bool iconize )
1497 {
1498     if ( IsWindowCollapsable( m_macWindow ) )
1499         CollapseWindow( m_macWindow , iconize ) ;
1500 }
1501
1502 void wxNonOwnedWindowCarbonImpl::Maximize(bool maximize)
1503 {
1504     Point idealSize = { 0 , 0 } ;
1505     if ( maximize )
1506     {
1507 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1508         HIRect bounds ;
1509         HIWindowGetAvailablePositioningBounds(kCGNullDirectDisplay,kHICoordSpace72DPIGlobal,
1510             &bounds);
1511         idealSize.h = bounds.size.width;
1512         idealSize.v = bounds.size.height;
1513 #else
1514         Rect rect ;
1515         GetAvailableWindowPositioningBounds(GetMainDevice(),&rect) ;
1516         idealSize.h = rect.right - rect.left ;
1517         idealSize.v = rect.bottom - rect.top ;
1518 #endif
1519     }
1520     ZoomWindowIdeal( (WindowRef)GetWXWindow() , maximize ? inZoomOut : inZoomIn , &idealSize ) ;
1521 }
1522
1523 bool wxNonOwnedWindowCarbonImpl::IsFullScreen() const
1524 {
1525     return m_macFullScreenData != NULL ;
1526 }
1527
1528 bool wxNonOwnedWindowCarbonImpl::ShowFullScreen(bool show, long style)
1529 {
1530     if ( show )
1531     {
1532         FullScreenData *data = (FullScreenData *)m_macFullScreenData ;
1533         delete data ;
1534         data = new FullScreenData() ;
1535
1536         m_macFullScreenData = data ;
1537         data->m_position = m_wxPeer->GetPosition() ;
1538         data->m_size = m_wxPeer->GetSize() ;
1539 #if wxOSX_USE_CARBON
1540         WindowAttributes attr = 0;
1541         GetWindowAttributes((WindowRef) GetWXWindow(), &attr);
1542         data->m_wasResizable = attr & kWindowResizableAttribute;
1543         if ( style & wxFULLSCREEN_NOMENUBAR )
1544             HideMenuBar() ;
1545 #endif
1546
1547         wxRect client = wxGetClientDisplayRect() ;
1548
1549         int left, top, width, height ;
1550         int x, y, w, h ;
1551
1552         x = client.x ;
1553         y = client.y ;
1554         w = client.width ;
1555         h = client.height ;
1556
1557         GetContentArea( left, top, width, height ) ;
1558         int outerwidth, outerheight;
1559         GetSize( outerwidth, outerheight );
1560
1561         if ( style & wxFULLSCREEN_NOCAPTION )
1562         {
1563             y -= top ;
1564             h += top ;
1565             // avoid adding the caption twice to the height
1566             outerheight -= top;
1567         }
1568
1569         if ( style & wxFULLSCREEN_NOBORDER )
1570         {
1571             x -= left ;
1572             w += outerwidth - width;
1573             h += outerheight - height;
1574         }
1575
1576         if ( style & wxFULLSCREEN_NOTOOLBAR )
1577         {
1578             // TODO
1579         }
1580
1581         if ( style & wxFULLSCREEN_NOSTATUSBAR )
1582         {
1583             // TODO
1584         }
1585
1586         m_wxPeer->SetSize( x , y , w, h ) ;
1587         if ( data->m_wasResizable )
1588         {
1589 #if wxOSX_USE_CARBON
1590             ChangeWindowAttributes( (WindowRef) GetWXWindow() , kWindowNoAttributes , kWindowResizableAttribute ) ;
1591 #endif
1592         }
1593     }
1594     else if ( m_macFullScreenData != NULL )
1595     {
1596         FullScreenData *data = (FullScreenData *) m_macFullScreenData ;
1597 #if wxOSX_USE_CARBON
1598         ShowMenuBar() ;
1599         if ( data->m_wasResizable )
1600             ChangeWindowAttributes( (WindowRef) GetWXWindow() , kWindowResizableAttribute ,  kWindowNoAttributes ) ;
1601 #endif
1602         m_wxPeer->SetPosition( data->m_position ) ;
1603         m_wxPeer->SetSize( data->m_size ) ;
1604
1605         delete data ;
1606         m_macFullScreenData = NULL ;
1607     }
1608
1609     return true;
1610 }
1611
1612 // Attracts the users attention to this window if the application is
1613 // inactive (should be called when a background event occurs)
1614
1615 static pascal void wxMacNMResponse( NMRecPtr ptr )
1616 {
1617     NMRemove( ptr ) ;
1618     DisposePtr( (Ptr)ptr ) ;
1619 }
1620
1621 void wxNonOwnedWindowCarbonImpl::RequestUserAttention(int WXUNUSED(flags))
1622 {
1623     NMRecPtr notificationRequest = (NMRecPtr) NewPtr( sizeof( NMRec) ) ;
1624
1625     memset( notificationRequest , 0 , sizeof(*notificationRequest) ) ;
1626     notificationRequest->qType = nmType ;
1627     notificationRequest->nmMark = 1 ;
1628     notificationRequest->nmIcon = 0 ;
1629     notificationRequest->nmSound = 0 ;
1630     notificationRequest->nmStr = NULL ;
1631     notificationRequest->nmResp = wxMacNMResponse ;
1632
1633     verify_noerr( NMInstall( notificationRequest ) ) ;
1634 }
1635
1636 void wxNonOwnedWindowCarbonImpl::ScreenToWindow( int *x, int *y )
1637 {
1638     HIPoint p = CGPointMake(  (x ? *x : 0), (y ? *y : 0) );
1639     HIViewRef contentView ;
1640     // TODO check toolbar offset
1641     HIViewFindByID( HIViewGetRoot( m_macWindow ), kHIViewWindowContentID , &contentView) ;
1642     HIPointConvert( &p, kHICoordSpace72DPIGlobal, NULL, kHICoordSpaceView, contentView );
1643     if ( x )
1644         *x = p.x;
1645     if ( y )
1646         *y = p.y;
1647 }
1648
1649 void wxNonOwnedWindowCarbonImpl::WindowToScreen( int *x, int *y )
1650 {
1651     HIPoint p = CGPointMake(  (x ? *x : 0), (y ? *y : 0) );
1652     HIViewRef contentView ;
1653     // TODO check toolbar offset
1654     HIViewFindByID( HIViewGetRoot( m_macWindow ), kHIViewWindowContentID , &contentView) ;
1655     HIPointConvert( &p, kHICoordSpaceView, contentView, kHICoordSpace72DPIGlobal, NULL );
1656     if ( x )
1657         *x = p.x;
1658     if ( y )
1659         *y = p.y;
1660 }
1661
1662 wxNonOwnedWindowImpl* wxNonOwnedWindowImpl::CreateNonOwnedWindow( wxNonOwnedWindow* wxpeer, wxWindow* parent, const wxPoint& pos, const wxSize& size,
1663     long style, long extraStyle, const wxString& name )
1664 {
1665     wxNonOwnedWindowImpl* now = new wxNonOwnedWindowCarbonImpl( wxpeer );
1666     now->Create( parent, pos, size, style , extraStyle, name );
1667     return now;
1668 }