]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/toplevel.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
added As/DissociateHandle() and implemented it for MSW (modified patch 972356)
[wxWidgets.git] / src / mac / carbon / toplevel.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: mac/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#ifdef __GNUG__
21 #pragma implementation "toplevel.h"
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
28 #pragma hdrstop
29#endif
30
31#ifndef WX_PRECOMP
32 #include "wx/app.h"
33 #include "wx/toplevel.h"
34 #include "wx/frame.h"
35 #include "wx/string.h"
36 #include "wx/log.h"
37 #include "wx/intl.h"
38 #include "wx/settings.h"
39#endif //WX_PRECOMP
40
41#include "wx/mac/uma.h"
42#include "wx/mac/aga.h"
43#include "wx/app.h"
44#include "wx/tooltip.h"
45#include "wx/dnd.h"
46#if wxUSE_SYSTEM_OPTIONS
47 #include "wx/sysopt.h"
48#endif
49
50#include <ToolUtils.h>
51
52// ----------------------------------------------------------------------------
53// globals
54// ----------------------------------------------------------------------------
55
56// list of all frames and modeless dialogs
57wxWindowList wxModelessWindows;
58
59static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param);
60
61// ============================================================================
62// wxTopLevelWindowMac implementation
63// ============================================================================
64
65BEGIN_EVENT_TABLE(wxTopLevelWindowMac, wxTopLevelWindowBase)
66END_EVENT_TABLE()
67
68
69// ---------------------------------------------------------------------------
70// Carbon Events
71// ---------------------------------------------------------------------------
72
73extern long wxMacTranslateKey(unsigned char key, unsigned char code) ;
74
75static const EventTypeSpec eventList[] =
76{
77 // TODO remove control related event like key and mouse (except for WindowLeave events)
78#if 1
79 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
80
81 { kEventClassKeyboard, kEventRawKeyDown } ,
82 { kEventClassKeyboard, kEventRawKeyRepeat } ,
83 { kEventClassKeyboard, kEventRawKeyUp } ,
84 { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
85#endif
86
87 { kEventClassWindow , kEventWindowShown } ,
88 { kEventClassWindow , kEventWindowActivated } ,
89 { kEventClassWindow , kEventWindowDeactivated } ,
90 { kEventClassWindow , kEventWindowBoundsChanging } ,
91 { kEventClassWindow , kEventWindowBoundsChanged } ,
92 { kEventClassWindow , kEventWindowClose } ,
93
94 // we have to catch these events on the toplevel window level, as controls don't get the
95 // raw mouse events anymore
96
97 { kEventClassMouse , kEventMouseDown } ,
98 { kEventClassMouse , kEventMouseUp } ,
99 { kEventClassMouse , kEventMouseWheelMoved } ,
100 { kEventClassMouse , kEventMouseMoved } ,
101 { kEventClassMouse , kEventMouseDragged } ,
102} ;
103
104static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
105{
106 OSStatus result = eventNotHandledErr ;
107
108 wxWindow* focus = wxWindow::FindFocus() ;
109 char charCode ;
110 UInt32 keyCode ;
111 UInt32 modifiers ;
112 Point point ;
113
114 EventRef rawEvent ;
115
116 GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
117
118 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
119 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
120 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
121 GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
122 sizeof( Point ), NULL, &point );
123
124 switch ( GetEventKind( event ) )
125 {
126 case kEventTextInputUnicodeForKeyEvent :
127 // this is only called when no default handler has jumped in, eg a wxControl on a floater window does not
128 // get its own kEventTextInputUnicodeForKeyEvent, so we route back the
129 wxControl* control = wxDynamicCast( focus , wxControl ) ;
130 if ( control )
131 {
132 ControlRef macControl = (ControlRef) control->GetHandle() ;
133 if ( macControl )
134 {
135 ::HandleControlKey( macControl , keyCode , charCode , modifiers ) ;
136 result = noErr ;
137 }
138 }
139 /*
140 // this may lead to double events sent to a window in case all handlers have skipped the key down event
141 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
142 UInt32 message = (keyCode << 8) + charCode;
143
144 if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
145 focus , message , modifiers , when , point.h , point.v ) )
146 {
147 result = noErr ;
148 }
149 */
150 break ;
151 }
152
153 return result ;
154}
155
156static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
157{
158 OSStatus result = eventNotHandledErr ;
159
160 wxWindow* focus = wxWindow::FindFocus() ;
161 if ( focus == NULL )
162 return result ;
163
164 char charCode ;
165 UInt32 keyCode ;
166 UInt32 modifiers ;
167 Point point ;
168 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
169
170 GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
171 GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
172 GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
173 GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
174 sizeof( Point ), NULL, &point );
175
176 UInt32 message = (keyCode << 8) + charCode;
177 switch( GetEventKind( event ) )
178 {
179 case kEventRawKeyRepeat :
180 case kEventRawKeyDown :
181 {
182 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
183 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
184 wxTheApp->MacSetCurrentEvent( event , handler ) ;
185 if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
186 focus , message , modifiers , when , point.h , point.v ) )
187 {
188 result = noErr ;
189 }
190 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
191 }
192 break ;
193 case kEventRawKeyUp :
194 if ( (focus != NULL) && wxTheApp->MacSendKeyUpEvent(
195 focus , message , modifiers , when , point.h , point.v ) )
196 {
197 result = noErr ;
198 }
199 break ;
200 case kEventRawKeyModifiersChanged :
201 {
202 wxKeyEvent event(wxEVT_KEY_DOWN);
203
204 event.m_shiftDown = modifiers & shiftKey;
205 event.m_controlDown = modifiers & controlKey;
206 event.m_altDown = modifiers & optionKey;
207 event.m_metaDown = modifiers & cmdKey;
208
209 event.m_x = point.h;
210 event.m_y = point.v;
211 event.m_timeStamp = when;
212 wxWindow* focus = wxWindow::FindFocus() ;
213 event.SetEventObject(focus);
214
215 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & controlKey )
216 {
217 event.m_keyCode = WXK_CONTROL ;
218 event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
219 focus->GetEventHandler()->ProcessEvent( event ) ;
220 }
221 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & shiftKey )
222 {
223 event.m_keyCode = WXK_SHIFT ;
224 event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
225 focus->GetEventHandler()->ProcessEvent( event ) ;
226 }
227 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & optionKey )
228 {
229 event.m_keyCode = WXK_ALT ;
230 event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
231 focus->GetEventHandler()->ProcessEvent( event ) ;
232 }
233 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & cmdKey )
234 {
235 event.m_keyCode = WXK_COMMAND ;
236 event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
237 focus->GetEventHandler()->ProcessEvent( event ) ;
238 }
239 wxTheApp->s_lastModifiers = modifiers ;
240 }
241 break ;
242 }
243
244 return result ;
245}
246
247// we don't interfere with foreign controls on our toplevel windows, therefore we always give back eventNotHandledErr
248// for windows that we didn't create (like eg Scrollbars in a databrowser) , or for controls where we did not handle the
249// mouse down at all
250
251// This handler can also be called from app level where data (ie target window) may be null or a non wx window
252
253wxWindow* g_MacLastWindow = NULL ;
254
255static EventMouseButton lastButton = 0 ;
256
257static void SetupMouseEvent( wxMouseEvent &wxevent , wxMacCarbonEvent &cEvent )
258{
259 UInt32 modifiers = cEvent.GetParameter<UInt32>(kEventParamKeyModifiers, typeUInt32) ;
260 Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
261
262 // this parameter are not given for all events
263 EventMouseButton button = 0 ;
264 UInt32 clickCount = 0 ;
265 cEvent.GetParameter<EventMouseButton>(kEventParamMouseButton, typeMouseButton , &button) ;
266 cEvent.GetParameter<UInt32>(kEventParamClickCount, typeUInt32 , &clickCount ) ;
267
268 wxevent.m_x = screenMouseLocation.h;
269 wxevent.m_y = screenMouseLocation.v;
270 wxevent.m_shiftDown = modifiers & shiftKey;
271 wxevent.m_controlDown = modifiers & controlKey;
272 wxevent.m_altDown = modifiers & optionKey;
273 wxevent.m_metaDown = modifiers & cmdKey;
274 wxevent.SetTimestamp( cEvent.GetTicks() ) ;
275 // a control click is interpreted as a right click
276 if ( button == kEventMouseButtonPrimary && (modifiers & controlKey) )
277 {
278 button = kEventMouseButtonSecondary ;
279 }
280
281 // we must make sure that our synthetic 'right' button corresponds in
282 // mouse down, moved and mouse up, and does not deliver a right down and left up
283
284 if ( cEvent.GetKind() == kEventMouseDown )
285 lastButton = button ;
286
287 if ( button == 0 )
288 lastButton = 0 ;
289 else if ( lastButton )
290 button = lastButton ;
291
292 // determinate the correct down state, wx does not want a 'down' for a mouseUp event, while mac delivers
293 // this button
294 if ( button != 0 && cEvent.GetKind() != kEventMouseUp )
295 {
296 switch( button )
297 {
298 case kEventMouseButtonPrimary :
299 wxevent.m_leftDown = true ;
300 break ;
301 case kEventMouseButtonSecondary :
302 wxevent.m_rightDown = true ;
303 break ;
304 case kEventMouseButtonTertiary :
305 wxevent.m_middleDown = true ;
306 break ;
307 }
308 }
309 // translate into wx types
310 switch ( cEvent.GetKind() )
311 {
312 case kEventMouseDown :
313 switch( button )
314 {
315 case kEventMouseButtonPrimary :
316 wxevent.SetEventType(clickCount > 1 ? wxEVT_LEFT_DCLICK : wxEVT_LEFT_DOWN ) ;
317 break ;
318 case kEventMouseButtonSecondary :
319 wxevent.SetEventType( clickCount > 1 ? wxEVT_RIGHT_DCLICK : wxEVT_RIGHT_DOWN ) ;
320 break ;
321 case kEventMouseButtonTertiary :
322 wxevent.SetEventType(clickCount > 1 ? wxEVT_MIDDLE_DCLICK : wxEVT_MIDDLE_DOWN ) ;
323 break ;
324 }
325 break ;
326 case kEventMouseUp :
327 switch( button )
328 {
329 case kEventMouseButtonPrimary :
330 wxevent.SetEventType( wxEVT_LEFT_UP ) ;
331 break ;
332 case kEventMouseButtonSecondary :
333 wxevent.SetEventType( wxEVT_RIGHT_UP ) ;
334 break ;
335 case kEventMouseButtonTertiary :
336 wxevent.SetEventType( wxEVT_MIDDLE_UP ) ;
337 break ;
338 }
339 break ;
340 case kEventMouseWheelMoved :
341 {
342 wxevent.SetEventType(wxEVT_MOUSEWHEEL ) ;
343
344 // EventMouseWheelAxis axis = cEvent.GetParameter<EventMouseWheelAxis>(kEventParamMouseWheelAxis, typeMouseWheelAxis) ;
345 SInt32 delta = cEvent.GetParameter<SInt32>(kEventParamMouseWheelDelta, typeLongInteger) ;
346
347 wxevent.m_wheelRotation = delta;
348 wxevent.m_wheelDelta = 1;
349 wxevent.m_linesPerAction = 1;
350 break ;
351 }
352 default :
353 wxevent.SetEventType(wxEVT_MOTION ) ;
354 break ;
355 }
356}
357
358ControlRef wxMacFindSubControl( Point location , ControlRef superControl , ControlPartCode *outPart )
359{
360 if ( superControl )
361 {
362 UInt16 childrenCount = 0 ;
363 OSStatus err = CountSubControls( superControl , &childrenCount ) ;
364 if ( err == errControlIsNotEmbedder )
365 return NULL ;
366 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") ) ;
367
368 for ( UInt16 i = childrenCount ; i >=1 ; --i )
369 {
370 ControlHandle sibling ;
371 err = GetIndexedSubControl( superControl , i , & sibling ) ;
372 if ( err == errControlIsNotEmbedder )
373 return NULL ;
374
375 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") ) ;
376 if ( IsControlVisible( sibling ) )
377 {
378 Rect r ;
379 UMAGetControlBoundsInWindowCoords( sibling , &r ) ;
380 if ( MacPtInRect( location , &r ) )
381 {
382 ControlHandle child = wxMacFindSubControl( location , sibling , outPart ) ;
383 if ( child )
384 return child ;
385 else
386 {
387 Point testLocation = location ;
388#if TARGET_API_MAC_OSX
389 testLocation.h -= r.left ;
390 testLocation.v -= r.top ;
391#endif
392 *outPart = TestControl( sibling , testLocation ) ;
393 return sibling ;
394 }
395 }
396 }
397 }
398 }
399 return NULL ;
400}
401
402ControlRef wxMacFindControlUnderMouse( Point location , WindowRef window , ControlPartCode *outPart )
403{
404#if TARGET_API_MAC_OSX
405 if ( UMAGetSystemVersion() >= 0x1030 )
406 return FindControlUnderMouse( location , window , outPart ) ;
407#endif
408 ControlRef rootControl = NULL ;
409 verify_noerr( GetRootControl( window , &rootControl ) ) ;
410 return wxMacFindSubControl( location , rootControl , outPart ) ;
411
412}
413pascal OSStatus wxMacTopLevelMouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
414{
415
416 OSStatus result = eventNotHandledErr ;
417
418 wxMacCarbonEvent cEvent( event ) ;
419
420 Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
421 Point windowMouseLocation = screenMouseLocation ;
422
423 WindowRef window ;
424 short windowPart = ::FindWindow(screenMouseLocation, &window);
425
426 wxWindow* currentMouseWindow = NULL ;
427 ControlRef control = NULL ;
428
429 if ( window )
430 {
431 QDGlobalToLocalPoint( UMAGetWindowPort(window ) , &windowMouseLocation ) ;
432
433 if ( wxTheApp->s_captureWindow && wxTheApp->s_captureWindow->MacGetTopLevelWindowRef() == (WXWindow) window && windowPart == inContent )
434 {
435 currentMouseWindow = wxTheApp->s_captureWindow ;
436 }
437 else if ( (IsWindowActive(window) && windowPart == inContent) )
438 {
439 ControlPartCode part ;
440 control = wxMacFindControlUnderMouse( windowMouseLocation , window , &part ) ;
441 // if there is no control below the mouse position, send the event to the toplevel window itself
442 if ( control == 0 )
443 currentMouseWindow = (wxWindow*) data ;
444 else
445 currentMouseWindow = wxFindControlFromMacControl( control ) ;
446 }
447 }
448
449 wxMouseEvent wxevent(wxEVT_LEFT_DOWN);
450 SetupMouseEvent( wxevent , cEvent ) ;
451
452 // handle all enter / leave events
453
454 if ( currentMouseWindow != g_MacLastWindow )
455 {
456 if ( g_MacLastWindow )
457 {
458 wxMouseEvent eventleave(wxevent);
459 eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
460 g_MacLastWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
461 eventleave.SetEventObject( g_MacLastWindow ) ;
462
463#if wxUSE_TOOLTIPS
464 wxToolTip::RelayEvent( g_MacLastWindow , eventleave);
465#endif // wxUSE_TOOLTIPS
466 g_MacLastWindow->GetEventHandler()->ProcessEvent(eventleave);
467 }
468 if ( currentMouseWindow )
469 {
470 wxMouseEvent evententer(wxevent);
471 evententer.SetEventType( wxEVT_ENTER_WINDOW );
472 currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
473 evententer.SetEventObject( currentMouseWindow ) ;
474#if wxUSE_TOOLTIPS
475 wxToolTip::RelayEvent( currentMouseWindow , evententer);
476#endif // wxUSE_TOOLTIPS
477 currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
478 }
479 g_MacLastWindow = currentMouseWindow ;
480 }
481
482 if ( windowPart == inMenuBar )
483 {
484 // special case menu bar, as we are having a low-level runloop we must do it ourselves
485 if ( cEvent.GetKind() == kEventMouseDown )
486 {
487 ::MenuSelect( screenMouseLocation ) ;
488 result = noErr ;
489 }
490 } // if ( windowPart == inMenuBar )
491 else if ( currentMouseWindow )
492 {
493 currentMouseWindow->ScreenToClient( &wxevent.m_x , &wxevent.m_y ) ;
494
495 wxevent.SetEventObject( currentMouseWindow ) ;
496
497 // update cursor
498
499 wxWindow* cursorTarget = currentMouseWindow ;
500 wxPoint cursorPoint( wxevent.m_x , wxevent.m_y ) ;
501
502 while( cursorTarget && !cursorTarget->MacSetupCursor( cursorPoint ) )
503 {
504 cursorTarget = cursorTarget->GetParent() ;
505 if ( cursorTarget )
506 cursorPoint += cursorTarget->GetPosition() ;
507 }
508
509 // update focus
510
511 if ( wxevent.GetEventType() == wxEVT_LEFT_DOWN )
512 {
513 // set focus to this window
514 if (currentMouseWindow->AcceptsFocus() && wxWindow::FindFocus()!=currentMouseWindow)
515 currentMouseWindow->SetFocus();
516 }
517
518 // make tooltips current
519
520 #if wxUSE_TOOLTIPS
521 if ( wxevent.GetEventType() == wxEVT_MOTION
522 || wxevent.GetEventType() == wxEVT_ENTER_WINDOW
523 || wxevent.GetEventType() == wxEVT_LEAVE_WINDOW )
524 wxToolTip::RelayEvent( currentMouseWindow , wxevent);
525 #endif // wxUSE_TOOLTIPS
526 if ( currentMouseWindow->GetEventHandler()->ProcessEvent(wxevent) )
527 result = noErr;
528 else
529 {
530 ControlPartCode dummyPart ;
531 // if built-in find control is finding the wrong control (ie static box instead of overlaid
532 // button, we cannot let the standard handler do its job, but must handle manually
533
534 if ( ( cEvent.GetKind() == kEventMouseDown ) &&
535 (FindControlUnderMouse(windowMouseLocation , window , &dummyPart) !=
536 wxMacFindControlUnderMouse( windowMouseLocation , window , &dummyPart ) ) )
537 {
538 if ( currentMouseWindow->MacIsReallyEnabled() )
539 {
540 EventModifiers modifiers = cEvent.GetParameter<EventModifiers>(kEventParamKeyModifiers, typeUInt32) ;
541 Point clickLocation = windowMouseLocation ;
542 #if TARGET_API_MAC_OSX
543 currentMouseWindow->MacRootWindowToWindow( &clickLocation.h , &clickLocation.v ) ;
544 #endif
545 HandleControlClick( (ControlRef) currentMouseWindow->GetHandle() , clickLocation ,
546 modifiers , (ControlActionUPP ) -1 ) ;
547 }
548 result = noErr ;
549 }
550 }
551 if ( cEvent.GetKind() == kEventMouseUp && wxTheApp->s_captureWindow )
552 {
553 wxTheApp->s_captureWindow = NULL ;
554 // update cursor ?
555 }
556 } // else if ( currentMouseWindow )
557 else
558 {
559 // don't mess with controls we don't know about
560 // for some reason returning eventNotHandledErr does not lead to the correct behaviour
561 // so we try sending them the correct control directly
562 wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
563 if ( cEvent.GetKind() == kEventMouseDown && toplevelWindow && control )
564 {
565 EventModifiers modifiers = cEvent.GetParameter<EventModifiers>(kEventParamKeyModifiers, typeUInt32) ;
566 Point clickLocation = windowMouseLocation ;
567#if TARGET_API_MAC_OSX
568 HIPoint hiPoint ;
569 hiPoint.x = clickLocation.h ;
570 hiPoint.y = clickLocation.v ;
571 HIViewConvertPoint( &hiPoint , (ControlRef) toplevelWindow->GetHandle() , control ) ;
572 clickLocation.h = (int)hiPoint.x ;
573 clickLocation.v = (int)hiPoint.y ;
574#endif
575 HandleControlClick( control , clickLocation ,
576 modifiers , (ControlActionUPP ) -1 ) ;
577 result = noErr ;
578 }
579 }
580 return result ;
581}
582
583static pascal OSStatus wxMacTopLevelWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
584{
585 OSStatus result = eventNotHandledErr ;
586
587 wxMacCarbonEvent cEvent( event ) ;
588
589 // WindowRef windowRef = cEvent.GetParameter<WindowRef>(kEventParamDirectObject) ;
590 wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
591
592 switch( GetEventKind( event ) )
593 {
594 case kEventWindowActivated :
595 {
596 toplevelWindow->MacActivate( cEvent.GetTicks() , true) ;
597 wxActivateEvent wxevent(wxEVT_ACTIVATE, true , toplevelWindow->GetId());
598 wxevent.SetTimestamp( cEvent.GetTicks() ) ;
599 wxevent.SetEventObject(toplevelWindow);
600 toplevelWindow->GetEventHandler()->ProcessEvent(wxevent);
601 // we still sending an eventNotHandledErr in order to allow for default processing
602 break ;
603 }
604 case kEventWindowDeactivated :
605 {
606 toplevelWindow->MacActivate(cEvent.GetTicks() , false) ;
607 wxActivateEvent wxevent(wxEVT_ACTIVATE, false , toplevelWindow->GetId());
608 wxevent.SetTimestamp( cEvent.GetTicks() ) ;
609 wxevent.SetEventObject(toplevelWindow);
610 toplevelWindow->GetEventHandler()->ProcessEvent(wxevent);
611 // we still sending an eventNotHandledErr in order to allow for default processing
612 break ;
613 }
614 case kEventWindowShown :
615 toplevelWindow->Refresh() ;
616 result = noErr ;
617 break ;
618 case kEventWindowClose :
619 toplevelWindow->Close() ;
620 result = noErr ;
621 break ;
622 case kEventWindowBoundsChanged :
623 {
624 UInt32 attributes = cEvent.GetParameter<UInt32>(kEventParamAttributes,typeUInt32) ;
625 Rect newRect = cEvent.GetParameter<Rect>(kEventParamCurrentBounds) ;
626 wxRect r( newRect.left , newRect.top , newRect.right - newRect.left , newRect.bottom - newRect.top ) ;
627 if ( attributes & kWindowBoundsChangeSizeChanged )
628 {
629 // according to the other ports we handle this within the OS level
630 // resize event, not within a wxSizeEvent
631 wxFrame *frame = wxDynamicCast( toplevelWindow , wxFrame ) ;
632 if ( frame )
633 {
634 #if wxUSE_STATUSBAR
635 frame->PositionStatusBar();
636 #endif
637 #if wxUSE_TOOLBAR
638 frame->PositionToolBar();
639 #endif
640 }
641
642 wxSizeEvent event( r.GetSize() , toplevelWindow->GetId() ) ;
643 event.SetEventObject( toplevelWindow ) ;
644
645 toplevelWindow->GetEventHandler()->ProcessEvent(event) ;
646 }
647 if ( attributes & kWindowBoundsChangeOriginChanged )
648 {
649 wxMoveEvent event( r.GetLeftTop() , toplevelWindow->GetId() ) ;
650 event.SetEventObject( toplevelWindow ) ;
651 toplevelWindow->GetEventHandler()->ProcessEvent(event) ;
652 }
653 result = noErr ;
654 break ;
655 }
656 case kEventWindowBoundsChanging :
657 {
658 UInt32 attributes = cEvent.GetParameter<UInt32>(kEventParamAttributes,typeUInt32) ;
659 Rect newRect = cEvent.GetParameter<Rect>(kEventParamCurrentBounds) ;
660
661 if ( (attributes & kWindowBoundsChangeSizeChanged) || (attributes & kWindowBoundsChangeOriginChanged) )
662 {
663 // all (Mac) rects are in content area coordinates, all wxRects in structure coordinates
664 int left , top , right , bottom ;
665 toplevelWindow->MacGetContentAreaInset( left , top , right , bottom ) ;
666 wxRect r( newRect.left - left , newRect.top - top ,
667 newRect.right - newRect.left + left + right , newRect.bottom - newRect.top + top + bottom ) ;
668 // this is a EVT_SIZING not a EVT_SIZE type !
669 wxSizeEvent wxevent( r , toplevelWindow->GetId() ) ;
670 wxevent.SetEventObject( toplevelWindow ) ;
671 wxRect adjustR = r ;
672 if ( toplevelWindow->GetEventHandler()->ProcessEvent(wxevent) )
673 adjustR = wxevent.GetRect() ;
674
675 if ( toplevelWindow->GetMaxWidth() != -1 && adjustR.GetWidth() > toplevelWindow->GetMaxWidth() )
676 adjustR.SetWidth( toplevelWindow->GetMaxWidth() ) ;
677 if ( toplevelWindow->GetMaxHeight() != -1 && adjustR.GetHeight() > toplevelWindow->GetMaxHeight() )
678 adjustR.SetHeight( toplevelWindow->GetMaxHeight() ) ;
679 if ( toplevelWindow->GetMinWidth() != -1 && adjustR.GetWidth() < toplevelWindow->GetMinWidth() )
680 adjustR.SetWidth( toplevelWindow->GetMinWidth() ) ;
681 if ( toplevelWindow->GetMinHeight() != -1 && adjustR.GetHeight() < toplevelWindow->GetMinHeight() )
682 adjustR.SetHeight( toplevelWindow->GetMinHeight() ) ;
683 const Rect adjustedRect = { adjustR.y + top , adjustR.x + left , adjustR.y + adjustR.height - bottom , adjustR.x + adjustR.width - right } ;
684 if ( !EqualRect( &newRect , &adjustedRect ) )
685 cEvent.SetParameter<Rect>( kEventParamCurrentBounds , &adjustedRect ) ;
686 }
687
688 result = noErr ;
689 break ;
690 }
691 default :
692 break ;
693 }
694 return result ;
695}
696
697pascal OSStatus wxMacTopLevelEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
698{
699 OSStatus result = eventNotHandledErr ;
700
701 switch ( GetEventClass( event ) )
702 {
703 case kEventClassKeyboard :
704 result = KeyboardEventHandler( handler, event , data ) ;
705 break ;
706 case kEventClassTextInput :
707 result = TextInputEventHandler( handler, event , data ) ;
708 break ;
709 case kEventClassWindow :
710 result = wxMacTopLevelWindowEventHandler( handler, event , data ) ;
711 break ;
712 case kEventClassMouse :
713 result = wxMacTopLevelMouseEventHandler( handler, event , data ) ;
714 break ;
715 default :
716 break ;
717 }
718 return result ;
719}
720
721DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacTopLevelEventHandler )
722
723// ---------------------------------------------------------------------------
724// wxWindowMac utility functions
725// ---------------------------------------------------------------------------
726
727// Find an item given the Macintosh Window Reference
728
729wxList wxWinMacWindowList(wxKEY_INTEGER);
730wxTopLevelWindowMac *wxFindWinFromMacWindow(WindowRef inWindowRef)
731{
732 wxNode *node = wxWinMacWindowList.Find((long)inWindowRef);
733 if (!node)
734 return NULL;
735 return (wxTopLevelWindowMac *)node->GetData();
736}
737
738void wxAssociateWinWithMacWindow(WindowRef inWindowRef, wxTopLevelWindowMac *win) ;
739void wxAssociateWinWithMacWindow(WindowRef inWindowRef, wxTopLevelWindowMac *win)
740{
741 // adding NULL WindowRef is (first) surely a result of an error and
742 // (secondly) breaks menu command processing
743 wxCHECK_RET( inWindowRef != (WindowRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
744
745 if ( !wxWinMacWindowList.Find((long)inWindowRef) )
746 wxWinMacWindowList.Append((long)inWindowRef, win);
747}
748
749void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win) ;
750void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win)
751{
752 wxWinMacWindowList.DeleteObject(win);
753}
754
755
756// ----------------------------------------------------------------------------
757// wxTopLevelWindowMac creation
758// ----------------------------------------------------------------------------
759
760wxTopLevelWindowMac *wxTopLevelWindowMac::s_macDeactivateWindow = NULL;
761
762typedef struct
763{
764 wxPoint m_position ;
765 wxSize m_size ;
766} FullScreenData ;
767
768void wxTopLevelWindowMac::Init()
769{
770 m_iconized =
771 m_maximizeOnShow = FALSE;
772 m_macWindow = NULL ;
773#if TARGET_API_MAC_OSX
774 m_macUsesCompositing = TRUE;
775#else
776 m_macUsesCompositing = FALSE;
777#endif
778 m_macEventHandler = NULL ;
779 m_macFullScreenData = NULL ;
780}
781
782class wxMacDeferredWindowDeleter : public wxObject
783{
784public :
785 wxMacDeferredWindowDeleter( WindowRef windowRef )
786 {
787 m_macWindow = windowRef ;
788 }
789 virtual ~wxMacDeferredWindowDeleter()
790 {
791 UMADisposeWindow( (WindowRef) m_macWindow ) ;
792 }
793 protected :
794 WindowRef m_macWindow ;
795} ;
796
797bool wxTopLevelWindowMac::Create(wxWindow *parent,
798 wxWindowID id,
799 const wxString& title,
800 const wxPoint& pos,
801 const wxSize& size,
802 long style,
803 const wxString& name)
804{
805 // init our fields
806 Init();
807
808 m_windowStyle = style;
809
810 SetName(name);
811
812 m_windowId = id == -1 ? NewControlId() : id;
813 wxWindow::SetTitle( title ) ;
814
815 MacCreateRealWindow( title, pos , size , MacRemoveBordersFromStyle(style) , name ) ;
816
817 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
818
819 wxTopLevelWindows.Append(this);
820
821 if ( parent )
822 parent->AddChild(this);
823
824 return TRUE;
825}
826
827wxTopLevelWindowMac::~wxTopLevelWindowMac()
828{
829 if ( m_macWindow )
830 {
831 wxToolTip::NotifyWindowDelete(m_macWindow) ;
832 wxPendingDelete.Append( new wxMacDeferredWindowDeleter( (WindowRef) m_macWindow ) ) ;
833 }
834
835 if ( m_macEventHandler )
836 {
837 ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
838 m_macEventHandler = NULL ;
839 }
840
841 wxRemoveMacWindowAssociation( this ) ;
842
843 if ( wxModelessWindows.Find(this) )
844 wxModelessWindows.DeleteObject(this);
845
846 FullScreenData *data = (FullScreenData *) m_macFullScreenData ;
847 delete data ;
848 m_macFullScreenData = NULL ;
849}
850
851
852// ----------------------------------------------------------------------------
853// wxTopLevelWindowMac maximize/minimize
854// ----------------------------------------------------------------------------
855
856void wxTopLevelWindowMac::Maximize(bool maximize)
857{
858 wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
859 wxMacWindowClipper clip (this);
860 ZoomWindow( (WindowRef)m_macWindow , maximize ? inZoomOut : inZoomIn , false ) ;
861}
862
863bool wxTopLevelWindowMac::IsMaximized() const
864{
865 return IsWindowInStandardState( (WindowRef)m_macWindow , NULL , NULL ) ;
866}
867
868void wxTopLevelWindowMac::Iconize(bool iconize)
869{
870 if ( IsWindowCollapsable((WindowRef)m_macWindow) )
871 CollapseWindow((WindowRef)m_macWindow , iconize ) ;
872}
873
874bool wxTopLevelWindowMac::IsIconized() const
875{
876 return IsWindowCollapsed((WindowRef)m_macWindow ) ;
877}
878
879void wxTopLevelWindowMac::Restore()
880{
881 // not available on mac
882}
883
884// ----------------------------------------------------------------------------
885// wxTopLevelWindowMac misc
886// ----------------------------------------------------------------------------
887
888wxPoint wxTopLevelWindowMac::GetClientAreaOrigin() const
889{
890 return wxPoint(0,0) ;
891}
892
893void wxTopLevelWindowMac::SetIcon(const wxIcon& icon)
894{
895 // this sets m_icon
896 wxTopLevelWindowBase::SetIcon(icon);
897}
898
899void wxTopLevelWindowMac::MacSetBackgroundBrush( const wxBrush &brush )
900{
901 wxTopLevelWindowBase::MacSetBackgroundBrush( brush ) ;
902
903 if ( m_macBackgroundBrush.Ok() && m_macBackgroundBrush.GetStyle() != wxTRANSPARENT && m_macBackgroundBrush.MacGetBrushKind() == kwxMacBrushTheme )
904 {
905 SetThemeWindowBackground( (WindowRef) m_macWindow , m_macBackgroundBrush.MacGetTheme() , false ) ;
906 }
907}
908
909void wxTopLevelWindowMac::MacInstallTopLevelWindowEventHandler()
910{
911 if ( m_macEventHandler != NULL )
912 {
913 verify_noerr( ::RemoveEventHandler( (EventHandlerRef) m_macEventHandler ) ) ;
914 }
915 InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacTopLevelEventHandlerUPP(),
916 GetEventTypeCount(eventList), eventList, this, (EventHandlerRef *)&m_macEventHandler);
917}
918
919void wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
920 const wxPoint& pos,
921 const wxSize& size,
922 long style,
923 const wxString& name )
924{
925 OSStatus err = noErr ;
926 SetName(name);
927 m_windowStyle = style;
928 m_isShown = FALSE;
929
930 // create frame.
931
932 Rect theBoundsRect;
933
934 int x = (int)pos.x;
935 int y = (int)pos.y;
936 if ( y < 50 )
937 y = 50 ;
938 if ( x < 20 )
939 x = 20 ;
940
941 int w = WidthDefault(size.x);
942 int h = HeightDefault(size.y);
943
944 ::SetRect(&theBoundsRect, x, y , x + w, y + h);
945
946 // translate the window attributes in the appropriate window class and attributes
947
948 WindowClass wclass = 0;
949 WindowAttributes attr = kWindowNoAttributes ;
950
951 if ( HasFlag( wxFRAME_TOOL_WINDOW) )
952 {
953 if (
954 HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
955 HasFlag( wxSYSTEM_MENU ) || HasFlag( wxCAPTION ) ||
956 HasFlag(wxTINY_CAPTION_HORIZ) || HasFlag(wxTINY_CAPTION_VERT)
957 )
958 {
959 wclass = kFloatingWindowClass ;
960 if ( HasFlag(wxTINY_CAPTION_VERT) )
961 {
962 attr |= kWindowSideTitlebarAttribute ;
963 }
964 }
965 else
966 {
967 wclass = kPlainWindowClass ;
968 }
969 }
970 else if ( HasFlag( wxCAPTION ) )
971 {
972 wclass = kDocumentWindowClass ;
973 }
974 else
975 {
976 if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
977 HasFlag( wxCLOSE_BOX ) || HasFlag( wxSYSTEM_MENU ) )
978 {
979 wclass = kDocumentWindowClass ;
980 }
981 else
982 {
983 wclass = kPlainWindowClass ;
984 }
985 }
986
987 if ( HasFlag( wxMINIMIZE_BOX ) )
988 {
989 attr |= kWindowCollapseBoxAttribute ;
990 }
991 if ( HasFlag( wxMAXIMIZE_BOX ) )
992 {
993 attr |= kWindowFullZoomAttribute ;
994 }
995 if ( HasFlag( wxRESIZE_BORDER ) )
996 {
997 attr |= kWindowResizableAttribute ;
998 }
999 if ( HasFlag( wxCLOSE_BOX) )
1000 {
1001 attr |= kWindowCloseBoxAttribute ;
1002 }
1003
1004 if (UMAGetSystemVersion() >= 0x1000)
1005 {
1006 // turn on live resizing (OS X only)
1007 attr |= kWindowLiveResizeAttribute;
1008 }
1009
1010 if (HasFlag(wxSTAY_ON_TOP))
1011 wclass = kUtilityWindowClass;
1012
1013#if TARGET_API_MAC_OSX
1014 attr |= kWindowCompositingAttribute;
1015#endif
1016
1017 if ( HasFlag(wxFRAME_SHAPED) )
1018 {
1019 WindowDefSpec customWindowDefSpec;
1020 customWindowDefSpec.defType = kWindowDefProcPtr;
1021 customWindowDefSpec.u.defProc = NewWindowDefUPP(wxShapedMacWindowDef);
1022
1023 err = ::CreateCustomWindow( &customWindowDefSpec, wclass,
1024 attr, &theBoundsRect,
1025 (WindowRef*) &m_macWindow);
1026 }
1027 else
1028 {
1029 err = ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
1030 }
1031
1032 wxCHECK_RET( err == noErr, wxT("Mac OS error when trying to create new window") );
1033
1034 // the create commands are only for content rect, so we have to set the size again as
1035 // structure bounds
1036 SetWindowBounds( (WindowRef) m_macWindow , kWindowStructureRgn , &theBoundsRect ) ;
1037
1038 wxAssociateWinWithMacWindow( (WindowRef) m_macWindow , this ) ;
1039 UMASetWTitle( (WindowRef) m_macWindow , title , m_font.GetEncoding() ) ;
1040 m_peer = new wxMacControl() ;
1041#if TARGET_API_MAC_OSX
1042 // There is a bug in 10.2.X for ::GetRootControl returning the window view instead of
1043 // the content view, so we have to retrieve it explicitely
1044 HIViewFindByID( HIViewGetRoot( (WindowRef) m_macWindow ) , kHIViewWindowContentID ,
1045 m_peer->GetControlRefAddr() ) ;
1046 if ( !m_peer->Ok() )
1047 {
1048 // compatibility mode fallback
1049 GetRootControl( (WindowRef) m_macWindow , m_peer->GetControlRefAddr() ) ;
1050 }
1051#else
1052 ::CreateRootControl( (WindowRef)m_macWindow , m_peer->GetControlRefAddr() ) ;
1053#endif
1054 // the root control level handleer
1055 MacInstallEventHandler( (WXWidget) m_peer->GetControlRef() ) ;
1056
1057 // the frame window event handler
1058 InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
1059 MacInstallTopLevelWindowEventHandler() ;
1060
1061 m_macFocus = NULL ;
1062
1063 if ( HasFlag(wxFRAME_SHAPED) )
1064 {
1065 // default shape matches the window size
1066 wxRegion rgn(0, 0, w, h);
1067 SetShape(rgn);
1068 }
1069
1070 wxWindowCreateEvent event(this);
1071 GetEventHandler()->ProcessEvent(event);
1072}
1073
1074void wxTopLevelWindowMac::ClearBackground()
1075{
1076 wxWindow::ClearBackground() ;
1077}
1078
1079// Raise the window to the top of the Z order
1080void wxTopLevelWindowMac::Raise()
1081{
1082 ::SelectWindow( (WindowRef)m_macWindow ) ;
1083}
1084
1085// Lower the window to the bottom of the Z order
1086void wxTopLevelWindowMac::Lower()
1087{
1088 ::SendBehind( (WindowRef)m_macWindow , NULL ) ;
1089}
1090
1091
1092void wxTopLevelWindowMac::MacDelayedDeactivation(long timestamp)
1093{
1094 if(s_macDeactivateWindow)
1095 {
1096 wxLogDebug(wxT("Doing delayed deactivation of %p"),s_macDeactivateWindow);
1097 s_macDeactivateWindow->MacActivate(timestamp, false);
1098 }
1099}
1100
1101void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
1102{
1103 // wxLogDebug(wxT("TopLevel=%p::MacActivate"),this);
1104
1105 if(s_macDeactivateWindow==this)
1106 s_macDeactivateWindow=NULL;
1107 MacDelayedDeactivation(timestamp);
1108 MacPropagateHiliteChanged() ;
1109}
1110
1111void wxTopLevelWindowMac::SetTitle(const wxString& title)
1112{
1113 wxWindow::SetTitle( title ) ;
1114 UMASetWTitle( (WindowRef)m_macWindow , title , m_font.GetEncoding() ) ;
1115}
1116
1117bool wxTopLevelWindowMac::Show(bool show)
1118{
1119 if ( !wxTopLevelWindowBase::Show(show) )
1120 return FALSE;
1121
1122 if (show)
1123 {
1124 #if wxUSE_SYSTEM_OPTIONS //code contributed by Ryan Wilcox December 18, 2003
1125 if ( (wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION) ) && ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION ) == 1) )
1126 {
1127 ::ShowWindow( (WindowRef)m_macWindow );
1128 }
1129 else
1130 #endif
1131 {
1132 ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
1133 }
1134 ::SelectWindow( (WindowRef)m_macWindow ) ;
1135 // as apps expect a size event to occur at this moment
1136 wxSizeEvent event( GetSize() , m_windowId);
1137 event.SetEventObject(this);
1138 GetEventHandler()->ProcessEvent(event);
1139 }
1140 else
1141 {
1142 #if wxUSE_SYSTEM_OPTIONS
1143 if ( (wxSystemOptions::HasOption(wxMAC_WINDOW_PLAIN_TRANSITION) ) && ( wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION ) == 1) )
1144 {
1145 ::HideWindow((WindowRef) m_macWindow );
1146 }
1147 else
1148 #endif
1149 {
1150 ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
1151 }
1152 }
1153
1154 MacPropagateVisibilityChanged() ;
1155
1156 return TRUE ;
1157}
1158
1159bool wxTopLevelWindowMac::ShowFullScreen(bool show, long style)
1160{
1161 if ( show )
1162 {
1163 FullScreenData *data = (FullScreenData *)m_macFullScreenData ;
1164 delete data ;
1165 data = new FullScreenData() ;
1166
1167 m_macFullScreenData = data ;
1168 data->m_position = GetPosition() ;
1169 data->m_size = GetSize() ;
1170
1171 if ( style & wxFULLSCREEN_NOMENUBAR )
1172 {
1173 HideMenuBar() ;
1174 }
1175 int left , top , right , bottom ;
1176 wxRect client = wxGetClientDisplayRect() ;
1177
1178 int x, y, w, h ;
1179
1180 x = client.x ;
1181 y = client.y ;
1182 w = client.width ;
1183 h = client.height ;
1184
1185 MacGetContentAreaInset( left , top , right , bottom ) ;
1186
1187 if ( style & wxFULLSCREEN_NOCAPTION )
1188 {
1189 y -= top ;
1190 h += top ;
1191 }
1192 if ( style & wxFULLSCREEN_NOBORDER )
1193 {
1194 x -= left ;
1195 w += left + right ;
1196 h += bottom ;
1197 }
1198 if ( style & wxFULLSCREEN_NOTOOLBAR )
1199 {
1200 // TODO
1201 }
1202 if ( style & wxFULLSCREEN_NOSTATUSBAR )
1203 {
1204 // TODO
1205 }
1206 SetSize( x , y , w, h ) ;
1207 }
1208 else
1209 {
1210 ShowMenuBar() ;
1211 FullScreenData *data = (FullScreenData *) m_macFullScreenData ;
1212 SetPosition( data->m_position ) ;
1213 SetSize( data->m_size ) ;
1214 delete data ;
1215 m_macFullScreenData = NULL ;
1216 }
1217 return FALSE;
1218}
1219
1220bool wxTopLevelWindowMac::IsFullScreen() const
1221{
1222 return m_macFullScreenData != NULL ;
1223}
1224
1225// we are still using coordinates of the content view, todo switch to structure bounds
1226
1227void wxTopLevelWindowMac::MacGetContentAreaInset( int &left , int &top , int &right , int &bottom )
1228{
1229 Rect content ;
1230 Rect structure ;
1231 GetWindowBounds( (WindowRef) m_macWindow, kWindowStructureRgn , &structure ) ;
1232 GetWindowBounds( (WindowRef) m_macWindow, kWindowContentRgn , &content ) ;
1233
1234 left = content.left - structure.left ;
1235 top = content.top - structure.top ;
1236 right = structure.right - content.right ;
1237 bottom = structure.bottom - content.bottom ;
1238}
1239
1240void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
1241{
1242 Rect bounds = { y , x , y + height , x + width } ;
1243 verify_noerr(SetWindowBounds( (WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
1244}
1245
1246void wxTopLevelWindowMac::DoGetPosition( int *x, int *y ) const
1247{
1248 Rect bounds ;
1249 verify_noerr(GetWindowBounds((WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
1250 if(x) *x = bounds.left ;
1251 if(y) *y = bounds.top ;
1252}
1253void wxTopLevelWindowMac::DoGetSize( int *width, int *height ) const
1254{
1255 Rect bounds ;
1256 verify_noerr(GetWindowBounds((WindowRef) m_macWindow, kWindowStructureRgn , &bounds )) ;
1257 if(width) *width = bounds.right - bounds.left ;
1258 if(height) *height = bounds.bottom - bounds.top ;
1259}
1260
1261void wxTopLevelWindowMac::DoGetClientSize( int *width, int *height ) const
1262{
1263 Rect bounds ;
1264 verify_noerr(GetWindowBounds((WindowRef) m_macWindow, kWindowContentRgn , &bounds )) ;
1265 if(width) *width = bounds.right - bounds.left ;
1266 if(height) *height = bounds.bottom - bounds.top ;
1267}
1268
1269void wxTopLevelWindowMac::MacSetMetalAppearance( bool set )
1270{
1271#if TARGET_API_MAC_OSX
1272 UInt32 attr = 0 ;
1273 GetWindowAttributes((WindowRef) m_macWindow , &attr ) ;
1274 wxASSERT_MSG( attr & kWindowCompositingAttribute ,
1275 wxT("Cannot set metal appearance on a non-compositing window") ) ;
1276
1277 MacChangeWindowAttributes( set ? kWindowMetalAttribute : kWindowNoAttributes ,
1278 set ? kWindowNoAttributes : kWindowMetalAttribute ) ;
1279#endif
1280}
1281
1282bool wxTopLevelWindowMac::MacGetMetalAppearance() const
1283{
1284#if TARGET_API_MAC_OSX
1285 return MacGetWindowAttributes() & kWindowMetalAttribute ;
1286#else
1287 return false ;
1288#endif
1289}
1290
1291void wxTopLevelWindowMac::MacChangeWindowAttributes( wxUint32 attributesToSet , wxUint32 attributesToClear )
1292{
1293 ChangeWindowAttributes ( (WindowRef) m_macWindow , attributesToSet, attributesToClear ) ;
1294}
1295
1296wxUint32 wxTopLevelWindowMac::MacGetWindowAttributes() const
1297{
1298 UInt32 attr = 0 ;
1299 GetWindowAttributes((WindowRef) m_macWindow , &attr ) ;
1300 return attr ;
1301}
1302
1303// ---------------------------------------------------------------------------
1304// Shape implementation
1305// ---------------------------------------------------------------------------
1306
1307
1308bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
1309{
1310 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
1311 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1312
1313 // The empty region signifies that the shape should be removed from the
1314 // window.
1315 if ( region.IsEmpty() )
1316 {
1317 wxSize sz = GetClientSize();
1318 wxRegion rgn(0, 0, sz.x, sz.y);
1319 return SetShape(rgn);
1320 }
1321
1322 // Make a copy of the region
1323 RgnHandle shapeRegion = NewRgn();
1324 CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
1325
1326 // Dispose of any shape region we may already have
1327 RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)MacGetWindowRef() );
1328 if ( oldRgn )
1329 DisposeRgn(oldRgn);
1330
1331 // Save the region so we can use it later
1332 SetWRefCon((WindowRef)MacGetWindowRef(), (SInt32)shapeRegion);
1333
1334 // Tell the window manager that the window has changed shape
1335 ReshapeCustomWindow((WindowRef)MacGetWindowRef());
1336 return TRUE;
1337}
1338
1339// ---------------------------------------------------------------------------
1340// Support functions for shaped windows, based on Apple's CustomWindow sample at
1341// http://developer.apple.com/samplecode/Sample_Code/Human_Interface_Toolbox/Mac_OS_High_Level_Toolbox/CustomWindow.htm
1342// ---------------------------------------------------------------------------
1343
1344static void wxShapedMacWindowGetPos(WindowRef window, Rect* inRect)
1345{
1346 GetWindowPortBounds(window, inRect);
1347 Point pt = {inRect->left, inRect->top};
1348 QDLocalToGlobalPoint( GetWindowPort(window) , &pt ) ;
1349 inRect->top = pt.v;
1350 inRect->left = pt.h;
1351 inRect->bottom += pt.v;
1352 inRect->right += pt.h;
1353}
1354
1355
1356static SInt32 wxShapedMacWindowGetFeatures(WindowRef window, SInt32 param)
1357{
1358 /*------------------------------------------------------
1359 Define which options your custom window supports.
1360 --------------------------------------------------------*/
1361 //just enable everything for our demo
1362 *(OptionBits*)param=//kWindowCanGrow|
1363 //kWindowCanZoom|
1364 //kWindowCanCollapse|
1365 //kWindowCanGetWindowRegion|
1366 //kWindowHasTitleBar|
1367 //kWindowSupportsDragHilite|
1368 kWindowCanDrawInCurrentPort|
1369 //kWindowCanMeasureTitle|
1370 kWindowWantsDisposeAtProcessDeath|
1371 kWindowSupportsGetGrowImageRegion|
1372 kWindowDefSupportsColorGrafPort;
1373 return 1;
1374}
1375
1376// The content region is left as a rectangle matching the window size, this is
1377// so the origin in the paint event, and etc. still matches what the
1378// programmer expects.
1379static void wxShapedMacWindowContentRegion(WindowRef window, RgnHandle rgn)
1380{
1381 SetEmptyRgn(rgn);
1382 wxTopLevelWindowMac* win = wxFindWinFromMacWindow(window);
1383 if (win)
1384 {
1385 Rect r ;
1386 wxShapedMacWindowGetPos(window, &r ) ;
1387 RectRgn( rgn , &r ) ;
1388 }
1389}
1390
1391// The structure region is set to the shape given to the SetShape method.
1392static void wxShapedMacWindowStructureRegion(WindowRef window, RgnHandle rgn)
1393{
1394 RgnHandle cachedRegion = (RgnHandle) GetWRefCon(window);
1395
1396 SetEmptyRgn(rgn);
1397 if (cachedRegion)
1398 {
1399 Rect windowRect;
1400 wxShapedMacWindowGetPos(window, &windowRect); //how big is the window
1401 CopyRgn(cachedRegion, rgn); //make a copy of our cached region
1402 OffsetRgn(rgn, windowRect.left, windowRect.top); // position it over window
1403 //MapRgn(rgn, &mMaskSize, &windowRect); //scale it to our actual window size
1404 }
1405}
1406
1407
1408
1409static SInt32 wxShapedMacWindowGetRegion(WindowRef window, SInt32 param)
1410{
1411 GetWindowRegionPtr rgnRec=(GetWindowRegionPtr)param;
1412
1413 switch(rgnRec->regionCode)
1414 {
1415 case kWindowStructureRgn:
1416 wxShapedMacWindowStructureRegion(window, rgnRec->winRgn);
1417 break;
1418 case kWindowContentRgn:
1419 wxShapedMacWindowContentRegion(window, rgnRec->winRgn);
1420 break;
1421 default:
1422 SetEmptyRgn(rgnRec->winRgn);
1423 } //switch
1424
1425 return noErr;
1426}
1427
1428
1429static SInt32 wxShapedMacWindowHitTest(WindowRef window,SInt32 param)
1430{
1431 /*------------------------------------------------------
1432 Determine the region of the window which was hit
1433 --------------------------------------------------------*/
1434 Point hitPoint;
1435 static RgnHandle tempRgn=nil;
1436
1437 if(!tempRgn)
1438 tempRgn=NewRgn();
1439
1440 SetPt(&hitPoint,LoWord(param),HiWord(param));//get the point clicked
1441
1442 //Mac OS 8.5 or later
1443 wxShapedMacWindowStructureRegion(window, tempRgn);
1444 if (PtInRgn(hitPoint, tempRgn)) //in window content region?
1445 return wInContent;
1446
1447 return wNoHit;//no significant area was hit.
1448}
1449
1450
1451static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param)
1452{
1453 switch(message)
1454 {
1455 case kWindowMsgHitTest:
1456 return wxShapedMacWindowHitTest(window,param);
1457
1458 case kWindowMsgGetFeatures:
1459 return wxShapedMacWindowGetFeatures(window,param);
1460
1461 // kWindowMsgGetRegion is sent during CreateCustomWindow and ReshapeCustomWindow
1462 case kWindowMsgGetRegion:
1463 return wxShapedMacWindowGetRegion(window,param);
1464 }
1465
1466 return 0;
1467}
1468
1469// ---------------------------------------------------------------------------
1470
wxWidgets (Impactor)