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