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