src/mac/carbon/nonownedwnd.cpp

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