1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/carbon/toplevel.cpp
3 // Purpose: implements wxTopLevelWindow for Mac
4 // Author: Stefan Csomor
8 // Copyright: (c) 2001-2004 Stefan Csomor
9 // License: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/toplevel.h"
32 #include "wx/string.h"
35 #include "wx/settings.h"
36 #include "wx/strconv.h"
37 #include "wx/control.h"
40 #include "wx/mac/uma.h"
41 #include "wx/mac/aga.h"
42 #include "wx/tooltip.h"
45 #if wxUSE_SYSTEM_OPTIONS
46 #include "wx/sysopt.h"
50 #include <ToolUtils.h>
54 #include "wx/mac/private.h"
56 // ----------------------------------------------------------------------------
58 // ----------------------------------------------------------------------------
60 // unified title and toolbar constant - not in Tiger headers, so we duplicate it here
61 #define kWindowUnifiedTitleAndToolbarAttribute (1 << 7)
63 // trace mask for activation tracing messages
64 static const wxChar
*TRACE_ACTIVATE
= _T("activation");
66 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
70 // list of all frames and modeless dialogs
71 wxWindowList wxModelessWindows
;
73 static pascal long wxShapedMacWindowDef(short varCode
, WindowRef window
, SInt16 message
, SInt32 param
);
75 // ============================================================================
76 // wxTopLevelWindowMac implementation
77 // ============================================================================
79 BEGIN_EVENT_TABLE(wxTopLevelWindowMac
, wxTopLevelWindowBase
)
82 // ---------------------------------------------------------------------------
84 // ---------------------------------------------------------------------------
86 static const EventTypeSpec eventList
[] =
88 // TODO: remove control related event like key and mouse (except for WindowLeave events)
90 { kEventClassKeyboard
, kEventRawKeyDown
} ,
91 { kEventClassKeyboard
, kEventRawKeyRepeat
} ,
92 { kEventClassKeyboard
, kEventRawKeyUp
} ,
93 { kEventClassKeyboard
, kEventRawKeyModifiersChanged
} ,
95 { kEventClassTextInput
, kEventTextInputUnicodeForKeyEvent
} ,
96 { kEventClassTextInput
, kEventTextInputUpdateActiveInputArea
} ,
98 { kEventClassWindow
, kEventWindowShown
} ,
99 { kEventClassWindow
, kEventWindowActivated
} ,
100 { kEventClassWindow
, kEventWindowDeactivated
} ,
101 { kEventClassWindow
, kEventWindowBoundsChanging
} ,
102 { kEventClassWindow
, kEventWindowBoundsChanged
} ,
103 { kEventClassWindow
, kEventWindowClose
} ,
104 { kEventClassWindow
, kEventWindowGetRegion
} ,
106 // we have to catch these events on the toplevel window level,
107 // as controls don't get the raw mouse events anymore
109 { kEventClassMouse
, kEventMouseDown
} ,
110 { kEventClassMouse
, kEventMouseUp
} ,
111 { kEventClassMouse
, kEventMouseWheelMoved
} ,
112 { kEventClassMouse
, kEventMouseMoved
} ,
113 { kEventClassMouse
, kEventMouseDragged
} ,
116 static pascal OSStatus
KeyboardEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
118 OSStatus result
= eventNotHandledErr
;
119 // call DoFindFocus instead of FindFocus, because for Composite Windows(like WxGenericListCtrl)
120 // FindFocus does not return the actual focus window, but the enclosing window
121 wxWindow
* focus
= wxWindow::DoFindFocus();
123 focus
= (wxTopLevelWindowMac
*) data
;
125 unsigned char charCode
;
133 UInt32 when
= EventTimeToTicks( GetEventTime( event
) ) ;
136 ByteCount dataSize
= 0 ;
137 if ( GetEventParameter( event
, kEventParamKeyUnicodes
, typeUnicodeText
, NULL
, 0 , &dataSize
, NULL
) == noErr
)
140 int numChars
= dataSize
/ sizeof( UniChar
) + 1;
142 UniChar
* charBuf
= buf
;
144 if ( numChars
* 2 > 4 )
145 charBuf
= new UniChar
[ numChars
] ;
146 GetEventParameter( event
, kEventParamKeyUnicodes
, typeUnicodeText
, NULL
, dataSize
, NULL
, charBuf
) ;
147 charBuf
[ numChars
- 1 ] = 0;
149 #if SIZEOF_WCHAR_T == 2
150 uniChar
= charBuf
[0] ;
152 wxMBConvUTF16 converter
;
153 converter
.MB2WC( uniChar
, (const char*)charBuf
, 2 ) ;
156 if ( numChars
* 2 > 4 )
161 GetEventParameter( event
, kEventParamKeyMacCharCodes
, typeChar
, NULL
, sizeof(char), NULL
, &charCode
);
162 GetEventParameter( event
, kEventParamKeyCode
, typeUInt32
, NULL
, sizeof(UInt32
), NULL
, &keyCode
);
163 GetEventParameter( event
, kEventParamKeyModifiers
, typeUInt32
, NULL
, sizeof(UInt32
), NULL
, &modifiers
);
164 GetEventParameter( event
, kEventParamMouseLocation
, typeQDPoint
, NULL
, sizeof(Point
), NULL
, &point
);
166 UInt32 message
= (keyCode
<< 8) + charCode
;
167 switch ( GetEventKind( event
) )
169 case kEventRawKeyRepeat
:
170 case kEventRawKeyDown
:
172 WXEVENTREF formerEvent
= wxTheApp
->MacGetCurrentEvent() ;
173 WXEVENTHANDLERCALLREF formerHandler
= wxTheApp
->MacGetCurrentEventHandlerCallRef() ;
174 wxTheApp
->MacSetCurrentEvent( event
, handler
) ;
175 if ( /* focus && */ wxTheApp
->MacSendKeyDownEvent(
176 focus
, message
, modifiers
, when
, point
.h
, point
.v
, uniChar
[0] ) )
180 wxTheApp
->MacSetCurrentEvent( formerEvent
, formerHandler
) ;
184 case kEventRawKeyUp
:
185 if ( /* focus && */ wxTheApp
->MacSendKeyUpEvent(
186 focus
, message
, modifiers
, when
, point
.h
, point
.v
, uniChar
[0] ) )
192 case kEventRawKeyModifiersChanged
:
194 wxKeyEvent
event(wxEVT_KEY_DOWN
);
196 event
.m_shiftDown
= modifiers
& shiftKey
;
197 event
.m_controlDown
= modifiers
& controlKey
;
198 event
.m_altDown
= modifiers
& optionKey
;
199 event
.m_metaDown
= modifiers
& cmdKey
;
204 event
.m_uniChar
= uniChar
[0] ;
207 event
.SetTimestamp(when
);
208 event
.SetEventObject(focus
);
210 if ( /* focus && */ (modifiers
^ wxApp::s_lastModifiers
) & controlKey
)
212 event
.m_keyCode
= WXK_CONTROL
;
213 event
.SetEventType( ( modifiers
& controlKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
214 focus
->GetEventHandler()->ProcessEvent( event
) ;
216 if ( /* focus && */ (modifiers
^ wxApp::s_lastModifiers
) & shiftKey
)
218 event
.m_keyCode
= WXK_SHIFT
;
219 event
.SetEventType( ( modifiers
& shiftKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
220 focus
->GetEventHandler()->ProcessEvent( event
) ;
222 if ( /* focus && */ (modifiers
^ wxApp::s_lastModifiers
) & optionKey
)
224 event
.m_keyCode
= WXK_ALT
;
225 event
.SetEventType( ( modifiers
& optionKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
226 focus
->GetEventHandler()->ProcessEvent( event
) ;
228 if ( /* focus && */ (modifiers
^ wxApp::s_lastModifiers
) & cmdKey
)
230 event
.m_keyCode
= WXK_COMMAND
;
231 event
.SetEventType( ( modifiers
& cmdKey
) ? wxEVT_KEY_DOWN
: wxEVT_KEY_UP
) ;
232 focus
->GetEventHandler()->ProcessEvent( event
) ;
235 wxApp::s_lastModifiers
= modifiers
;
246 // we don't interfere with foreign controls on our toplevel windows, therefore we always give back eventNotHandledErr
247 // for windows that we didn't create (like eg Scrollbars in a databrowser), or for controls where we did not handle the
250 // This handler can also be called from app level where data (ie target window) may be null or a non wx window
252 wxWindow
* g_MacLastWindow
= NULL
;
254 EventMouseButton g_lastButton
= 0 ;
255 bool g_lastButtonWasFakeRight
= false ;
257 void SetupMouseEvent( wxMouseEvent
&wxevent
, wxMacCarbonEvent
&cEvent
)
259 UInt32 modifiers
= cEvent
.GetParameter
<UInt32
>(kEventParamKeyModifiers
, typeUInt32
) ;
260 Point screenMouseLocation
= cEvent
.GetParameter
<Point
>(kEventParamMouseLocation
) ;
262 // these parameters are not given for all events
263 EventMouseButton button
= 0 ;
264 UInt32 clickCount
= 0 ;
265 UInt32 mouseChord
= 0;
267 cEvent
.GetParameter
<EventMouseButton
>( kEventParamMouseButton
, typeMouseButton
, &button
) ;
268 cEvent
.GetParameter
<UInt32
>( kEventParamClickCount
, typeUInt32
, &clickCount
) ;
269 // the chord is the state of the buttons pressed currently
270 cEvent
.GetParameter
<UInt32
>( kEventParamMouseChord
, typeUInt32
, &mouseChord
) ;
272 wxevent
.m_x
= screenMouseLocation
.h
;
273 wxevent
.m_y
= screenMouseLocation
.v
;
274 wxevent
.m_shiftDown
= modifiers
& shiftKey
;
275 wxevent
.m_controlDown
= modifiers
& controlKey
;
276 wxevent
.m_altDown
= modifiers
& optionKey
;
277 wxevent
.m_metaDown
= modifiers
& cmdKey
;
278 wxevent
.m_clickCount
= clickCount
;
279 wxevent
.SetTimestamp( cEvent
.GetTicks() ) ;
281 // a control click is interpreted as a right click
282 bool thisButtonIsFakeRight
= false ;
283 if ( button
== kEventMouseButtonPrimary
&& (modifiers
& controlKey
) )
285 button
= kEventMouseButtonSecondary
;
286 thisButtonIsFakeRight
= true ;
289 // otherwise we report double clicks by connecting a left click with a ctrl-left click
290 if ( clickCount
> 1 && button
!= g_lastButton
)
293 // we must make sure that our synthetic 'right' button corresponds in
294 // mouse down, moved and mouse up, and does not deliver a right down and left up
296 if ( cEvent
.GetKind() == kEventMouseDown
)
298 g_lastButton
= button
;
299 g_lastButtonWasFakeRight
= thisButtonIsFakeRight
;
305 g_lastButtonWasFakeRight
= false ;
307 else if ( g_lastButton
== kEventMouseButtonSecondary
&& g_lastButtonWasFakeRight
)
308 button
= g_lastButton
;
310 // Adjust the chord mask to remove the primary button and add the
311 // secondary button. It is possible that the secondary button is
312 // already pressed, e.g. on a mouse connected to a laptop, but this
313 // possibility is ignored here:
314 if( thisButtonIsFakeRight
&& ( mouseChord
& 1U ) )
315 mouseChord
= ((mouseChord
& ~1U) | 2U);
318 wxevent
.m_leftDown
= true ;
320 wxevent
.m_rightDown
= true ;
322 wxevent
.m_middleDown
= true ;
324 // translate into wx types
325 switch ( cEvent
.GetKind() )
327 case kEventMouseDown
:
330 case kEventMouseButtonPrimary
:
331 wxevent
.SetEventType( clickCount
> 1 ? wxEVT_LEFT_DCLICK
: wxEVT_LEFT_DOWN
) ;
334 case kEventMouseButtonSecondary
:
335 wxevent
.SetEventType( clickCount
> 1 ? wxEVT_RIGHT_DCLICK
: wxEVT_RIGHT_DOWN
) ;
338 case kEventMouseButtonTertiary
:
339 wxevent
.SetEventType( clickCount
> 1 ? wxEVT_MIDDLE_DCLICK
: wxEVT_MIDDLE_DOWN
) ;
350 case kEventMouseButtonPrimary
:
351 wxevent
.SetEventType( wxEVT_LEFT_UP
) ;
354 case kEventMouseButtonSecondary
:
355 wxevent
.SetEventType( wxEVT_RIGHT_UP
) ;
358 case kEventMouseButtonTertiary
:
359 wxevent
.SetEventType( wxEVT_MIDDLE_UP
) ;
367 case kEventMouseWheelMoved
:
369 wxevent
.SetEventType( wxEVT_MOUSEWHEEL
) ;
371 EventMouseWheelAxis axis
= cEvent
.GetParameter
<EventMouseWheelAxis
>(kEventParamMouseWheelAxis
, typeMouseWheelAxis
) ;
372 SInt32 delta
= cEvent
.GetParameter
<SInt32
>(kEventParamMouseWheelDelta
, typeSInt32
) ;
374 wxevent
.m_wheelRotation
= delta
;
375 wxevent
.m_wheelDelta
= 1;
376 wxevent
.m_linesPerAction
= 1;
377 if ( axis
== kEventMouseWheelAxisX
)
378 wxevent
.m_wheelAxis
= 1;
382 case kEventMouseEntered
:
383 case kEventMouseExited
:
384 case kEventMouseDragged
:
385 case kEventMouseMoved
:
386 wxevent
.SetEventType( wxEVT_MOTION
) ;
393 ControlRef
wxMacFindSubControl( wxTopLevelWindowMac
* toplevelWindow
, const Point
& location
, ControlRef superControl
, ControlPartCode
*outPart
)
397 UInt16 childrenCount
= 0 ;
398 ControlHandle sibling
;
400 OSStatus err
= CountSubControls( superControl
, &childrenCount
) ;
401 if ( err
== errControlIsNotEmbedder
)
404 wxASSERT_MSG( err
== noErr
, wxT("Unexpected error when accessing subcontrols") ) ;
406 for ( UInt16 i
= childrenCount
; i
>=1 ; --i
)
408 err
= GetIndexedSubControl( superControl
, i
, & sibling
) ;
409 if ( err
== errControlIsNotEmbedder
)
412 wxASSERT_MSG( err
== noErr
, wxT("Unexpected error when accessing subcontrols") ) ;
413 if ( IsControlVisible( sibling
) )
415 UMAGetControlBoundsInWindowCoords( sibling
, &r
) ;
416 if ( MacPtInRect( location
, &r
) )
418 ControlHandle child
= wxMacFindSubControl( toplevelWindow
, location
, sibling
, outPart
) ;
425 Point testLocation
= location
;
427 if ( toplevelWindow
)
429 testLocation
.h
-= r
.left
;
430 testLocation
.v
-= r
.top
;
433 *outPart
= TestControl( sibling
, testLocation
) ;
446 #define NEW_CAPTURE_HANDLING 1
449 wxMacTopLevelMouseEventHandler(EventHandlerCallRef
WXUNUSED(handler
),
453 wxTopLevelWindowMac
* toplevelWindow
= (wxTopLevelWindowMac
*) data
;
455 OSStatus result
= eventNotHandledErr
;
457 wxMacCarbonEvent
cEvent( event
) ;
459 Point screenMouseLocation
= cEvent
.GetParameter
<Point
>(kEventParamMouseLocation
) ;
460 Point windowMouseLocation
= screenMouseLocation
;
462 WindowRef window
= NULL
;
463 short windowPart
= ::FindWindow(screenMouseLocation
, &window
);
465 wxWindow
* currentMouseWindow
= NULL
;
466 ControlRef control
= NULL
;
468 #if NEW_CAPTURE_HANDLING
469 if ( wxApp::s_captureWindow
)
471 window
= (WindowRef
) wxApp::s_captureWindow
->MacGetTopLevelWindowRef() ;
472 windowPart
= inContent
;
478 wxMacGlobalToLocal( window
, &windowMouseLocation
) ;
480 if ( wxApp::s_captureWindow
481 #if !NEW_CAPTURE_HANDLING
482 && wxApp::s_captureWindow
->MacGetTopLevelWindowRef() == (WXWindow
) window
&& windowPart
== inContent
486 currentMouseWindow
= wxApp::s_captureWindow
;
488 else if ( (IsWindowActive(window
) && windowPart
== inContent
) )
490 ControlPartCode part
;
491 control
= FindControlUnderMouse( windowMouseLocation
, window
, &part
) ;
492 // if there is no control below the mouse position, send the event to the toplevel window itself
495 currentMouseWindow
= (wxWindow
*) data
;
499 currentMouseWindow
= (wxWindow
*) wxFindControlFromMacControl( control
) ;
500 #ifndef __WXUNIVERSAL__
501 if ( currentMouseWindow
== NULL
&& cEvent
.GetKind() == kEventMouseMoved
)
504 // for wxToolBar to function we have to send certaint events to it
505 // instead of its children (wxToolBarTools)
507 GetSuperControl(control
, &parent
);
508 wxWindow
*wxParent
= (wxWindow
*) wxFindControlFromMacControl( parent
) ;
509 if ( wxParent
&& wxParent
->IsKindOf( CLASSINFO( wxToolBar
) ) )
510 currentMouseWindow
= wxParent
;
516 // disabled windows must not get any input messages
517 if ( currentMouseWindow
&& !currentMouseWindow
->MacIsReallyEnabled() )
518 currentMouseWindow
= NULL
;
522 wxMouseEvent
wxevent(wxEVT_LEFT_DOWN
);
523 SetupMouseEvent( wxevent
, cEvent
) ;
525 // handle all enter / leave events
527 if ( currentMouseWindow
!= g_MacLastWindow
)
529 if ( g_MacLastWindow
)
531 wxMouseEvent
eventleave(wxevent
);
532 eventleave
.SetEventType( wxEVT_LEAVE_WINDOW
);
533 g_MacLastWindow
->ScreenToClient( &eventleave
.m_x
, &eventleave
.m_y
);
534 eventleave
.SetEventObject( g_MacLastWindow
) ;
535 wxevent
.SetId( g_MacLastWindow
->GetId() ) ;
538 wxToolTip::RelayEvent( g_MacLastWindow
, eventleave
);
541 g_MacLastWindow
->GetEventHandler()->ProcessEvent(eventleave
);
544 if ( currentMouseWindow
)
546 wxMouseEvent
evententer(wxevent
);
547 evententer
.SetEventType( wxEVT_ENTER_WINDOW
);
548 currentMouseWindow
->ScreenToClient( &evententer
.m_x
, &evententer
.m_y
);
549 evententer
.SetEventObject( currentMouseWindow
) ;
550 wxevent
.SetId( currentMouseWindow
->GetId() ) ;
553 wxToolTip::RelayEvent( currentMouseWindow
, evententer
);
556 currentMouseWindow
->GetEventHandler()->ProcessEvent(evententer
);
559 g_MacLastWindow
= currentMouseWindow
;
562 if ( windowPart
== inMenuBar
)
564 // special case menu bar, as we are having a low-level runloop we must do it ourselves
565 if ( cEvent
.GetKind() == kEventMouseDown
)
567 ::MenuSelect( screenMouseLocation
) ;
572 else if ( currentMouseWindow
)
574 wxWindow
*currentMouseWindowParent
= currentMouseWindow
->GetParent();
576 currentMouseWindow
->ScreenToClient( &wxevent
.m_x
, &wxevent
.m_y
) ;
578 wxevent
.SetEventObject( currentMouseWindow
) ;
579 wxevent
.SetId( currentMouseWindow
->GetId() ) ;
581 // make tooltips current
584 if ( wxevent
.GetEventType() == wxEVT_MOTION
)
585 wxToolTip::RelayEvent( currentMouseWindow
, wxevent
);
588 if ( currentMouseWindow
->GetEventHandler()->ProcessEvent(wxevent
) )
590 if ((currentMouseWindowParent
!= NULL
) &&
591 (currentMouseWindowParent
->GetChildren().Find(currentMouseWindow
) == NULL
))
592 currentMouseWindow
= NULL
;
598 // if the user code did _not_ handle the event, then perform the
599 // default processing
600 if ( wxevent
.GetEventType() == wxEVT_LEFT_DOWN
)
602 // ... that is set focus to this window
603 if (currentMouseWindow
->CanAcceptFocus() && wxWindow::FindFocus()!=currentMouseWindow
)
604 currentMouseWindow
->SetFocus();
607 // if built-in find control is finding the wrong control (ie static box instead of overlaid
608 // button, we cannot let the standard handler do its job, but must handle manually
610 if ( cEvent
.GetKind() == kEventMouseDown
)
612 if ( currentMouseWindow
->MacIsReallyEnabled() )
614 EventModifiers modifiers
= cEvent
.GetParameter
<EventModifiers
>(kEventParamKeyModifiers
, typeUInt32
) ;
615 Point clickLocation
= windowMouseLocation
;
617 currentMouseWindow
->MacRootWindowToWindow( &clickLocation
.h
, &clickLocation
.v
) ;
619 HandleControlClick( (ControlRef
) currentMouseWindow
->GetHandle() , clickLocation
,
620 modifiers
, (ControlActionUPP
) -1 ) ;
622 if ((currentMouseWindowParent
!= NULL
) &&
623 (currentMouseWindowParent
->GetChildren().Find(currentMouseWindow
) == NULL
))
625 currentMouseWindow
= NULL
;
633 if ( cEvent
.GetKind() == kEventMouseUp
&& wxApp::s_captureWindow
)
635 wxApp::s_captureWindow
= NULL
;
641 wxWindow
* cursorTarget
= currentMouseWindow
;
642 wxPoint
cursorPoint( wxevent
.m_x
, wxevent
.m_y
) ;
644 while ( cursorTarget
&& !cursorTarget
->MacSetupCursor( cursorPoint
) )
646 cursorTarget
= cursorTarget
->GetParent() ;
648 cursorPoint
+= cursorTarget
->GetPosition();
652 else // currentMouseWindow == NULL
654 // don't mess with controls we don't know about
655 // for some reason returning eventNotHandledErr does not lead to the correct behaviour
656 // so we try sending them the correct control directly
657 if ( cEvent
.GetKind() == kEventMouseDown
&& toplevelWindow
&& control
)
659 EventModifiers modifiers
= cEvent
.GetParameter
<EventModifiers
>(kEventParamKeyModifiers
, typeUInt32
) ;
660 Point clickLocation
= windowMouseLocation
;
661 #if TARGET_API_MAC_OSX
663 hiPoint
.x
= clickLocation
.h
;
664 hiPoint
.y
= clickLocation
.v
;
665 HIViewConvertPoint( &hiPoint
, (ControlRef
) toplevelWindow
->GetHandle() , control
) ;
666 clickLocation
.h
= (int)hiPoint
.x
;
667 clickLocation
.v
= (int)hiPoint
.y
;
668 #endif // TARGET_API_MAC_OSX
670 HandleControlClick( control
, clickLocation
, modifiers
, (ControlActionUPP
) -1 ) ;
678 static pascal OSStatus
679 wxMacTopLevelWindowEventHandler(EventHandlerCallRef
WXUNUSED(handler
),
683 OSStatus result
= eventNotHandledErr
;
685 wxMacCarbonEvent
cEvent( event
) ;
687 // WindowRef windowRef = cEvent.GetParameter<WindowRef>(kEventParamDirectObject) ;
688 wxTopLevelWindowMac
* toplevelWindow
= (wxTopLevelWindowMac
*) data
;
690 switch ( GetEventKind( event
) )
692 case kEventWindowActivated
:
694 toplevelWindow
->MacActivate( cEvent
.GetTicks() , true) ;
695 wxActivateEvent
wxevent(wxEVT_ACTIVATE
, true , toplevelWindow
->GetId());
696 wxevent
.SetTimestamp( cEvent
.GetTicks() ) ;
697 wxevent
.SetEventObject(toplevelWindow
);
698 toplevelWindow
->GetEventHandler()->ProcessEvent(wxevent
);
699 // we still sending an eventNotHandledErr in order to allow for default processing
703 case kEventWindowDeactivated
:
705 toplevelWindow
->MacActivate(cEvent
.GetTicks() , false) ;
706 wxActivateEvent
wxevent(wxEVT_ACTIVATE
, false , toplevelWindow
->GetId());
707 wxevent
.SetTimestamp( cEvent
.GetTicks() ) ;
708 wxevent
.SetEventObject(toplevelWindow
);
709 toplevelWindow
->GetEventHandler()->ProcessEvent(wxevent
);
710 // we still sending an eventNotHandledErr in order to allow for default processing
714 case kEventWindowShown
:
715 toplevelWindow
->Refresh() ;
719 case kEventWindowClose
:
720 toplevelWindow
->Close() ;
724 case kEventWindowBoundsChanged
:
726 UInt32 attributes
= cEvent
.GetParameter
<UInt32
>(kEventParamAttributes
, typeUInt32
) ;
727 Rect newRect
= cEvent
.GetParameter
<Rect
>(kEventParamCurrentBounds
) ;
728 wxRect
r( newRect
.left
, newRect
.top
, newRect
.right
- newRect
.left
, newRect
.bottom
- newRect
.top
) ;
729 if ( attributes
& kWindowBoundsChangeSizeChanged
)
731 #ifndef __WXUNIVERSAL__
732 // according to the other ports we handle this within the OS level
733 // resize event, not within a wxSizeEvent
734 wxFrame
*frame
= wxDynamicCast( toplevelWindow
, wxFrame
) ;
737 frame
->PositionBars();
740 wxSizeEvent
event( r
.GetSize() , toplevelWindow
->GetId() ) ;
741 event
.SetEventObject( toplevelWindow
) ;
743 toplevelWindow
->GetEventHandler()->ProcessEvent(event
) ;
744 toplevelWindow
->wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
747 if ( attributes
& kWindowBoundsChangeOriginChanged
)
749 wxMoveEvent
event( r
.GetLeftTop() , toplevelWindow
->GetId() ) ;
750 event
.SetEventObject( toplevelWindow
) ;
751 toplevelWindow
->GetEventHandler()->ProcessEvent(event
) ;
758 case kEventWindowBoundsChanging
:
760 UInt32 attributes
= cEvent
.GetParameter
<UInt32
>(kEventParamAttributes
,typeUInt32
) ;
761 Rect newRect
= cEvent
.GetParameter
<Rect
>(kEventParamCurrentBounds
) ;
763 if ( (attributes
& kWindowBoundsChangeSizeChanged
) || (attributes
& kWindowBoundsChangeOriginChanged
) )
765 // all (Mac) rects are in content area coordinates, all wxRects in structure coordinates
766 int left
, top
, right
, bottom
;
767 toplevelWindow
->MacGetContentAreaInset( left
, top
, right
, bottom
) ;
772 newRect
.right
- newRect
.left
+ left
+ right
,
773 newRect
.bottom
- newRect
.top
+ top
+ bottom
) ;
775 // this is a EVT_SIZING not a EVT_SIZE type !
776 wxSizeEvent
wxevent( r
, toplevelWindow
->GetId() ) ;
777 wxevent
.SetEventObject( toplevelWindow
) ;
779 if ( toplevelWindow
->GetEventHandler()->ProcessEvent(wxevent
) )
780 adjustR
= wxevent
.GetRect() ;
782 if ( toplevelWindow
->GetMaxWidth() != -1 && adjustR
.GetWidth() > toplevelWindow
->GetMaxWidth() )
783 adjustR
.SetWidth( toplevelWindow
->GetMaxWidth() ) ;
784 if ( toplevelWindow
->GetMaxHeight() != -1 && adjustR
.GetHeight() > toplevelWindow
->GetMaxHeight() )
785 adjustR
.SetHeight( toplevelWindow
->GetMaxHeight() ) ;
786 if ( toplevelWindow
->GetMinWidth() != -1 && adjustR
.GetWidth() < toplevelWindow
->GetMinWidth() )
787 adjustR
.SetWidth( toplevelWindow
->GetMinWidth() ) ;
788 if ( toplevelWindow
->GetMinHeight() != -1 && adjustR
.GetHeight() < toplevelWindow
->GetMinHeight() )
789 adjustR
.SetHeight( toplevelWindow
->GetMinHeight() ) ;
790 const Rect adjustedRect
= { adjustR
.y
+ top
, adjustR
.x
+ left
, adjustR
.y
+ adjustR
.height
- bottom
, adjustR
.x
+ adjustR
.width
- right
} ;
791 if ( !EqualRect( &newRect
, &adjustedRect
) )
792 cEvent
.SetParameter
<Rect
>( kEventParamCurrentBounds
, &adjustedRect
) ;
793 toplevelWindow
->wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
800 case kEventWindowGetRegion
:
802 if ( toplevelWindow
->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
804 WindowRegionCode windowRegionCode
;
806 // Fetch the region code that is being queried
807 GetEventParameter( event
,
808 kEventParamWindowRegionCode
,
809 typeWindowRegionCode
, NULL
,
810 sizeof windowRegionCode
, NULL
,
811 &windowRegionCode
) ;
813 // If it is the opaque region code then set the
814 // region to empty and return noErr to stop event
816 if ( windowRegionCode
== kWindowOpaqueRgn
) {
818 GetEventParameter( event
,
819 kEventParamRgnHandle
,
820 typeQDRgnHandle
, NULL
,
823 SetEmptyRgn(region
) ;
837 // mix this in from window.cpp
838 pascal OSStatus
wxMacUnicodeTextEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
) ;
840 pascal OSStatus
wxMacTopLevelEventHandler( EventHandlerCallRef handler
, EventRef event
, void *data
)
842 OSStatus result
= eventNotHandledErr
;
844 switch ( GetEventClass( event
) )
846 case kEventClassTextInput
:
847 result
= wxMacUnicodeTextEventHandler( handler
, event
, data
) ;
850 case kEventClassKeyboard
:
851 result
= KeyboardEventHandler( handler
, event
, data
) ;
854 case kEventClassWindow
:
855 result
= wxMacTopLevelWindowEventHandler( handler
, event
, data
) ;
858 case kEventClassMouse
:
859 result
= wxMacTopLevelMouseEventHandler( handler
, event
, data
) ;
869 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacTopLevelEventHandler
)
871 // ---------------------------------------------------------------------------
872 // wxWindowMac utility functions
873 // ---------------------------------------------------------------------------
875 // Find an item given the Macintosh Window Reference
877 WX_DECLARE_HASH_MAP(WindowRef
, wxTopLevelWindowMac
*, wxPointerHash
, wxPointerEqual
, MacWindowMap
);
879 static MacWindowMap wxWinMacWindowList
;
881 wxTopLevelWindowMac
*wxFindWinFromMacWindow(WindowRef inWindowRef
)
883 MacWindowMap::iterator node
= wxWinMacWindowList
.find(inWindowRef
);
885 return (node
== wxWinMacWindowList
.end()) ? NULL
: node
->second
;
888 void wxAssociateWinWithMacWindow(WindowRef inWindowRef
, wxTopLevelWindowMac
*win
) ;
889 void wxAssociateWinWithMacWindow(WindowRef inWindowRef
, wxTopLevelWindowMac
*win
)
891 // adding NULL WindowRef is (first) surely a result of an error and
893 wxCHECK_RET( inWindowRef
!= (WindowRef
) NULL
, wxT("attempt to add a NULL WindowRef to window list") );
895 wxWinMacWindowList
[inWindowRef
] = win
;
898 void wxRemoveMacWindowAssociation(wxTopLevelWindowMac
*win
) ;
899 void wxRemoveMacWindowAssociation(wxTopLevelWindowMac
*win
)
901 MacWindowMap::iterator it
;
902 for ( it
= wxWinMacWindowList
.begin(); it
!= wxWinMacWindowList
.end(); ++it
)
904 if ( it
->second
== win
)
906 wxWinMacWindowList
.erase(it
);
912 // ----------------------------------------------------------------------------
913 // wxTopLevelWindowMac creation
914 // ----------------------------------------------------------------------------
916 wxTopLevelWindowMac
*wxTopLevelWindowMac::s_macDeactivateWindow
= NULL
;
922 bool m_wasResizable
;
925 void wxTopLevelWindowMac::Init()
928 m_maximizeOnShow
= false;
931 m_macEventHandler
= NULL
;
932 m_macFullScreenData
= NULL
;
935 wxMacDeferredWindowDeleter::wxMacDeferredWindowDeleter( WindowRef windowRef
)
937 m_macWindow
= windowRef
;
940 wxMacDeferredWindowDeleter::~wxMacDeferredWindowDeleter()
942 UMADisposeWindow( (WindowRef
) m_macWindow
) ;
945 bool wxTopLevelWindowMac::Create(wxWindow
*parent
,
947 const wxString
& title
,
951 const wxString
& name
)
956 m_windowStyle
= style
;
960 m_windowId
= id
== -1 ? NewControlId() : id
;
961 wxWindow::SetLabel( title
) ;
963 DoMacCreateRealWindow( parent
, title
, pos
, size
, style
, name
) ;
965 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
));
967 if (GetExtraStyle() & wxFRAME_EX_METAL
)
968 MacSetMetalAppearance(true);
970 wxTopLevelWindows
.Append(this);
973 parent
->AddChild(this);
978 wxTopLevelWindowMac::~wxTopLevelWindowMac()
983 wxToolTip::NotifyWindowDelete(m_macWindow
) ;
985 wxPendingDelete
.Append( new wxMacDeferredWindowDeleter( (WindowRef
) m_macWindow
) ) ;
988 if ( m_macEventHandler
)
990 ::RemoveEventHandler((EventHandlerRef
) m_macEventHandler
);
991 m_macEventHandler
= NULL
;
994 wxRemoveMacWindowAssociation( this ) ;
996 if ( wxModelessWindows
.Find(this) )
997 wxModelessWindows
.DeleteObject(this);
999 FullScreenData
*data
= (FullScreenData
*) m_macFullScreenData
;
1001 m_macFullScreenData
= NULL
;
1003 // avoid dangling refs
1004 if ( s_macDeactivateWindow
== this )
1005 s_macDeactivateWindow
= NULL
;
1009 // ----------------------------------------------------------------------------
1010 // wxTopLevelWindowMac maximize/minimize
1011 // ----------------------------------------------------------------------------
1013 void wxTopLevelWindowMac::Maximize(bool maximize
)
1015 Point idealSize
= { 0 , 0 } ;
1018 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1020 HIWindowGetAvailablePositioningBounds(kCGNullDirectDisplay
,kHICoordSpace72DPIGlobal
,
1022 idealSize
.h
= bounds
.size
.width
;
1023 idealSize
.v
= bounds
.size
.height
;
1026 GetAvailableWindowPositioningBounds(GetMainDevice(),&rect
) ;
1027 idealSize
.h
= rect
.right
- rect
.left
;
1028 idealSize
.v
= rect
.bottom
- rect
.top
;
1031 ZoomWindowIdeal( (WindowRef
)m_macWindow
, maximize
? inZoomOut
: inZoomIn
, &idealSize
) ;
1034 bool wxTopLevelWindowMac::IsMaximized() const
1036 return IsWindowInStandardState( (WindowRef
)m_macWindow
, NULL
, NULL
) ;
1039 void wxTopLevelWindowMac::Iconize(bool iconize
)
1041 if ( IsWindowCollapsable( (WindowRef
)m_macWindow
) )
1042 CollapseWindow( (WindowRef
)m_macWindow
, iconize
) ;
1045 bool wxTopLevelWindowMac::IsIconized() const
1047 return IsWindowCollapsed((WindowRef
)m_macWindow
) ;
1050 void wxTopLevelWindowMac::Restore()
1052 if ( IsMaximized() )
1054 else if ( IsIconized() )
1058 // ----------------------------------------------------------------------------
1059 // wxTopLevelWindowMac misc
1060 // ----------------------------------------------------------------------------
1062 wxPoint
wxTopLevelWindowMac::GetClientAreaOrigin() const
1064 return wxPoint(0, 0) ;
1067 void wxTopLevelWindowMac::MacSetBackgroundBrush( const wxBrush
&brush
)
1069 wxTopLevelWindowBase::MacSetBackgroundBrush( brush
) ;
1071 if ( m_macBackgroundBrush
.Ok() && m_macBackgroundBrush
.GetStyle() != wxTRANSPARENT
&& m_macBackgroundBrush
.MacGetBrushKind() == kwxMacBrushTheme
)
1073 SetThemeWindowBackground( (WindowRef
) m_macWindow
, m_macBackgroundBrush
.MacGetTheme() , false ) ;
1077 void wxTopLevelWindowMacInstallTopLevelWindowEventHandler(WindowRef window
, EventHandlerRef
* handler
, void *ref
)
1079 InstallWindowEventHandler(window
, GetwxMacTopLevelEventHandlerUPP(),
1080 GetEventTypeCount(eventList
), eventList
, ref
, handler
);
1083 void wxTopLevelWindowMac::MacInstallTopLevelWindowEventHandler()
1085 if ( m_macEventHandler
!= NULL
)
1087 verify_noerr( ::RemoveEventHandler( (EventHandlerRef
) m_macEventHandler
) ) ;
1089 wxTopLevelWindowMacInstallTopLevelWindowEventHandler(MAC_WXHWND(m_macWindow
),(EventHandlerRef
*)&m_macEventHandler
,this);
1092 void wxTopLevelWindowMac::MacCreateRealWindow(
1093 const wxString
& title
,
1097 const wxString
& name
)
1099 DoMacCreateRealWindow( NULL
, title
, pos
, size
, style
, name
);
1102 void wxTopLevelWindowMac::DoMacCreateRealWindow(
1104 const wxString
& title
,
1108 const wxString
& name
)
1110 OSStatus err
= noErr
;
1112 m_windowStyle
= style
;
1120 wxRect display
= wxGetClientDisplayRect() ;
1122 if ( x
== wxDefaultPosition
.x
)
1125 if ( y
== wxDefaultPosition
.y
)
1128 int w
= WidthDefault(size
.x
);
1129 int h
= HeightDefault(size
.y
);
1131 ::SetRect(&theBoundsRect
, x
, y
, x
+ w
, y
+ h
);
1133 // translate the window attributes in the appropriate window class and attributes
1134 WindowClass wclass
= 0;
1135 WindowAttributes attr
= kWindowNoAttributes
;
1136 WindowGroupRef group
= NULL
;
1137 bool activationScopeSet
= false;
1138 WindowActivationScope activationScope
= kWindowActivationScopeNone
;
1140 if ( HasFlag( wxFRAME_TOOL_WINDOW
) )
1143 HasFlag( wxMINIMIZE_BOX
) || HasFlag( wxMAXIMIZE_BOX
) ||
1144 HasFlag( wxSYSTEM_MENU
) || HasFlag( wxCAPTION
) ||
1145 HasFlag(wxTINY_CAPTION_HORIZ
) || HasFlag(wxTINY_CAPTION_VERT
)
1148 if ( HasFlag( wxSTAY_ON_TOP
) )
1149 wclass
= kUtilityWindowClass
;
1151 wclass
= kFloatingWindowClass
;
1153 if ( HasFlag(wxTINY_CAPTION_VERT
) )
1154 attr
|= kWindowSideTitlebarAttribute
;
1158 wclass
= kPlainWindowClass
;
1159 activationScopeSet
= true;
1160 activationScope
= kWindowActivationScopeNone
;
1163 else if ( HasFlag( wxPOPUP_WINDOW
) )
1166 // Until we've got a real wxPopupWindow class on wxMac make it a
1167 // little easier for wxFrame to be used to emulate it and workaround
1168 // the lack of wxPopupWindow.
1169 if ( HasFlag( wxBORDER_NONE
) )
1170 wclass
= kHelpWindowClass
; // has no border
1172 wclass
= kPlainWindowClass
; // has a single line border, it will have to do for now
1173 //attr |= kWindowNoShadowAttribute; // turn off the shadow Should we??
1174 group
= GetWindowGroupOfClass( // float above other windows
1175 kFloatingWindowClass
) ;
1177 else if ( HasFlag( wxCAPTION
) )
1179 wclass
= kDocumentWindowClass
;
1180 attr
|= kWindowInWindowMenuAttribute
;
1182 else if ( HasFlag( wxFRAME_DRAWER
) )
1184 wclass
= kDrawerWindowClass
;
1188 if ( HasFlag( wxMINIMIZE_BOX
) || HasFlag( wxMAXIMIZE_BOX
) ||
1189 HasFlag( wxCLOSE_BOX
) || HasFlag( wxSYSTEM_MENU
) )
1191 wclass
= kDocumentWindowClass
;
1193 else if ( HasFlag( wxNO_BORDER
) )
1195 wclass
= kSimpleWindowClass
;
1199 wclass
= kPlainWindowClass
;
1203 if ( wclass
!= kPlainWindowClass
)
1205 if ( HasFlag( wxMINIMIZE_BOX
) )
1206 attr
|= kWindowCollapseBoxAttribute
;
1208 if ( HasFlag( wxMAXIMIZE_BOX
) )
1209 attr
|= kWindowFullZoomAttribute
;
1211 if ( HasFlag( wxRESIZE_BORDER
) )
1212 attr
|= kWindowResizableAttribute
;
1214 if ( HasFlag( wxCLOSE_BOX
) )
1215 attr
|= kWindowCloseBoxAttribute
;
1217 attr
|= kWindowLiveResizeAttribute
;
1219 if ( HasFlag(wxSTAY_ON_TOP
) )
1220 group
= GetWindowGroupOfClass(kUtilityWindowClass
) ;
1222 if ( HasFlag( wxFRAME_FLOAT_ON_PARENT
) )
1223 group
= GetWindowGroupOfClass(kFloatingWindowClass
) ;
1225 if ( group
== NULL
&& parent
!= NULL
)
1227 WindowRef parenttlw
= (WindowRef
) parent
->MacGetTopLevelWindowRef();
1229 group
= GetWindowGroupParent( GetWindowGroup( parenttlw
) );
1232 attr
|= kWindowCompositingAttribute
;
1233 #if 0 // wxMAC_USE_CORE_GRAPHICS ; TODO : decide on overall handling of high dpi screens (pixel vs userscale)
1234 attr
|= kWindowFrameworkScaledAttribute
;
1237 if ( HasFlag(wxFRAME_SHAPED
) )
1239 WindowDefSpec customWindowDefSpec
;
1240 customWindowDefSpec
.defType
= kWindowDefProcPtr
;
1241 customWindowDefSpec
.u
.defProc
=
1243 (WindowDefUPP
) wxShapedMacWindowDef
;
1245 NewWindowDefUPP(wxShapedMacWindowDef
);
1247 err
= ::CreateCustomWindow( &customWindowDefSpec
, wclass
,
1248 attr
, &theBoundsRect
,
1249 (WindowRef
*) &m_macWindow
);
1253 err
= ::CreateNewWindow( wclass
, attr
, &theBoundsRect
, (WindowRef
*)&m_macWindow
) ;
1256 if ( err
== noErr
&& m_macWindow
!= NULL
&& group
!= NULL
)
1257 SetWindowGroup( (WindowRef
) m_macWindow
, group
) ;
1259 wxCHECK_RET( err
== noErr
, wxT("Mac OS error when trying to create new window") );
1261 // setup a separate group for each window, so that overlays can be handled easily
1263 WindowGroupRef overlaygroup
= NULL
;
1264 verify_noerr( CreateWindowGroup( kWindowGroupAttrMoveTogether
| kWindowGroupAttrLayerTogether
| kWindowGroupAttrHideOnCollapse
, &overlaygroup
));
1265 verify_noerr( SetWindowGroupParent( overlaygroup
, GetWindowGroup( (WindowRef
) m_macWindow
)));
1266 verify_noerr( SetWindowGroup( (WindowRef
) m_macWindow
, overlaygroup
));
1268 if ( activationScopeSet
)
1270 verify_noerr( SetWindowActivationScope( (WindowRef
) m_macWindow
, activationScope
));
1273 // the create commands are only for content rect,
1274 // so we have to set the size again as structure bounds
1275 SetWindowBounds( (WindowRef
) m_macWindow
, kWindowStructureRgn
, &theBoundsRect
) ;
1277 wxAssociateWinWithMacWindow( (WindowRef
) m_macWindow
, this ) ;
1278 UMASetWTitle( (WindowRef
) m_macWindow
, title
, m_font
.GetEncoding() ) ;
1279 m_peer
= new wxMacControl(this , true /*isRootControl*/) ;
1281 // There is a bug in 10.2.X for ::GetRootControl returning the window view instead of
1282 // the content view, so we have to retrieve it explicitly
1283 HIViewFindByID( HIViewGetRoot( (WindowRef
) m_macWindow
) , kHIViewWindowContentID
,
1284 m_peer
->GetControlRefAddr() ) ;
1285 if ( !m_peer
->Ok() )
1287 // compatibility mode fallback
1288 GetRootControl( (WindowRef
) m_macWindow
, m_peer
->GetControlRefAddr() ) ;
1291 // the root control level handler
1292 MacInstallEventHandler( (WXWidget
) m_peer
->GetControlRef() ) ;
1294 // Causes the inner part of the window not to be metal
1295 // if the style is used before window creation.
1296 #if 0 // TARGET_API_MAC_OSX
1297 if ( m_macUsesCompositing
&& m_macWindow
!= NULL
)
1299 if ( GetExtraStyle() & wxFRAME_EX_METAL
)
1300 MacSetMetalAppearance( true ) ;
1304 #if TARGET_API_MAC_OSX
1305 if ( m_macWindow
!= NULL
)
1307 MacSetUnifiedAppearance( true ) ;
1311 HIViewRef growBoxRef
= 0 ;
1312 err
= HIViewFindByID( HIViewGetRoot( (WindowRef
)m_macWindow
), kHIViewWindowGrowBoxID
, &growBoxRef
);
1313 if ( err
== noErr
&& growBoxRef
!= 0 )
1314 HIGrowBoxViewSetTransparent( growBoxRef
, true ) ;
1316 // the frame window event handler
1317 InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow
)) ) ;
1318 MacInstallTopLevelWindowEventHandler() ;
1320 DoSetWindowVariant( m_windowVariant
) ;
1324 if ( HasFlag(wxFRAME_SHAPED
) )
1326 // default shape matches the window size
1327 wxRegion
rgn( 0, 0, w
, h
);
1331 wxWindowCreateEvent
event(this);
1332 GetEventHandler()->ProcessEvent(event
);
1335 void wxTopLevelWindowMac::ClearBackground()
1337 wxWindow::ClearBackground() ;
1340 // Raise the window to the top of the Z order
1341 void wxTopLevelWindowMac::Raise()
1343 ::SelectWindow( (WindowRef
)m_macWindow
) ;
1346 // Lower the window to the bottom of the Z order
1347 void wxTopLevelWindowMac::Lower()
1349 ::SendBehind( (WindowRef
)m_macWindow
, NULL
) ;
1352 void wxTopLevelWindowMac::MacDelayedDeactivation(long timestamp
)
1354 if (s_macDeactivateWindow
)
1356 wxLogTrace(TRACE_ACTIVATE
,
1357 wxT("Doing delayed deactivation of %p"),
1358 s_macDeactivateWindow
);
1360 s_macDeactivateWindow
->MacActivate(timestamp
, false);
1364 void wxTopLevelWindowMac::MacActivate( long timestamp
, bool WXUNUSED(inIsActivating
) )
1366 wxLogTrace(TRACE_ACTIVATE
, wxT("TopLevel=%p::MacActivate"), this);
1368 if (s_macDeactivateWindow
== this)
1369 s_macDeactivateWindow
= NULL
;
1371 MacDelayedDeactivation(timestamp
);
1372 MacPropagateHiliteChanged() ;
1375 void wxTopLevelWindowMac::SetTitle(const wxString
& title
)
1377 wxWindow::SetLabel( title
) ;
1378 UMASetWTitle( (WindowRef
)m_macWindow
, title
, m_font
.GetEncoding() ) ;
1381 wxString
wxTopLevelWindowMac::GetTitle() const
1383 return wxWindow::GetLabel();
1386 bool wxTopLevelWindowMac::Show(bool show
)
1388 if ( !wxTopLevelWindowBase::Show(show
) )
1391 bool plainTransition
= true;
1393 #if wxUSE_SYSTEM_OPTIONS
1394 if ( wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION
) )
1395 plainTransition
= ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION
) == 1 ) ;
1400 if ( plainTransition
)
1401 ::ShowWindow( (WindowRef
)m_macWindow
);
1403 ::TransitionWindow( (WindowRef
)m_macWindow
, kWindowZoomTransitionEffect
, kWindowShowTransitionAction
, NULL
);
1405 ::SelectWindow( (WindowRef
)m_macWindow
) ;
1407 // because apps expect a size event to occur at this moment
1408 wxSizeEvent
event(GetSize() , m_windowId
);
1409 event
.SetEventObject(this);
1410 GetEventHandler()->ProcessEvent(event
);
1414 if ( plainTransition
)
1415 ::HideWindow( (WindowRef
)m_macWindow
);
1417 ::TransitionWindow( (WindowRef
)m_macWindow
, kWindowZoomTransitionEffect
, kWindowHideTransitionAction
, NULL
);
1420 MacPropagateVisibilityChanged() ;
1425 bool wxTopLevelWindowMac::ShowFullScreen(bool show
, long style
)
1429 FullScreenData
*data
= (FullScreenData
*)m_macFullScreenData
;
1431 data
= new FullScreenData() ;
1433 m_macFullScreenData
= data
;
1434 data
->m_position
= GetPosition() ;
1435 data
->m_size
= GetSize() ;
1436 data
->m_wasResizable
= MacGetWindowAttributes() & kWindowResizableAttribute
;
1438 if ( style
& wxFULLSCREEN_NOMENUBAR
)
1441 wxRect client
= wxGetClientDisplayRect() ;
1443 int left
, top
, right
, bottom
;
1451 MacGetContentAreaInset( left
, top
, right
, bottom
) ;
1453 if ( style
& wxFULLSCREEN_NOCAPTION
)
1459 if ( style
& wxFULLSCREEN_NOBORDER
)
1466 if ( style
& wxFULLSCREEN_NOTOOLBAR
)
1471 if ( style
& wxFULLSCREEN_NOSTATUSBAR
)
1476 SetSize( x
, y
, w
, h
) ;
1477 if ( data
->m_wasResizable
)
1478 MacChangeWindowAttributes( kWindowNoAttributes
, kWindowResizableAttribute
) ;
1483 FullScreenData
*data
= (FullScreenData
*) m_macFullScreenData
;
1484 if ( data
->m_wasResizable
)
1485 MacChangeWindowAttributes( kWindowResizableAttribute
, kWindowNoAttributes
) ;
1486 SetPosition( data
->m_position
) ;
1487 SetSize( data
->m_size
) ;
1490 m_macFullScreenData
= NULL
;
1496 bool wxTopLevelWindowMac::IsFullScreen() const
1498 return m_macFullScreenData
!= NULL
;
1502 bool wxTopLevelWindowMac::SetTransparent(wxByte alpha
)
1504 OSStatus result
= SetWindowAlpha((WindowRef
)m_macWindow
, float(alpha
)/255.0);
1505 return result
== noErr
;
1509 bool wxTopLevelWindowMac::CanSetTransparent()
1515 void wxTopLevelWindowMac::SetExtraStyle(long exStyle
)
1517 if ( GetExtraStyle() == exStyle
)
1520 wxTopLevelWindowBase::SetExtraStyle( exStyle
) ;
1522 #if TARGET_API_MAC_OSX
1523 if ( m_macWindow
!= NULL
)
1525 bool metal
= GetExtraStyle() & wxFRAME_EX_METAL
;
1527 if ( MacGetMetalAppearance() != metal
)
1529 if ( MacGetUnifiedAppearance() )
1530 MacSetUnifiedAppearance( !metal
) ;
1532 MacSetMetalAppearance( metal
) ;
1538 bool wxTopLevelWindowMac::SetBackgroundStyle(wxBackgroundStyle style
)
1540 if ( !wxTopLevelWindowBase::SetBackgroundStyle(style
) )
1543 WindowRef windowRef
= HIViewGetWindow( (HIViewRef
)GetHandle() );
1545 if ( GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT
)
1547 OSStatus err
= HIWindowChangeFeatures( windowRef
, 0, kWindowIsOpaque
);
1548 verify_noerr( err
);
1549 err
= ReshapeCustomWindow( windowRef
);
1550 verify_noerr( err
);
1556 // TODO: switch to structure bounds -
1557 // we are still using coordinates of the content view
1559 void wxTopLevelWindowMac::MacGetContentAreaInset( int &left
, int &top
, int &right
, int &bottom
)
1561 Rect content
, structure
;
1563 GetWindowBounds( (WindowRef
) m_macWindow
, kWindowStructureRgn
, &structure
) ;
1564 GetWindowBounds( (WindowRef
) m_macWindow
, kWindowContentRgn
, &content
) ;
1566 left
= content
.left
- structure
.left
;
1567 top
= content
.top
- structure
.top
;
1568 right
= structure
.right
- content
.right
;
1569 bottom
= structure
.bottom
- content
.bottom
;
1572 void wxTopLevelWindowMac::DoMoveWindow(int x
, int y
, int width
, int height
)
1574 m_cachedClippedRectValid
= false ;
1575 Rect bounds
= { y
, x
, y
+ height
, x
+ width
} ;
1576 verify_noerr(SetWindowBounds( (WindowRef
) m_macWindow
, kWindowStructureRgn
, &bounds
)) ;
1577 wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
1580 void wxTopLevelWindowMac::DoGetPosition( int *x
, int *y
) const
1584 verify_noerr(GetWindowBounds((WindowRef
) m_macWindow
, kWindowStructureRgn
, &bounds
)) ;
1592 void wxTopLevelWindowMac::DoGetSize( int *width
, int *height
) const
1596 verify_noerr(GetWindowBounds((WindowRef
) m_macWindow
, kWindowStructureRgn
, &bounds
)) ;
1599 *width
= bounds
.right
- bounds
.left
;
1601 *height
= bounds
.bottom
- bounds
.top
;
1604 void wxTopLevelWindowMac::DoGetClientSize( int *width
, int *height
) const
1608 verify_noerr(GetWindowBounds((WindowRef
) m_macWindow
, kWindowContentRgn
, &bounds
)) ;
1611 *width
= bounds
.right
- bounds
.left
;
1613 *height
= bounds
.bottom
- bounds
.top
;
1616 void wxTopLevelWindowMac::DoCentre(int dir
)
1618 if ( m_macWindow
!= 0 )
1619 wxTopLevelWindowBase::DoCentre(dir
);
1622 void wxTopLevelWindowMac::MacSetMetalAppearance( bool set
)
1624 #if TARGET_API_MAC_OSX
1625 if ( MacGetUnifiedAppearance() )
1626 MacSetUnifiedAppearance( false ) ;
1628 MacChangeWindowAttributes( set
? kWindowMetalAttribute
: kWindowNoAttributes
,
1629 set
? kWindowNoAttributes
: kWindowMetalAttribute
) ;
1633 bool wxTopLevelWindowMac::MacGetMetalAppearance() const
1635 #if TARGET_API_MAC_OSX
1636 return MacGetWindowAttributes() & kWindowMetalAttribute
;
1642 void wxTopLevelWindowMac::MacSetUnifiedAppearance( bool set
)
1644 #if TARGET_API_MAC_OSX
1645 if ( UMAGetSystemVersion() >= 0x1040 )
1647 if ( MacGetMetalAppearance() )
1648 MacSetMetalAppearance( false ) ;
1650 MacChangeWindowAttributes( set
? kWindowUnifiedTitleAndToolbarAttribute
: kWindowNoAttributes
,
1651 set
? kWindowNoAttributes
: kWindowUnifiedTitleAndToolbarAttribute
) ;
1653 // For some reason, Tiger uses white as the background color for this appearance,
1654 // while most apps using it use the typical striped background. Restore that behavior
1656 // TODO: Determine if we need this on Leopard as well. (should be harmless either way,
1658 SetBackgroundColour( wxSYS_COLOUR_WINDOW
) ;
1663 bool wxTopLevelWindowMac::MacGetUnifiedAppearance() const
1665 #if TARGET_API_MAC_OSX
1666 if ( UMAGetSystemVersion() >= 0x1040 )
1667 return MacGetWindowAttributes() & kWindowUnifiedTitleAndToolbarAttribute
;
1673 void wxTopLevelWindowMac::MacChangeWindowAttributes( wxUint32 attributesToSet
, wxUint32 attributesToClear
)
1675 ChangeWindowAttributes( (WindowRef
)m_macWindow
, attributesToSet
, attributesToClear
) ;
1678 wxUint32
wxTopLevelWindowMac::MacGetWindowAttributes() const
1681 GetWindowAttributes( (WindowRef
) m_macWindow
, &attr
) ;
1686 void wxTopLevelWindowMac::MacPerformUpdates()
1688 // for composited windows this also triggers a redraw of all
1689 // invalid views in the window
1690 HIWindowFlush((WindowRef
) m_macWindow
) ;
1693 // Attracts the users attention to this window if the application is
1694 // inactive (should be called when a background event occurs)
1696 static pascal void wxMacNMResponse( NMRecPtr ptr
)
1699 DisposePtr( (Ptr
)ptr
) ;
1702 void wxTopLevelWindowMac::RequestUserAttention(int WXUNUSED(flags
))
1704 NMRecPtr notificationRequest
= (NMRecPtr
) NewPtr( sizeof( NMRec
) ) ;
1705 static wxMacNMUPP
nmupp( wxMacNMResponse
);
1707 memset( notificationRequest
, 0 , sizeof(*notificationRequest
) ) ;
1708 notificationRequest
->qType
= nmType
;
1709 notificationRequest
->nmMark
= 1 ;
1710 notificationRequest
->nmIcon
= 0 ;
1711 notificationRequest
->nmSound
= 0 ;
1712 notificationRequest
->nmStr
= NULL
;
1713 notificationRequest
->nmResp
= nmupp
;
1715 verify_noerr( NMInstall( notificationRequest
) ) ;
1718 // ---------------------------------------------------------------------------
1719 // Shape implementation
1720 // ---------------------------------------------------------------------------
1723 bool wxTopLevelWindowMac::SetShape(const wxRegion
& region
)
1725 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1726 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1728 // The empty region signifies that the shape
1729 // should be removed from the window.
1730 if ( region
.IsEmpty() )
1732 wxSize sz
= GetClientSize();
1733 wxRegion
rgn(0, 0, sz
.x
, sz
.y
);
1734 if ( rgn
.IsEmpty() )
1737 return SetShape(rgn
);
1740 // Make a copy of the region
1741 RgnHandle shapeRegion
= NewRgn();
1742 CopyRgn( (RgnHandle
)region
.GetWXHRGN(), shapeRegion
);
1744 // Dispose of any shape region we may already have
1745 RgnHandle oldRgn
= (RgnHandle
)GetWRefCon( (WindowRef
)MacGetWindowRef() );
1749 // Save the region so we can use it later
1750 SetWRefCon((WindowRef
)MacGetWindowRef(), (URefCon
)shapeRegion
);
1752 // inform the window manager that the window has changed shape
1753 ReshapeCustomWindow((WindowRef
)MacGetWindowRef());
1758 // ---------------------------------------------------------------------------
1759 // Support functions for shaped windows, based on Apple's CustomWindow sample at
1760 // http://developer.apple.com/samplecode/Sample_Code/Human_Interface_Toolbox/Mac_OS_High_Level_Toolbox/CustomWindow.htm
1761 // ---------------------------------------------------------------------------
1763 static void wxShapedMacWindowGetPos(WindowRef window
, Rect
* inRect
)
1765 GetWindowPortBounds(window
, inRect
);
1766 Point pt
= { inRect
->top
,inRect
->left
};
1767 wxMacLocalToGlobal( window
, &pt
) ;
1768 inRect
->bottom
+= pt
.v
- inRect
->top
;
1769 inRect
->right
+= pt
.h
- inRect
->left
;
1771 inRect
->left
= pt
.h
;
1774 static SInt32
wxShapedMacWindowGetFeatures(WindowRef
WXUNUSED(window
), SInt32 param
)
1776 /*------------------------------------------------------
1777 Define which options your custom window supports.
1778 --------------------------------------------------------*/
1779 //just enable everything for our demo
1780 *(OptionBits
*)param
=
1783 //kWindowCanCollapse |
1784 //kWindowCanGetWindowRegion |
1785 //kWindowHasTitleBar |
1786 //kWindowSupportsDragHilite |
1787 kWindowCanDrawInCurrentPort
|
1788 //kWindowCanMeasureTitle |
1789 kWindowWantsDisposeAtProcessDeath
|
1790 kWindowSupportsGetGrowImageRegion
|
1791 kWindowDefSupportsColorGrafPort
;
1796 // The content region is left as a rectangle matching the window size, this is
1797 // so the origin in the paint event, and etc. still matches what the
1798 // programmer expects.
1799 static void wxShapedMacWindowContentRegion(WindowRef window
, RgnHandle rgn
)
1802 wxTopLevelWindowMac
* win
= wxFindWinFromMacWindow(window
);
1806 wxShapedMacWindowGetPos( window
, &r
) ;
1807 RectRgn( rgn
, &r
) ;
1811 // The structure region is set to the shape given to the SetShape method.
1812 static void wxShapedMacWindowStructureRegion(WindowRef window
, RgnHandle rgn
)
1814 RgnHandle cachedRegion
= (RgnHandle
) GetWRefCon(window
);
1820 wxShapedMacWindowGetPos(window
, &windowRect
); // how big is the window
1821 CopyRgn(cachedRegion
, rgn
); // make a copy of our cached region
1822 OffsetRgn(rgn
, windowRect
.left
, windowRect
.top
); // position it over window
1823 //MapRgn(rgn, &mMaskSize, &windowRect); //scale it to our actual window size
1827 static SInt32
wxShapedMacWindowGetRegion(WindowRef window
, SInt32 param
)
1829 GetWindowRegionPtr rgnRec
= (GetWindowRegionPtr
)param
;
1834 switch (rgnRec
->regionCode
)
1836 case kWindowStructureRgn
:
1837 wxShapedMacWindowStructureRegion(window
, rgnRec
->winRgn
);
1840 case kWindowContentRgn
:
1841 wxShapedMacWindowContentRegion(window
, rgnRec
->winRgn
);
1845 SetEmptyRgn(rgnRec
->winRgn
);
1852 // Determine the region of the window which was hit
1854 static SInt32
wxShapedMacWindowHitTest(WindowRef window
, SInt32 param
)
1857 static RgnHandle tempRgn
= NULL
;
1859 if (tempRgn
== NULL
)
1862 // get the point clicked
1863 SetPt( &hitPoint
, LoWord(param
), HiWord(param
) );
1865 // Mac OS 8.5 or later
1866 wxShapedMacWindowStructureRegion(window
, tempRgn
);
1867 if (PtInRgn( hitPoint
, tempRgn
)) //in window content region?
1870 // no significant area was hit
1874 static pascal long wxShapedMacWindowDef(short WXUNUSED(varCode
), WindowRef window
, SInt16 message
, SInt32 param
)
1878 case kWindowMsgHitTest
:
1879 return wxShapedMacWindowHitTest(window
, param
);
1881 case kWindowMsgGetFeatures
:
1882 return wxShapedMacWindowGetFeatures(window
, param
);
1884 // kWindowMsgGetRegion is sent during CreateCustomWindow and ReshapeCustomWindow
1885 case kWindowMsgGetRegion
:
1886 return wxShapedMacWindowGetRegion(window
, param
);