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