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