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