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