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