]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
if we can't detect tooltip color, yellow as used by Tiger is still better than white...
[wxWidgets.git] / src / mac / carbon / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/carbon/window.cpp
3 // Purpose: wxWindowMac
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #include "wx/window.h"
15
16 #ifndef WX_PRECOMP
17 #include "wx/log.h"
18 #include "wx/app.h"
19 #include "wx/utils.h"
20 #include "wx/panel.h"
21 #include "wx/frame.h"
22 #include "wx/dc.h"
23 #include "wx/dcclient.h"
24 #include "wx/button.h"
25 #include "wx/menu.h"
26 #include "wx/dialog.h"
27 #include "wx/settings.h"
28 #include "wx/msgdlg.h"
29 #include "wx/scrolbar.h"
30 #include "wx/statbox.h"
31 #include "wx/textctrl.h"
32 #include "wx/toolbar.h"
33 #include "wx/layout.h"
34 #include "wx/statusbr.h"
35 #include "wx/menuitem.h"
36 #include "wx/treectrl.h"
37 #include "wx/listctrl.h"
38 #endif
39
40 #include "wx/tooltip.h"
41 #include "wx/spinctrl.h"
42 #include "wx/geometry.h"
43
44 #if wxUSE_LISTCTRL
45 #include "wx/listctrl.h"
46 #endif
47
48 #if wxUSE_TREECTRL
49 #include "wx/treectrl.h"
50 #endif
51
52 #if wxUSE_CARET
53 #include "wx/caret.h"
54 #endif
55
56 #if wxUSE_POPUPWIN
57 #include "wx/popupwin.h"
58 #endif
59
60 #if wxUSE_DRAG_AND_DROP
61 #include "wx/dnd.h"
62 #endif
63
64 #include "wx/mac/uma.h"
65
66 #define MAC_SCROLLBAR_SIZE 15
67 #define MAC_SMALL_SCROLLBAR_SIZE 11
68
69 #include <string.h>
70
71 #ifdef __WXUNIVERSAL__
72 IMPLEMENT_ABSTRACT_CLASS(wxWindowMac, wxWindowBase)
73 #else
74 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
75 #endif
76
77 BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
78 EVT_NC_PAINT(wxWindowMac::OnNcPaint)
79 EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
80 EVT_PAINT(wxWindowMac::OnPaint)
81 EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
82 END_EVENT_TABLE()
83
84 #define wxMAC_DEBUG_REDRAW 0
85 #ifndef wxMAC_DEBUG_REDRAW
86 #define wxMAC_DEBUG_REDRAW 0
87 #endif
88
89 // ---------------------------------------------------------------------------
90 // Utility Routines to move between different coordinate systems
91 // ---------------------------------------------------------------------------
92
93 /*
94 * Right now we have the following setup :
95 * a border that is not part of the native control is always outside the
96 * control's border (otherwise we loose all native intelligence, future ways
97 * may be to have a second embedding control responsible for drawing borders
98 * and backgrounds eventually)
99 * so all this border calculations have to be taken into account when calling
100 * native methods or getting native oriented data
101 * so we have three coordinate systems here
102 * wx client coordinates
103 * wx window coordinates (including window frames)
104 * native coordinates
105 */
106
107 //
108 // originating from native control
109 //
110
111
112 void wxMacNativeToWindow( const wxWindow* window , RgnHandle handle )
113 {
114 OffsetRgn( handle , window->MacGetLeftBorderSize() , window->MacGetTopBorderSize() ) ;
115 }
116
117 void wxMacNativeToWindow( const wxWindow* window , Rect *rect )
118 {
119 OffsetRect( rect , window->MacGetLeftBorderSize() , window->MacGetTopBorderSize() ) ;
120 }
121
122 //
123 // directed towards native control
124 //
125
126 void wxMacWindowToNative( const wxWindow* window , RgnHandle handle )
127 {
128 OffsetRgn( handle , -window->MacGetLeftBorderSize() , -window->MacGetTopBorderSize() );
129 }
130
131 void wxMacWindowToNative( const wxWindow* window , Rect *rect )
132 {
133 OffsetRect( rect , -window->MacGetLeftBorderSize() , -window->MacGetTopBorderSize() ) ;
134 }
135
136 // ---------------------------------------------------------------------------
137 // Carbon Events
138 // ---------------------------------------------------------------------------
139
140 static const EventTypeSpec eventList[] =
141 {
142 { kEventClassCommand, kEventProcessCommand } ,
143 { kEventClassCommand, kEventCommandUpdateStatus } ,
144
145 { kEventClassControl , kEventControlGetClickActivation } ,
146 { kEventClassControl , kEventControlHit } ,
147
148 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
149 { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
150
151 { kEventClassControl , kEventControlDraw } ,
152
153 { kEventClassControl , kEventControlVisibilityChanged } ,
154 { kEventClassControl , kEventControlEnabledStateChanged } ,
155 { kEventClassControl , kEventControlHiliteChanged } ,
156
157 { kEventClassControl , kEventControlActivate } ,
158 { kEventClassControl , kEventControlDeactivate } ,
159
160 { kEventClassControl , kEventControlSetFocusPart } ,
161 { kEventClassControl , kEventControlFocusPartChanged } ,
162
163 { kEventClassService , kEventServiceGetTypes },
164 { kEventClassService , kEventServiceCopy },
165 { kEventClassService , kEventServicePaste },
166
167 // { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
168 // { kEventClassControl , kEventControlBoundsChanged } ,
169 } ;
170
171 static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
172 {
173 OSStatus result = eventNotHandledErr ;
174
175 wxMacCarbonEvent cEvent( event ) ;
176
177 ControlRef controlRef ;
178 wxWindowMac* thisWindow = (wxWindowMac*) data ;
179
180 cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
181
182 switch ( GetEventKind( event ) )
183 {
184 case kEventControlDraw :
185 {
186 RgnHandle updateRgn = NULL ;
187 RgnHandle allocatedRgn = NULL ;
188 wxRegion visRegion = thisWindow->MacGetVisibleRegion() ;
189
190 if ( cEvent.GetParameter<RgnHandle>(kEventParamRgnHandle, &updateRgn) != noErr )
191 {
192 HIShapeGetAsQDRgn( visRegion.GetWXHRGN(), updateRgn );
193 }
194 else
195 {
196 if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
197 {
198 // as this update region is in native window locals we must adapt it to wx window local
199 allocatedRgn = NewRgn() ;
200 CopyRgn( updateRgn , allocatedRgn ) ;
201
202 // hide the given region by the new region that must be shifted
203 wxMacNativeToWindow( thisWindow , allocatedRgn ) ;
204 updateRgn = allocatedRgn ;
205 }
206 }
207
208 #if wxMAC_DEBUG_REDRAW
209 if ( thisWindow->MacIsUserPane() )
210 {
211 static float color = 0.5 ;
212 static channel = 0 ;
213 HIRect bounds;
214 CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
215
216 HIViewGetBounds( controlRef, &bounds );
217 CGContextSetRGBFillColor( cgContext, channel == 0 ? color : 0.5 ,
218 channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
219 CGContextFillRect( cgContext, bounds );
220 color += 0.1 ;
221 if ( color > 0.9 )
222 {
223 color = 0.5 ;
224 channel++ ;
225 if ( channel == 3 )
226 channel = 0 ;
227 }
228 }
229 #endif
230
231 {
232 bool created = false ;
233 CGContextRef cgContext = NULL ;
234 OSStatus err = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) ;
235 wxASSERT_MSG( err == noErr , wxT("Unable to retrieve CGContextRef") ) ;
236 thisWindow->MacSetCGContextRef( cgContext ) ;
237
238 {
239 wxMacCGContextStateSaver sg( cgContext ) ;
240 float alpha = 1.0 ;
241 {
242 wxWindow* iter = thisWindow ;
243 while ( iter )
244 {
245 alpha *= (float) iter->GetTransparent()/255.0 ;
246 if ( iter->IsTopLevel() )
247 iter = NULL ;
248 else
249 iter = iter->GetParent() ;
250 }
251 }
252 CGContextSetAlpha( cgContext , alpha ) ;
253
254 if ( thisWindow->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
255 {
256 HIRect bounds;
257 HIViewGetBounds( controlRef, &bounds );
258 CGContextClearRect( cgContext, bounds );
259 }
260
261
262
263 if ( thisWindow->MacDoRedraw( updateRgn , cEvent.GetTicks() ) )
264 result = noErr ;
265
266 thisWindow->MacSetCGContextRef( NULL ) ;
267 }
268
269 if ( created )
270 CGContextRelease( cgContext ) ;
271 }
272
273 if ( allocatedRgn )
274 DisposeRgn( allocatedRgn ) ;
275 }
276 break ;
277
278 case kEventControlVisibilityChanged :
279 // we might have two native controls attributed to the same wxWindow instance
280 // eg a scrollview and an embedded textview, make sure we only fire for the 'outer'
281 // control, as otherwise native and wx visibility are different
282 if ( thisWindow->GetPeer() != NULL && thisWindow->GetPeer()->GetControlRef() == controlRef )
283 {
284 thisWindow->MacVisibilityChanged() ;
285 }
286 break ;
287
288 case kEventControlEnabledStateChanged :
289 thisWindow->MacEnabledStateChanged();
290 break ;
291
292 case kEventControlHiliteChanged :
293 thisWindow->MacHiliteChanged() ;
294 break ;
295
296 case kEventControlActivate :
297 case kEventControlDeactivate :
298 // FIXME: we should have a virtual function for this!
299 #if wxUSE_TREECTRL
300 if ( thisWindow->IsKindOf( CLASSINFO( wxTreeCtrl ) ) )
301 thisWindow->Refresh();
302 #endif
303 #if wxUSE_LISTCTRL
304 if ( thisWindow->IsKindOf( CLASSINFO( wxListCtrl ) ) )
305 thisWindow->Refresh();
306 #endif
307 break ;
308
309 //
310 // focus handling
311 // different handling on OS X
312 //
313
314 case kEventControlFocusPartChanged :
315 // the event is emulated by wxmac for systems lower than 10.5
316 {
317 ControlPartCode previousControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPreviousPart , typeControlPartCode );
318 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlCurrentPart , typeControlPartCode );
319
320 if ( thisWindow->MacGetTopLevelWindow() && thisWindow->GetPeer()->NeedsFocusRect() )
321 {
322 thisWindow->MacInvalidateBorders();
323 }
324
325 if ( currentControlPart == 0 )
326 {
327 // kill focus
328 #if wxUSE_CARET
329 if ( thisWindow->GetCaret() )
330 thisWindow->GetCaret()->OnKillFocus();
331 #endif
332
333 wxLogTrace(_T("Focus"), _T("focus lost(%p)"), wx_static_cast(void*, thisWindow));
334
335 // remove this as soon as posting the synthesized event works properly
336 static bool inKillFocusEvent = false ;
337
338 if ( !inKillFocusEvent )
339 {
340 inKillFocusEvent = true ;
341 wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
342 event.SetEventObject(thisWindow);
343 thisWindow->HandleWindowEvent(event) ;
344 inKillFocusEvent = false ;
345 }
346 }
347 else if ( previousControlPart == 0 )
348 {
349 // set focus
350 // panel wants to track the window which was the last to have focus in it
351 wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
352 wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
353 thisWindow->HandleWindowEvent(eventFocus);
354
355 #if wxUSE_CARET
356 if ( thisWindow->GetCaret() )
357 thisWindow->GetCaret()->OnSetFocus();
358 #endif
359
360 wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
361 event.SetEventObject(thisWindow);
362 thisWindow->HandleWindowEvent(event) ;
363 }
364 }
365 break;
366 case kEventControlSetFocusPart :
367 {
368 #ifdef __WXMAC_OSX__
369 Boolean focusEverything = false ;
370 if ( cEvent.GetParameter<Boolean>(kEventParamControlFocusEverything , &focusEverything ) == noErr )
371 {
372 // put a breakpoint here to catch focus everything events
373 }
374 #endif
375 ControlPartCode controlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
376
377 ControlPartCode previousControlPart = 0;
378 verify_noerr( HIViewGetFocusPart(controlRef, &previousControlPart));
379
380 if ( thisWindow->MacIsUserPane() )
381 {
382 if ( controlPart != kControlFocusNoPart )
383 cEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, 1 ) ;
384 result = noErr ;
385 }
386 else
387 result = CallNextEventHandler(handler, event);
388
389 if ( UMAGetSystemVersion() < 0x1050 )
390 {
391 // set back to 0 if problems arise
392 #if 1
393 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
394 // synthesize the event focus changed event
395 EventRef evRef = NULL ;
396
397 OSStatus err = MacCreateEvent(
398 NULL , kEventClassControl , kEventControlFocusPartChanged , TicksToEventTime( TickCount() ) ,
399 kEventAttributeUserEvent , &evRef );
400 verify_noerr( err );
401
402 wxMacCarbonEvent iEvent( evRef ) ;
403 iEvent.SetParameter<ControlRef>( kEventParamDirectObject , controlRef ) ;
404 iEvent.SetParameter<ControlPartCode>( kEventParamControlPreviousPart, typeControlPartCode, previousControlPart ) ;
405 iEvent.SetParameter<ControlPartCode>( kEventParamControlCurrentPart, typeControlPartCode, currentControlPart ) ;
406
407 #if 0
408 // TODO test this first, avoid double posts etc...
409 PostEventToQueue( GetMainEventQueue(), evRef , kEventPriorityHigh );
410 #else
411 wxMacWindowControlEventHandler( NULL , evRef , data ) ;
412 #endif
413 ReleaseEvent( evRef ) ;
414 #else
415 // old implementation, to be removed if the new one works
416 if ( controlPart == kControlFocusNoPart )
417 {
418 #if wxUSE_CARET
419 if ( thisWindow->GetCaret() )
420 thisWindow->GetCaret()->OnKillFocus();
421 #endif
422
423 wxLogTrace(_T("Focus"), _T("focus lost(%p)"), wx_static_cast(void*, thisWindow));
424
425 static bool inKillFocusEvent = false ;
426
427 if ( !inKillFocusEvent )
428 {
429 inKillFocusEvent = true ;
430 wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
431 event.SetEventObject(thisWindow);
432 thisWindow->HandleWindowEvent(event) ;
433 inKillFocusEvent = false ;
434 }
435 }
436 else
437 {
438 // panel wants to track the window which was the last to have focus in it
439 wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
440 wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
441 thisWindow->HandleWindowEvent(eventFocus);
442
443 #if wxUSE_CARET
444 if ( thisWindow->GetCaret() )
445 thisWindow->GetCaret()->OnSetFocus();
446 #endif
447
448 wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
449 event.SetEventObject(thisWindow);
450 thisWindow->HandleWindowEvent(event) ;
451 }
452 #endif
453 }
454 }
455 break ;
456
457 case kEventControlHit :
458 result = thisWindow->MacControlHit( handler , event ) ;
459 break ;
460
461 case kEventControlGetClickActivation :
462 {
463 // fix to always have a proper activation for DataBrowser controls (stay in bkgnd otherwise)
464 WindowRef owner = cEvent.GetParameter<WindowRef>(kEventParamWindowRef);
465 if ( !IsWindowActive(owner) )
466 {
467 cEvent.SetParameter(kEventParamClickActivation,(UInt32) kActivateAndIgnoreClick) ;
468 result = noErr ;
469 }
470 }
471 break ;
472
473 default :
474 break ;
475 }
476
477 return result ;
478 }
479
480 static pascal OSStatus
481 wxMacWindowServiceEventHandler(EventHandlerCallRef WXUNUSED(handler),
482 EventRef event,
483 void *data)
484 {
485 OSStatus result = eventNotHandledErr ;
486
487 wxMacCarbonEvent cEvent( event ) ;
488
489 ControlRef controlRef ;
490 wxWindowMac* thisWindow = (wxWindowMac*) data ;
491 wxTextCtrl* textCtrl = wxDynamicCast( thisWindow , wxTextCtrl ) ;
492 cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
493
494 switch ( GetEventKind( event ) )
495 {
496 case kEventServiceGetTypes :
497 if ( textCtrl )
498 {
499 long from, to ;
500 textCtrl->GetSelection( &from , &to ) ;
501
502 CFMutableArrayRef copyTypes = 0 , pasteTypes = 0;
503 if ( from != to )
504 copyTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServiceCopyTypes , typeCFMutableArrayRef ) ;
505 if ( textCtrl->IsEditable() )
506 pasteTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServicePasteTypes , typeCFMutableArrayRef ) ;
507
508 static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt', 'PICT', 'MooV', 'AIFF' */ };
509 for ( size_t i = 0 ; i < WXSIZEOF(textDataTypes) ; ++i )
510 {
511 CFStringRef typestring = CreateTypeStringWithOSType(textDataTypes[i]);
512 if ( typestring )
513 {
514 if ( copyTypes )
515 CFArrayAppendValue(copyTypes, typestring) ;
516 if ( pasteTypes )
517 CFArrayAppendValue(pasteTypes, typestring) ;
518
519 CFRelease( typestring ) ;
520 }
521 }
522
523 result = noErr ;
524 }
525 break ;
526
527 case kEventServiceCopy :
528 if ( textCtrl )
529 {
530 long from, to ;
531
532 textCtrl->GetSelection( &from , &to ) ;
533 wxString val = textCtrl->GetValue() ;
534 val = val.Mid( from , to - from ) ;
535 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
536 verify_noerr( PasteboardClear( pasteboard ) ) ;
537 PasteboardSynchronize( pasteboard );
538 // TODO add proper conversion
539 CFDataRef data = CFDataCreate( kCFAllocatorDefault, (const UInt8*)val.c_str(), val.length() );
540 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) 1, CFSTR("com.apple.traditional-mac-plain-text"), data, 0);
541 CFRelease( data );
542 result = noErr ;
543 }
544 break ;
545
546 case kEventServicePaste :
547 if ( textCtrl )
548 {
549 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
550 PasteboardSynchronize( pasteboard );
551 ItemCount itemCount;
552 verify_noerr( PasteboardGetItemCount( pasteboard, &itemCount ) );
553 for( UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++ )
554 {
555 PasteboardItemID itemID;
556 if ( PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ) == noErr )
557 {
558 CFDataRef flavorData = NULL;
559 if ( PasteboardCopyItemFlavorData( pasteboard, itemID, CFSTR("com.apple.traditional-mac-plain-text"), &flavorData ) == noErr )
560 {
561 CFIndex flavorDataSize = CFDataGetLength( flavorData );
562 char *content = new char[flavorDataSize+1] ;
563 memcpy( content, CFDataGetBytePtr( flavorData ), flavorDataSize );
564 content[flavorDataSize]=0;
565 CFRelease( flavorData );
566 #if wxUSE_UNICODE
567 textCtrl->WriteText( wxString( content , wxConvLocal ) );
568 #else
569 textCtrl->WriteText( wxString( content ) ) ;
570 #endif
571
572 delete[] content ;
573 result = noErr ;
574 }
575 }
576 }
577 }
578 break ;
579
580 default:
581 break ;
582 }
583
584 return result ;
585 }
586
587 pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
588 {
589 OSStatus result = eventNotHandledErr ;
590 wxWindowMac* focus = (wxWindowMac*) data ;
591
592 wchar_t* uniChars = NULL ;
593 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
594
595 UniChar* charBuf = NULL;
596 ByteCount dataSize = 0 ;
597 int numChars = 0 ;
598 UniChar buf[2] ;
599 if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
600 {
601 numChars = dataSize / sizeof( UniChar) + 1;
602 charBuf = buf ;
603
604 if ( (size_t) numChars * 2 > sizeof(buf) )
605 charBuf = new UniChar[ numChars ] ;
606 else
607 charBuf = buf ;
608
609 uniChars = new wchar_t[ numChars ] ;
610 GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
611 charBuf[ numChars - 1 ] = 0;
612 #if SIZEOF_WCHAR_T == 2
613 uniChars = (wchar_t*) charBuf ;
614 /* memcpy( uniChars , charBuf , numChars * 2 ) ;*/ // is there any point in copying charBuf over itself? (in fact, memcpy isn't even guaranteed to work correctly if the source and destination ranges overlap...)
615 #else
616 // the resulting string will never have more chars than the utf16 version, so this is safe
617 wxMBConvUTF16 converter ;
618 numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
619 #endif
620 }
621
622 switch ( GetEventKind( event ) )
623 {
624 case kEventTextInputUpdateActiveInputArea :
625 {
626 // An IME input event may return several characters, but we need to send one char at a time to
627 // EVT_CHAR
628 for (int pos=0 ; pos < numChars ; pos++)
629 {
630 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
631 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
632 wxTheApp->MacSetCurrentEvent( event , handler ) ;
633
634 UInt32 message = uniChars[pos] < 128 ? (char)uniChars[pos] : '?';
635 /*
636 NB: faking a charcode here is problematic. The kEventTextInputUpdateActiveInputArea event is sent
637 multiple times to update the active range during inline input, so this handler will often receive
638 uncommited text, which should usually not trigger side effects. It might be a good idea to check the
639 kEventParamTextInputSendFixLen parameter and verify if input is being confirmed (see CarbonEvents.h).
640 On the other hand, it can be useful for some applications to react to uncommitted text (for example,
641 to update a status display), as long as it does not disrupt the inline input session. Ideally, wx
642 should add new event types to support advanced text input. For now, I would keep things as they are.
643
644 However, the code that was being used caused additional problems:
645 UInt32 message = (0 << 8) + ((char)uniChars[pos] );
646 Since it simply truncated the unichar to the last byte, it ended up causing weird bugs with inline
647 input, such as switching to another field when one attempted to insert the character U+4E09 (the kanji
648 for "three"), because it was truncated to 09 (kTabCharCode), which was later "converted" to WXK_TAB
649 (still 09) in wxMacTranslateKey; or triggering the default button when one attempted to insert U+840D
650 (the kanji for "name"), which got truncated to 0D and interpreted as a carriage return keypress.
651 Note that even single-byte characters could have been misinterpreted, since MacRoman charcodes only
652 overlap with Unicode within the (7-bit) ASCII range.
653 But simply passing a NUL charcode would disable text updated events, because wxTextCtrl::OnChar checks
654 for codes within a specific range. Therefore I went for the solution seen above, which keeps ASCII
655 characters as they are and replaces the rest with '?', ensuring that update events are triggered.
656 It would be better to change wxTextCtrl::OnChar to look at the actual unicode character instead, but
657 I don't have time to look into that right now.
658 -- CL
659 */
660 if ( wxTheApp->MacSendCharEvent(
661 focus , message , 0 , when , 0 , 0 , uniChars[pos] ) )
662 {
663 result = noErr ;
664 }
665
666 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
667 }
668 }
669 break ;
670 case kEventTextInputUnicodeForKeyEvent :
671 {
672 UInt32 keyCode, modifiers ;
673 Point point ;
674 EventRef rawEvent ;
675 unsigned char charCode ;
676
677 GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
678 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
679 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
680 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
681 GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
682
683 UInt32 message = (keyCode << 8) + charCode;
684
685 // An IME input event may return several characters, but we need to send one char at a time to
686 // EVT_CHAR
687 for (int pos=0 ; pos < numChars ; pos++)
688 {
689 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
690 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
691 wxTheApp->MacSetCurrentEvent( event , handler ) ;
692
693 if ( wxTheApp->MacSendCharEvent(
694 focus , message , modifiers , when , point.h , point.v , uniChars[pos] ) )
695 {
696 result = noErr ;
697 }
698
699 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
700 }
701 }
702 break;
703 default:
704 break ;
705 }
706
707 delete [] uniChars ;
708 if ( charBuf != buf )
709 delete [] charBuf ;
710
711 return result ;
712 }
713
714 static pascal OSStatus
715 wxMacWindowCommandEventHandler(EventHandlerCallRef WXUNUSED(handler),
716 EventRef event,
717 void *data)
718 {
719 OSStatus result = eventNotHandledErr ;
720 wxWindowMac* focus = (wxWindowMac*) data ;
721
722 HICommand command ;
723
724 wxMacCarbonEvent cEvent( event ) ;
725 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
726
727 wxMenuItem* item = NULL ;
728 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
729 int id = wxMacCommandToId( command.commandID ) ;
730
731 if ( item )
732 {
733 wxASSERT( itemMenu != NULL ) ;
734
735 switch ( cEvent.GetKind() )
736 {
737 case kEventProcessCommand :
738 result = itemMenu->MacHandleCommandProcess( item, id, focus );
739 break ;
740
741 case kEventCommandUpdateStatus:
742 result = itemMenu->MacHandleCommandUpdateStatus( item, id, focus );
743 break ;
744
745 default :
746 break ;
747 }
748 }
749 return result ;
750 }
751
752 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
753 {
754 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
755 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
756 wxTheApp->MacSetCurrentEvent( event , handler ) ;
757 OSStatus result = eventNotHandledErr ;
758
759 switch ( GetEventClass( event ) )
760 {
761 case kEventClassCommand :
762 result = wxMacWindowCommandEventHandler( handler , event , data ) ;
763 break ;
764
765 case kEventClassControl :
766 result = wxMacWindowControlEventHandler( handler, event, data ) ;
767 break ;
768
769 case kEventClassService :
770 result = wxMacWindowServiceEventHandler( handler, event , data ) ;
771 break ;
772
773 case kEventClassTextInput :
774 result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
775 break ;
776
777 default :
778 break ;
779 }
780
781 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
782
783 return result ;
784 }
785
786 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
787
788 // ---------------------------------------------------------------------------
789 // Scrollbar Tracking for all
790 // ---------------------------------------------------------------------------
791
792 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode ) ;
793 pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode )
794 {
795 if ( partCode != 0)
796 {
797 wxWindow* wx = wxFindControlFromMacControl( control ) ;
798 if ( wx )
799 wx->MacHandleControlClick( (WXWidget) control , partCode , true /* stillDown */ ) ;
800 }
801 }
802 wxMAC_DEFINE_PROC_GETTER( ControlActionUPP , wxMacLiveScrollbarActionProc ) ;
803
804 // ===========================================================================
805 // implementation
806 // ===========================================================================
807
808 WX_DECLARE_HASH_MAP(ControlRef, wxWindow*, wxPointerHash, wxPointerEqual, MacControlMap);
809
810 static MacControlMap wxWinMacControlList;
811
812 wxWindow *wxFindControlFromMacControl(ControlRef inControl )
813 {
814 MacControlMap::iterator node = wxWinMacControlList.find(inControl);
815
816 return (node == wxWinMacControlList.end()) ? NULL : node->second;
817 }
818
819 void wxAssociateControlWithMacControl(ControlRef inControl, wxWindow *control)
820 {
821 // adding NULL ControlRef is (first) surely a result of an error and
822 // (secondly) breaks native event processing
823 wxCHECK_RET( inControl != (ControlRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
824
825 wxWinMacControlList[inControl] = control;
826 }
827
828 void wxRemoveMacControlAssociation(wxWindow *control)
829 {
830 // iterate over all the elements in the class
831 // is the iterator stable ? as we might have two associations pointing to the same wxWindow
832 // we should go on...
833
834 bool found = true ;
835 while ( found )
836 {
837 found = false ;
838 MacControlMap::iterator it;
839 for ( it = wxWinMacControlList.begin(); it != wxWinMacControlList.end(); ++it )
840 {
841 if ( it->second == control )
842 {
843 wxWinMacControlList.erase(it);
844 found = true ;
845 break;
846 }
847 }
848 }
849 }
850
851 // ----------------------------------------------------------------------------
852 // constructors and such
853 // ----------------------------------------------------------------------------
854
855 wxWindowMac::wxWindowMac()
856 {
857 Init();
858 }
859
860 wxWindowMac::wxWindowMac(wxWindowMac *parent,
861 wxWindowID id,
862 const wxPoint& pos ,
863 const wxSize& size ,
864 long style ,
865 const wxString& name )
866 {
867 Init();
868 Create(parent, id, pos, size, style, name);
869 }
870
871 void wxWindowMac::Init()
872 {
873 m_peer = NULL ;
874 m_macAlpha = 255 ;
875 m_cgContextRef = NULL ;
876
877 // as all windows are created with WS_VISIBLE style...
878 m_isShown = true;
879
880 m_hScrollBar = NULL ;
881 m_vScrollBar = NULL ;
882 m_hScrollBarAlwaysShown = false;
883 m_vScrollBarAlwaysShown = false;
884
885 m_macIsUserPane = true;
886 m_clipChildren = false ;
887 m_cachedClippedRectValid = false ;
888 }
889
890 wxWindowMac::~wxWindowMac()
891 {
892 SendDestroyEvent();
893
894 m_isBeingDeleted = true;
895
896 MacInvalidateBorders() ;
897
898 #ifndef __WXUNIVERSAL__
899 // VS: make sure there's no wxFrame with last focus set to us:
900 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
901 {
902 wxFrame *frame = wxDynamicCast(win, wxFrame);
903 if ( frame )
904 {
905 if ( frame->GetLastFocus() == this )
906 frame->SetLastFocus((wxWindow*)NULL);
907 break;
908 }
909 }
910 #endif
911
912 // destroy children before destroying this window itself
913 DestroyChildren();
914
915 // wxRemoveMacControlAssociation( this ) ;
916 // If we delete an item, we should initialize the parent panel,
917 // because it could now be invalid.
918 wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
919 if ( tlw )
920 {
921 if ( tlw->GetDefaultItem() == (wxButton*) this)
922 tlw->SetDefaultItem(NULL);
923 }
924
925 if ( m_peer && m_peer->Ok() )
926 {
927 // in case the callback might be called during destruction
928 wxRemoveMacControlAssociation( this) ;
929 ::RemoveEventHandler( (EventHandlerRef ) m_macControlEventHandler ) ;
930 // we currently are not using this hook
931 // ::SetControlColorProc( *m_peer , NULL ) ;
932 m_peer->Dispose() ;
933 }
934
935 if ( g_MacLastWindow == this )
936 g_MacLastWindow = NULL ;
937
938 #ifndef __WXUNIVERSAL__
939 wxFrame* frame = wxDynamicCast( wxGetTopLevelParent( (wxWindow*)this ) , wxFrame ) ;
940 if ( frame )
941 {
942 if ( frame->GetLastFocus() == this )
943 frame->SetLastFocus( NULL ) ;
944 }
945 #endif
946
947 // delete our drop target if we've got one
948 #if wxUSE_DRAG_AND_DROP
949 if ( m_dropTarget != NULL )
950 {
951 delete m_dropTarget;
952 m_dropTarget = NULL;
953 }
954 #endif
955
956 delete m_peer ;
957 }
958
959 WXWidget wxWindowMac::GetHandle() const
960 {
961 return (WXWidget) m_peer->GetControlRef() ;
962 }
963
964 void wxWindowMac::MacInstallEventHandler( WXWidget control )
965 {
966 wxAssociateControlWithMacControl( (ControlRef) control , this ) ;
967 InstallControlEventHandler( (ControlRef)control , GetwxMacWindowEventHandlerUPP(),
968 GetEventTypeCount(eventList), eventList, this,
969 (EventHandlerRef *)&m_macControlEventHandler);
970 }
971
972 // Constructor
973 bool wxWindowMac::Create(wxWindowMac *parent,
974 wxWindowID id,
975 const wxPoint& pos,
976 const wxSize& size,
977 long style,
978 const wxString& name)
979 {
980 wxCHECK_MSG( parent, false, wxT("can't create wxWindowMac without parent") );
981
982 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
983 return false;
984
985 m_windowVariant = parent->GetWindowVariant() ;
986
987 if ( m_macIsUserPane )
988 {
989 Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
990
991 UInt32 features = 0
992 | kControlSupportsEmbedding
993 | kControlSupportsLiveFeedback
994 | kControlGetsFocusOnClick
995 // | kControlHasSpecialBackground
996 // | kControlSupportsCalcBestRect
997 | kControlHandlesTracking
998 | kControlSupportsFocus
999 | kControlWantsActivate
1000 | kControlWantsIdle ;
1001
1002 m_peer = new wxMacControl(this) ;
1003 OSStatus err =::CreateUserPaneControl( MAC_WXHWND(GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , m_peer->GetControlRefAddr() );
1004 verify_noerr( err );
1005
1006 MacPostControlCreate(pos, size) ;
1007 }
1008
1009 #ifndef __WXUNIVERSAL__
1010 // Don't give scrollbars to wxControls unless they ask for them
1011 if ( (! IsKindOf(CLASSINFO(wxControl)) && ! IsKindOf(CLASSINFO(wxStatusBar)))
1012 || (IsKindOf(CLASSINFO(wxControl)) && ((style & wxHSCROLL) || (style & wxVSCROLL))))
1013 {
1014 MacCreateScrollBars( style ) ;
1015 }
1016 #endif
1017
1018 wxWindowCreateEvent event(this);
1019 GetEventHandler()->AddPendingEvent(event);
1020
1021 return true;
1022 }
1023
1024 void wxWindowMac::MacChildAdded()
1025 {
1026 if ( m_vScrollBar )
1027 m_vScrollBar->Raise() ;
1028 if ( m_hScrollBar )
1029 m_hScrollBar->Raise() ;
1030 }
1031
1032 void wxWindowMac::MacPostControlCreate(const wxPoint& WXUNUSED(pos), const wxSize& size)
1033 {
1034 wxASSERT_MSG( m_peer != NULL && m_peer->Ok() , wxT("No valid mac control") ) ;
1035
1036 m_peer->SetReference( (URefCon) this ) ;
1037 GetParent()->AddChild( this );
1038
1039 MacInstallEventHandler( (WXWidget) m_peer->GetControlRef() );
1040
1041 ControlRef container = (ControlRef) GetParent()->GetHandle() ;
1042 wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
1043 ::EmbedControl( m_peer->GetControlRef() , container ) ;
1044 GetParent()->MacChildAdded() ;
1045
1046 // adjust font, controlsize etc
1047 DoSetWindowVariant( m_windowVariant ) ;
1048
1049 m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics) ) ;
1050
1051 if (!m_macIsUserPane)
1052 SetInitialSize(size);
1053
1054 SetCursor( *wxSTANDARD_CURSOR ) ;
1055 }
1056
1057 void wxWindowMac::DoSetWindowVariant( wxWindowVariant variant )
1058 {
1059 // Don't assert, in case we set the window variant before
1060 // the window is created
1061 // wxASSERT( m_peer->Ok() ) ;
1062
1063 m_windowVariant = variant ;
1064
1065 if (m_peer == NULL || !m_peer->Ok())
1066 return;
1067
1068 ControlSize size ;
1069 ThemeFontID themeFont = kThemeSystemFont ;
1070
1071 // we will get that from the settings later
1072 // and make this NORMAL later, but first
1073 // we have a few calculations that we must fix
1074
1075 switch ( variant )
1076 {
1077 case wxWINDOW_VARIANT_NORMAL :
1078 size = kControlSizeNormal;
1079 themeFont = kThemeSystemFont ;
1080 break ;
1081
1082 case wxWINDOW_VARIANT_SMALL :
1083 size = kControlSizeSmall;
1084 themeFont = kThemeSmallSystemFont ;
1085 break ;
1086
1087 case wxWINDOW_VARIANT_MINI :
1088 // not always defined in the headers
1089 size = 3 ;
1090 themeFont = 109 ;
1091 break ;
1092
1093 case wxWINDOW_VARIANT_LARGE :
1094 size = kControlSizeLarge;
1095 themeFont = kThemeSystemFont ;
1096 break ;
1097
1098 default:
1099 wxFAIL_MSG(_T("unexpected window variant"));
1100 break ;
1101 }
1102
1103 m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
1104
1105 wxFont font ;
1106 font.MacCreateFromThemeFont( themeFont ) ;
1107 SetFont( font ) ;
1108 }
1109
1110 void wxWindowMac::MacUpdateControlFont()
1111 {
1112 m_peer->SetFont( GetFont() , GetForegroundColour() , GetWindowStyle() ) ;
1113 // do not trigger refreshes upon invisible and possible partly created objects
1114 if ( IsShownOnScreen() )
1115 Refresh() ;
1116 }
1117
1118 bool wxWindowMac::SetFont(const wxFont& font)
1119 {
1120 bool retval = wxWindowBase::SetFont( font );
1121
1122 MacUpdateControlFont() ;
1123
1124 return retval;
1125 }
1126
1127 bool wxWindowMac::SetForegroundColour(const wxColour& col )
1128 {
1129 bool retval = wxWindowBase::SetForegroundColour( col );
1130
1131 if (retval)
1132 MacUpdateControlFont();
1133
1134 return retval;
1135 }
1136
1137 bool wxWindowMac::SetBackgroundColour(const wxColour& col )
1138 {
1139 if ( !wxWindowBase::SetBackgroundColour(col) && m_hasBgCol )
1140 return false ;
1141
1142 m_peer->SetBackgroundColour( col ) ;
1143
1144 return true ;
1145 }
1146
1147 bool wxWindowMac::MacCanFocus() const
1148 {
1149 // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
1150 // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning,
1151 // but the value range is nowhere documented
1152 Boolean keyExistsAndHasValidFormat ;
1153 CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue( CFSTR("AppleKeyboardUIMode" ) ,
1154 kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat );
1155
1156 if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
1157 {
1158 return true ;
1159 }
1160 else
1161 {
1162 UInt32 features = 0 ;
1163 m_peer->GetFeatures( &features ) ;
1164
1165 return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
1166 }
1167 }
1168
1169 void wxWindowMac::SetFocus()
1170 {
1171 if ( !AcceptsFocus() )
1172 return ;
1173
1174 wxWindow* former = FindFocus() ;
1175 if ( former == this )
1176 return ;
1177
1178 // as we cannot rely on the control features to find out whether we are in full keyboard mode,
1179 // we can only leave in case of an error
1180 OSStatus err = m_peer->SetFocus( kControlFocusNextPart ) ;
1181 if ( err == errCouldntSetFocus )
1182 return ;
1183
1184 SetUserFocusWindow( (WindowRef)MacGetTopLevelWindowRef() );
1185 }
1186
1187 void wxWindowMac::DoCaptureMouse()
1188 {
1189 wxApp::s_captureWindow = this ;
1190 }
1191
1192 wxWindow * wxWindowBase::GetCapture()
1193 {
1194 return wxApp::s_captureWindow ;
1195 }
1196
1197 void wxWindowMac::DoReleaseMouse()
1198 {
1199 wxApp::s_captureWindow = NULL ;
1200 }
1201
1202 #if wxUSE_DRAG_AND_DROP
1203
1204 void wxWindowMac::SetDropTarget(wxDropTarget *pDropTarget)
1205 {
1206 if ( m_dropTarget != NULL )
1207 delete m_dropTarget;
1208
1209 m_dropTarget = pDropTarget;
1210 if ( m_dropTarget != NULL )
1211 {
1212 // TODO:
1213 }
1214 }
1215
1216 #endif
1217
1218 // Old-style File Manager Drag & Drop
1219 void wxWindowMac::DragAcceptFiles(bool WXUNUSED(accept))
1220 {
1221 // TODO:
1222 }
1223
1224 // Returns the size of the native control. In the case of the toplevel window
1225 // this is the content area root control
1226
1227 void wxWindowMac::MacGetPositionAndSizeFromControl(int& WXUNUSED(x),
1228 int& WXUNUSED(y),
1229 int& WXUNUSED(w),
1230 int& WXUNUSED(h)) const
1231 {
1232 wxFAIL_MSG( wxT("Not currently supported") ) ;
1233 }
1234
1235 // From a wx position / size calculate the appropriate size of the native control
1236
1237 bool wxWindowMac::MacGetBoundsForControl(
1238 const wxPoint& pos,
1239 const wxSize& size,
1240 int& x, int& y,
1241 int& w, int& h , bool adjustOrigin ) const
1242 {
1243 // the desired size, minus the border pixels gives the correct size of the control
1244 x = (int)pos.x;
1245 y = (int)pos.y;
1246
1247 // TODO: the default calls may be used as soon as PostCreateControl Is moved here
1248 w = wxMax(size.x, 0) ; // WidthDefault( size.x );
1249 h = wxMax(size.y, 0) ; // HeightDefault( size.y ) ;
1250
1251 x += MacGetLeftBorderSize() ;
1252 y += MacGetTopBorderSize() ;
1253 w -= MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1254 h -= MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1255
1256 if ( adjustOrigin )
1257 AdjustForParentClientOrigin( x , y ) ;
1258
1259 // this is in window relative coordinate, as this parent may have a border, its physical position is offset by this border
1260 if ( !GetParent()->IsTopLevel() )
1261 {
1262 x -= GetParent()->MacGetLeftBorderSize() ;
1263 y -= GetParent()->MacGetTopBorderSize() ;
1264 }
1265
1266 return true ;
1267 }
1268
1269 // Get window size (not client size)
1270 void wxWindowMac::DoGetSize(int *x, int *y) const
1271 {
1272 Rect bounds ;
1273 m_peer->GetRect( &bounds ) ;
1274
1275 if (x)
1276 *x = bounds.right - bounds.left + MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1277 if (y)
1278 *y = bounds.bottom - bounds.top + MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1279 }
1280
1281 // get the position of the bounds of this window in client coordinates of its parent
1282 void wxWindowMac::DoGetPosition(int *x, int *y) const
1283 {
1284 Rect bounds ;
1285 m_peer->GetRect( &bounds ) ;
1286
1287 int x1 = bounds.left ;
1288 int y1 = bounds.top ;
1289
1290 // get the wx window position from the native one
1291 x1 -= MacGetLeftBorderSize() ;
1292 y1 -= MacGetTopBorderSize() ;
1293
1294 if ( !IsTopLevel() )
1295 {
1296 wxWindow *parent = GetParent();
1297 if ( parent )
1298 {
1299 // we must first adjust it to be in window coordinates of the parent,
1300 // as otherwise it gets lost by the ClientAreaOrigin fix
1301 x1 += parent->MacGetLeftBorderSize() ;
1302 y1 += parent->MacGetTopBorderSize() ;
1303
1304 // and now to client coordinates
1305 wxPoint pt(parent->GetClientAreaOrigin());
1306 x1 -= pt.x ;
1307 y1 -= pt.y ;
1308 }
1309 }
1310
1311 if (x)
1312 *x = x1 ;
1313 if (y)
1314 *y = y1 ;
1315 }
1316
1317 void wxWindowMac::DoScreenToClient(int *x, int *y) const
1318 {
1319 WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
1320 wxCHECK_RET( window , wxT("TopLevel Window missing") ) ;
1321
1322 Point localwhere = { 0, 0 } ;
1323
1324 if (x)
1325 localwhere.h = *x ;
1326 if (y)
1327 localwhere.v = *y ;
1328
1329 wxMacGlobalToLocal( window , &localwhere ) ;
1330
1331 if (x)
1332 *x = localwhere.h ;
1333 if (y)
1334 *y = localwhere.v ;
1335
1336 MacRootWindowToWindow( x , y ) ;
1337
1338 wxPoint origin = GetClientAreaOrigin() ;
1339 if (x)
1340 *x -= origin.x ;
1341 if (y)
1342 *y -= origin.y ;
1343 }
1344
1345 void wxWindowMac::DoClientToScreen(int *x, int *y) const
1346 {
1347 WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
1348 wxCHECK_RET( window , wxT("TopLevel window missing") ) ;
1349
1350 wxPoint origin = GetClientAreaOrigin() ;
1351 if (x)
1352 *x += origin.x ;
1353 if (y)
1354 *y += origin.y ;
1355
1356 MacWindowToRootWindow( x , y ) ;
1357
1358 Point localwhere = { 0, 0 };
1359 if (x)
1360 localwhere.h = *x ;
1361 if (y)
1362 localwhere.v = *y ;
1363
1364 wxMacLocalToGlobal( window, &localwhere ) ;
1365
1366 if (x)
1367 *x = localwhere.h ;
1368 if (y)
1369 *y = localwhere.v ;
1370 }
1371
1372 void wxWindowMac::MacClientToRootWindow( int *x , int *y ) const
1373 {
1374 wxPoint origin = GetClientAreaOrigin() ;
1375 if (x)
1376 *x += origin.x ;
1377 if (y)
1378 *y += origin.y ;
1379
1380 MacWindowToRootWindow( x , y ) ;
1381 }
1382
1383 void wxWindowMac::MacRootWindowToClient( int *x , int *y ) const
1384 {
1385 MacRootWindowToWindow( x , y ) ;
1386
1387 wxPoint origin = GetClientAreaOrigin() ;
1388 if (x)
1389 *x -= origin.x ;
1390 if (y)
1391 *y -= origin.y ;
1392 }
1393
1394 void wxWindowMac::MacWindowToRootWindow( int *x , int *y ) const
1395 {
1396 wxPoint pt ;
1397
1398 if (x)
1399 pt.x = *x ;
1400 if (y)
1401 pt.y = *y ;
1402
1403 if ( !IsTopLevel() )
1404 {
1405 wxTopLevelWindowMac* top = MacGetTopLevelWindow();
1406 if (top)
1407 {
1408 pt.x -= MacGetLeftBorderSize() ;
1409 pt.y -= MacGetTopBorderSize() ;
1410 wxMacControl::Convert( &pt , m_peer , top->m_peer ) ;
1411 }
1412 }
1413
1414 if (x)
1415 *x = (int) pt.x ;
1416 if (y)
1417 *y = (int) pt.y ;
1418 }
1419
1420 void wxWindowMac::MacWindowToRootWindow( short *x , short *y ) const
1421 {
1422 int x1 , y1 ;
1423
1424 if (x)
1425 x1 = *x ;
1426 if (y)
1427 y1 = *y ;
1428
1429 MacWindowToRootWindow( &x1 , &y1 ) ;
1430
1431 if (x)
1432 *x = x1 ;
1433 if (y)
1434 *y = y1 ;
1435 }
1436
1437 void wxWindowMac::MacRootWindowToWindow( int *x , int *y ) const
1438 {
1439 wxPoint pt ;
1440
1441 if (x)
1442 pt.x = *x ;
1443 if (y)
1444 pt.y = *y ;
1445
1446 if ( !IsTopLevel() )
1447 {
1448 wxTopLevelWindowMac* top = MacGetTopLevelWindow();
1449 if (top)
1450 {
1451 wxMacControl::Convert( &pt , top->m_peer , m_peer ) ;
1452 pt.x += MacGetLeftBorderSize() ;
1453 pt.y += MacGetTopBorderSize() ;
1454 }
1455 }
1456
1457 if (x)
1458 *x = (int) pt.x ;
1459 if (y)
1460 *y = (int) pt.y ;
1461 }
1462
1463 void wxWindowMac::MacRootWindowToWindow( short *x , short *y ) const
1464 {
1465 int x1 , y1 ;
1466
1467 if (x)
1468 x1 = *x ;
1469 if (y)
1470 y1 = *y ;
1471
1472 MacRootWindowToWindow( &x1 , &y1 ) ;
1473
1474 if (x)
1475 *x = x1 ;
1476 if (y)
1477 *y = y1 ;
1478 }
1479
1480 void wxWindowMac::MacGetContentAreaInset( int &left , int &top , int &right , int &bottom )
1481 {
1482 RgnHandle rgn = NewRgn() ;
1483
1484 if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1485 {
1486 Rect structure, content ;
1487
1488 GetRegionBounds( rgn , &content ) ;
1489 m_peer->GetRect( &structure ) ;
1490 OffsetRect( &structure, -structure.left , -structure.top ) ;
1491
1492 left = content.left - structure.left ;
1493 top = content.top - structure.top ;
1494 right = structure.right - content.right ;
1495 bottom = structure.bottom - content.bottom ;
1496 }
1497 else
1498 {
1499 left = top = right = bottom = 0 ;
1500 }
1501
1502 DisposeRgn( rgn ) ;
1503 }
1504
1505 wxSize wxWindowMac::DoGetSizeFromClientSize( const wxSize & size ) const
1506 {
1507 wxSize sizeTotal = size;
1508
1509 RgnHandle rgn = NewRgn() ;
1510 if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1511 {
1512 Rect content, structure ;
1513 GetRegionBounds( rgn , &content ) ;
1514 m_peer->GetRect( &structure ) ;
1515
1516 // structure is in parent coordinates, but we only need width and height, so it's ok
1517
1518 sizeTotal.x += (structure.right - structure.left) - (content.right - content.left) ;
1519 sizeTotal.y += (structure.bottom - structure.top) - (content.bottom - content.top) ;
1520 }
1521
1522 DisposeRgn( rgn ) ;
1523
1524 sizeTotal.x += MacGetLeftBorderSize() + MacGetRightBorderSize() ;
1525 sizeTotal.y += MacGetTopBorderSize() + MacGetBottomBorderSize() ;
1526
1527 return sizeTotal;
1528 }
1529
1530 // Get size *available for subwindows* i.e. excluding menu bar etc.
1531 void wxWindowMac::DoGetClientSize( int *x, int *y ) const
1532 {
1533 int ww, hh;
1534
1535 RgnHandle rgn = NewRgn() ;
1536 Rect content ;
1537 if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1538 GetRegionBounds( rgn , &content ) ;
1539 else
1540 m_peer->GetRect( &content ) ;
1541 DisposeRgn( rgn ) ;
1542
1543 ww = content.right - content.left ;
1544 hh = content.bottom - content.top ;
1545
1546 if (m_hScrollBar && m_hScrollBar->IsShown() )
1547 hh -= m_hScrollBar->GetSize().y ;
1548
1549 if (m_vScrollBar && m_vScrollBar->IsShown() )
1550 ww -= m_vScrollBar->GetSize().x ;
1551
1552 if (x)
1553 *x = ww;
1554 if (y)
1555 *y = hh;
1556 }
1557
1558 bool wxWindowMac::SetCursor(const wxCursor& cursor)
1559 {
1560 if (m_cursor.IsSameAs(cursor))
1561 return false;
1562
1563 if (!cursor.IsOk())
1564 {
1565 if ( ! wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ) )
1566 return false ;
1567 }
1568 else
1569 {
1570 if ( ! wxWindowBase::SetCursor( cursor ) )
1571 return false ;
1572 }
1573
1574 wxASSERT_MSG( m_cursor.Ok(),
1575 wxT("cursor must be valid after call to the base version"));
1576
1577 wxWindowMac *mouseWin = 0 ;
1578 {
1579 wxTopLevelWindowMac *tlw = MacGetTopLevelWindow() ;
1580 WindowRef window = (WindowRef) ( tlw ? tlw->MacGetWindowRef() : 0 ) ;
1581
1582 ControlPartCode part ;
1583 ControlRef control ;
1584 Point pt ;
1585 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1586 HIPoint hiPoint ;
1587 HIGetMousePosition(kHICoordSpaceWindow, window, &hiPoint);
1588 pt.h = hiPoint.x;
1589 pt.v = hiPoint.y;
1590 #else
1591 GetGlobalMouse( &pt );
1592 int x = pt.h;
1593 int y = pt.v;
1594 ScreenToClient(&x, &y);
1595 pt.h = x;
1596 pt.v = y;
1597 #endif
1598 control = FindControlUnderMouse( pt , window , &part ) ;
1599 if ( control )
1600 mouseWin = wxFindControlFromMacControl( control ) ;
1601
1602 }
1603
1604 if ( mouseWin == this && !wxIsBusy() )
1605 m_cursor.MacInstall() ;
1606
1607 return true ;
1608 }
1609
1610 #if wxUSE_MENUS
1611 bool wxWindowMac::DoPopupMenu(wxMenu *menu, int x, int y)
1612 {
1613 #ifndef __WXUNIVERSAL__
1614 menu->SetInvokingWindow((wxWindow*)this);
1615 menu->UpdateUI();
1616
1617 if ( x == wxDefaultCoord && y == wxDefaultCoord )
1618 {
1619 wxPoint mouse = wxGetMousePosition();
1620 x = mouse.x;
1621 y = mouse.y;
1622 }
1623 else
1624 {
1625 ClientToScreen( &x , &y ) ;
1626 }
1627
1628 menu->MacBeforeDisplay( true ) ;
1629 long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() , y, x, 0) ;
1630 if ( HiWord(menuResult) != 0 )
1631 {
1632 MenuCommand macid;
1633 GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
1634 int id = wxMacCommandToId( macid );
1635 wxMenuItem* item = NULL ;
1636 wxMenu* realmenu ;
1637 item = menu->FindItem( id, &realmenu ) ;
1638 if ( item )
1639 {
1640 if (item->IsCheckable())
1641 item->Check( !item->IsChecked() ) ;
1642
1643 menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
1644 }
1645 }
1646
1647 menu->MacAfterDisplay( true ) ;
1648 menu->SetInvokingWindow( NULL );
1649
1650 return true;
1651 #else
1652 // actually this shouldn't be called, because universal is having its own implementation
1653 return false;
1654 #endif
1655 }
1656 #endif
1657
1658 // ----------------------------------------------------------------------------
1659 // tooltips
1660 // ----------------------------------------------------------------------------
1661
1662 #if wxUSE_TOOLTIPS
1663
1664 void wxWindowMac::DoSetToolTip(wxToolTip *tooltip)
1665 {
1666 wxWindowBase::DoSetToolTip(tooltip);
1667
1668 if ( m_tooltip )
1669 m_tooltip->SetWindow(this);
1670 }
1671
1672 #endif
1673
1674 void wxWindowMac::MacInvalidateBorders()
1675 {
1676 if ( m_peer == NULL )
1677 return ;
1678
1679 bool vis = IsShownOnScreen() ;
1680 if ( !vis )
1681 return ;
1682
1683 int outerBorder = MacGetLeftBorderSize() ;
1684 if ( m_peer->NeedsFocusRect() /* && m_peer->HasFocus() */ )
1685 outerBorder += 4 ;
1686
1687 if ( outerBorder == 0 )
1688 return ;
1689
1690 // now we know that we have something to do at all
1691
1692 // as the borders are drawn on the parent we have to properly invalidate all these areas
1693 RgnHandle updateInner , updateOuter;
1694 Rect rect ;
1695
1696 // this rectangle is in HIViewCoordinates under OSX and in Window Coordinates under Carbon
1697 updateInner = NewRgn() ;
1698 updateOuter = NewRgn() ;
1699
1700 m_peer->GetRect( &rect ) ;
1701 RectRgn( updateInner, &rect ) ;
1702 InsetRect( &rect , -outerBorder , -outerBorder ) ;
1703 RectRgn( updateOuter, &rect ) ;
1704 DiffRgn( updateOuter, updateInner , updateOuter ) ;
1705
1706 GetParent()->m_peer->SetNeedsDisplay( updateOuter ) ;
1707
1708 DisposeRgn( updateOuter ) ;
1709 DisposeRgn( updateInner ) ;
1710 }
1711
1712 void wxWindowMac::DoMoveWindow(int x, int y, int width, int height)
1713 {
1714 // this is never called for a toplevel window, so we know we have a parent
1715 int former_x , former_y , former_w, former_h ;
1716
1717 // Get true coordinates of former position
1718 DoGetPosition( &former_x , &former_y ) ;
1719 DoGetSize( &former_w , &former_h ) ;
1720
1721 wxWindow *parent = GetParent();
1722 if ( parent )
1723 {
1724 wxPoint pt(parent->GetClientAreaOrigin());
1725 former_x += pt.x ;
1726 former_y += pt.y ;
1727 }
1728
1729 int actualWidth = width ;
1730 int actualHeight = height ;
1731 int actualX = x;
1732 int actualY = y;
1733
1734 if ((m_minWidth != -1) && (actualWidth < m_minWidth))
1735 actualWidth = m_minWidth;
1736 if ((m_minHeight != -1) && (actualHeight < m_minHeight))
1737 actualHeight = m_minHeight;
1738 if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
1739 actualWidth = m_maxWidth;
1740 if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
1741 actualHeight = m_maxHeight;
1742
1743 bool doMove = false, doResize = false ;
1744
1745 if ( actualX != former_x || actualY != former_y )
1746 doMove = true ;
1747
1748 if ( actualWidth != former_w || actualHeight != former_h )
1749 doResize = true ;
1750
1751 if ( doMove || doResize )
1752 {
1753 // as the borders are drawn outside the native control, we adjust now
1754
1755 wxRect bounds( wxPoint( actualX + MacGetLeftBorderSize() ,actualY + MacGetTopBorderSize() ),
1756 wxSize( actualWidth - (MacGetLeftBorderSize() + MacGetRightBorderSize()) ,
1757 actualHeight - (MacGetTopBorderSize() + MacGetBottomBorderSize()) ) ) ;
1758
1759 Rect r ;
1760 wxMacRectToNative( &bounds , &r ) ;
1761
1762 if ( !GetParent()->IsTopLevel() )
1763 wxMacWindowToNative( GetParent() , &r ) ;
1764
1765 MacInvalidateBorders() ;
1766
1767 m_cachedClippedRectValid = false ;
1768 m_peer->SetRect( &r ) ;
1769
1770 wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
1771
1772 MacInvalidateBorders() ;
1773
1774 MacRepositionScrollBars() ;
1775 if ( doMove )
1776 {
1777 wxPoint point(actualX, actualY);
1778 wxMoveEvent event(point, m_windowId);
1779 event.SetEventObject(this);
1780 HandleWindowEvent(event) ;
1781 }
1782
1783 if ( doResize )
1784 {
1785 MacRepositionScrollBars() ;
1786 wxSize size(actualWidth, actualHeight);
1787 wxSizeEvent event(size, m_windowId);
1788 event.SetEventObject(this);
1789 HandleWindowEvent(event);
1790 }
1791 }
1792 }
1793
1794 wxSize wxWindowMac::DoGetBestSize() const
1795 {
1796 if ( m_macIsUserPane || IsTopLevel() )
1797 return wxWindowBase::DoGetBestSize() ;
1798
1799 Rect bestsize = { 0 , 0 , 0 , 0 } ;
1800 int bestWidth, bestHeight ;
1801
1802 m_peer->GetBestRect( &bestsize ) ;
1803 if ( EmptyRect( &bestsize ) )
1804 {
1805 bestsize.left =
1806 bestsize.top = 0 ;
1807 bestsize.right =
1808 bestsize.bottom = 16 ;
1809
1810 if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
1811 {
1812 bestsize.bottom = 16 ;
1813 }
1814 #if wxUSE_SPINBTN
1815 else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
1816 {
1817 bestsize.bottom = 24 ;
1818 }
1819 #endif
1820 else
1821 {
1822 // return wxWindowBase::DoGetBestSize() ;
1823 }
1824 }
1825
1826 bestWidth = bestsize.right - bestsize.left ;
1827 bestHeight = bestsize.bottom - bestsize.top ;
1828 if ( bestHeight < 10 )
1829 bestHeight = 13 ;
1830
1831 return wxSize(bestWidth, bestHeight);
1832 }
1833
1834 // set the size of the window: if the dimensions are positive, just use them,
1835 // but if any of them is equal to -1, it means that we must find the value for
1836 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1837 // which case -1 is a valid value for x and y)
1838 //
1839 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1840 // the width/height to best suit our contents, otherwise we reuse the current
1841 // width/height
1842 void wxWindowMac::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1843 {
1844 // get the current size and position...
1845 int currentX, currentY;
1846 int currentW, currentH;
1847
1848 GetPosition(&currentX, &currentY);
1849 GetSize(&currentW, &currentH);
1850
1851 // ... and don't do anything (avoiding flicker) if it's already ok
1852 if ( x == currentX && y == currentY &&
1853 width == currentW && height == currentH && ( height != -1 && width != -1 ) )
1854 {
1855 // TODO: REMOVE
1856 MacRepositionScrollBars() ; // we might have a real position shift
1857
1858 return;
1859 }
1860
1861 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1862 {
1863 if ( x == wxDefaultCoord )
1864 x = currentX;
1865 if ( y == wxDefaultCoord )
1866 y = currentY;
1867 }
1868
1869 AdjustForParentClientOrigin( x, y, sizeFlags );
1870
1871 wxSize size = wxDefaultSize;
1872 if ( width == wxDefaultCoord )
1873 {
1874 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1875 {
1876 size = DoGetBestSize();
1877 width = size.x;
1878 }
1879 else
1880 {
1881 // just take the current one
1882 width = currentW;
1883 }
1884 }
1885
1886 if ( height == wxDefaultCoord )
1887 {
1888 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1889 {
1890 if ( size.x == wxDefaultCoord )
1891 size = DoGetBestSize();
1892 // else: already called DoGetBestSize() above
1893
1894 height = size.y;
1895 }
1896 else
1897 {
1898 // just take the current one
1899 height = currentH;
1900 }
1901 }
1902
1903 DoMoveWindow( x, y, width, height );
1904 }
1905
1906 wxPoint wxWindowMac::GetClientAreaOrigin() const
1907 {
1908 RgnHandle rgn = NewRgn() ;
1909 Rect content ;
1910 if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
1911 {
1912 GetRegionBounds( rgn , &content ) ;
1913 }
1914 else
1915 {
1916 content.left =
1917 content.top = 0 ;
1918 }
1919
1920 DisposeRgn( rgn ) ;
1921
1922 return wxPoint( content.left + MacGetLeftBorderSize() , content.top + MacGetTopBorderSize() );
1923 }
1924
1925 void wxWindowMac::DoSetClientSize(int clientwidth, int clientheight)
1926 {
1927 if ( clientwidth != wxDefaultCoord || clientheight != wxDefaultCoord )
1928 {
1929 int currentclientwidth , currentclientheight ;
1930 int currentwidth , currentheight ;
1931
1932 GetClientSize( &currentclientwidth , &currentclientheight ) ;
1933 GetSize( &currentwidth , &currentheight ) ;
1934
1935 DoSetSize( wxDefaultCoord , wxDefaultCoord , currentwidth + clientwidth - currentclientwidth ,
1936 currentheight + clientheight - currentclientheight , wxSIZE_USE_EXISTING ) ;
1937 }
1938 }
1939
1940 void wxWindowMac::SetLabel(const wxString& title)
1941 {
1942 m_label = title ;
1943
1944 if ( m_peer && m_peer->Ok() )
1945 m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics) ) ;
1946
1947 // do not trigger refreshes upon invisible and possible partly created objects
1948 if ( IsShownOnScreen() )
1949 Refresh() ;
1950 }
1951
1952 wxString wxWindowMac::GetLabel() const
1953 {
1954 return m_label ;
1955 }
1956
1957 bool wxWindowMac::Show(bool show)
1958 {
1959 if ( !wxWindowBase::Show(show) )
1960 return false;
1961
1962 if ( m_peer )
1963 m_peer->SetVisibility( show , true ) ;
1964
1965 return true;
1966 }
1967
1968 void wxWindowMac::DoEnable(bool enable)
1969 {
1970 m_peer->Enable( enable ) ;
1971 }
1972
1973 //
1974 // status change notifications
1975 //
1976
1977 void wxWindowMac::MacVisibilityChanged()
1978 {
1979 }
1980
1981 void wxWindowMac::MacHiliteChanged()
1982 {
1983 }
1984
1985 void wxWindowMac::MacEnabledStateChanged()
1986 {
1987 OnEnabled( m_peer->IsEnabled() );
1988 }
1989
1990 //
1991 // status queries on the inherited window's state
1992 //
1993
1994 bool wxWindowMac::MacIsReallyEnabled()
1995 {
1996 return m_peer->IsEnabled() ;
1997 }
1998
1999 bool wxWindowMac::MacIsReallyHilited()
2000 {
2001 return m_peer->IsActive();
2002 }
2003
2004 void wxWindowMac::MacFlashInvalidAreas()
2005 {
2006 #if TARGET_API_MAC_OSX
2007 HIViewFlashDirtyArea( (WindowRef) MacGetTopLevelWindowRef() ) ;
2008 #endif
2009 }
2010
2011 int wxWindowMac::GetCharHeight() const
2012 {
2013 wxClientDC dc( (wxWindowMac*)this ) ;
2014
2015 return dc.GetCharHeight() ;
2016 }
2017
2018 int wxWindowMac::GetCharWidth() const
2019 {
2020 wxClientDC dc( (wxWindowMac*)this ) ;
2021
2022 return dc.GetCharWidth() ;
2023 }
2024
2025 void wxWindowMac::GetTextExtent(const wxString& string, int *x, int *y,
2026 int *descent, int *externalLeading, const wxFont *theFont ) const
2027 {
2028 const wxFont *fontToUse = theFont;
2029 if ( !fontToUse )
2030 fontToUse = &m_font;
2031
2032 wxClientDC dc( (wxWindowMac*) this ) ;
2033 wxCoord lx,ly,ld,le ;
2034 dc.GetTextExtent( string , &lx , &ly , &ld, &le, (wxFont *)fontToUse ) ;
2035 if ( externalLeading )
2036 *externalLeading = le ;
2037 if ( descent )
2038 *descent = ld ;
2039 if ( x )
2040 *x = lx ;
2041 if ( y )
2042 *y = ly ;
2043 }
2044
2045 /*
2046 * Rect is given in client coordinates, for further reading, read wxTopLevelWindowMac::InvalidateRect
2047 * we always intersect with the entire window, not only with the client area
2048 */
2049
2050 void wxWindowMac::Refresh(bool WXUNUSED(eraseBack), const wxRect *rect)
2051 {
2052 if ( m_peer == NULL )
2053 return ;
2054
2055 if ( !IsShownOnScreen() )
2056 return ;
2057
2058 if ( rect )
2059 {
2060 Rect r ;
2061
2062 wxMacRectToNative( rect , &r ) ;
2063 m_peer->SetNeedsDisplay( &r ) ;
2064 }
2065 else
2066 {
2067 m_peer->SetNeedsDisplay() ;
2068 }
2069 }
2070
2071 void wxWindowMac::DoFreeze()
2072 {
2073 #if TARGET_API_MAC_OSX
2074 if ( m_peer && m_peer->Ok() )
2075 m_peer->SetDrawingEnabled( false ) ;
2076 #endif
2077 }
2078
2079 void wxWindowMac::DoThaw()
2080 {
2081 #if TARGET_API_MAC_OSX
2082 if ( m_peer && m_peer->Ok() )
2083 {
2084 m_peer->SetDrawingEnabled( true ) ;
2085 m_peer->InvalidateWithChildren() ;
2086 }
2087 #endif
2088 }
2089
2090 wxWindowMac *wxGetActiveWindow()
2091 {
2092 // actually this is a windows-only concept
2093 return NULL;
2094 }
2095
2096 // Coordinates relative to the window
2097 void wxWindowMac::WarpPointer(int WXUNUSED(x_pos), int WXUNUSED(y_pos))
2098 {
2099 // We really don't move the mouse programmatically under Mac.
2100 }
2101
2102 void wxWindowMac::OnEraseBackground(wxEraseEvent& event)
2103 {
2104 if ( MacGetTopLevelWindow() == NULL )
2105 return ;
2106 /*
2107 #if TARGET_API_MAC_OSX
2108 if ( !m_backgroundColour.Ok() || GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
2109 {
2110 }
2111 else
2112 #endif
2113 */
2114 if ( GetBackgroundStyle() == wxBG_STYLE_COLOUR )
2115 {
2116 event.GetDC()->Clear() ;
2117 }
2118 else
2119 {
2120 event.Skip() ;
2121 }
2122 }
2123
2124 void wxWindowMac::OnNcPaint( wxNcPaintEvent& event )
2125 {
2126 event.Skip() ;
2127 }
2128
2129 int wxWindowMac::GetScrollPos(int orient) const
2130 {
2131 if ( orient == wxHORIZONTAL )
2132 {
2133 if ( m_hScrollBar )
2134 return m_hScrollBar->GetThumbPosition() ;
2135 }
2136 else
2137 {
2138 if ( m_vScrollBar )
2139 return m_vScrollBar->GetThumbPosition() ;
2140 }
2141
2142 return 0;
2143 }
2144
2145 // This now returns the whole range, not just the number
2146 // of positions that we can scroll.
2147 int wxWindowMac::GetScrollRange(int orient) const
2148 {
2149 if ( orient == wxHORIZONTAL )
2150 {
2151 if ( m_hScrollBar )
2152 return m_hScrollBar->GetRange() ;
2153 }
2154 else
2155 {
2156 if ( m_vScrollBar )
2157 return m_vScrollBar->GetRange() ;
2158 }
2159
2160 return 0;
2161 }
2162
2163 int wxWindowMac::GetScrollThumb(int orient) const
2164 {
2165 if ( orient == wxHORIZONTAL )
2166 {
2167 if ( m_hScrollBar )
2168 return m_hScrollBar->GetThumbSize() ;
2169 }
2170 else
2171 {
2172 if ( m_vScrollBar )
2173 return m_vScrollBar->GetThumbSize() ;
2174 }
2175
2176 return 0;
2177 }
2178
2179 void wxWindowMac::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
2180 {
2181 if ( orient == wxHORIZONTAL )
2182 {
2183 if ( m_hScrollBar )
2184 m_hScrollBar->SetThumbPosition( pos ) ;
2185 }
2186 else
2187 {
2188 if ( m_vScrollBar )
2189 m_vScrollBar->SetThumbPosition( pos ) ;
2190 }
2191 }
2192
2193 void
2194 wxWindowMac::AlwaysShowScrollbars(bool hflag, bool vflag)
2195 {
2196 bool needVisibilityUpdate = false;
2197
2198 if ( m_hScrollBarAlwaysShown != hflag )
2199 {
2200 m_hScrollBarAlwaysShown = hflag;
2201 needVisibilityUpdate = true;
2202 }
2203
2204 if ( m_vScrollBarAlwaysShown != vflag )
2205 {
2206 m_vScrollBarAlwaysShown = vflag;
2207 needVisibilityUpdate = true;
2208 }
2209
2210 if ( needVisibilityUpdate )
2211 DoUpdateScrollbarVisibility();
2212 }
2213
2214 //
2215 // we draw borders and grow boxes, are already set up and clipped in the current port / cgContextRef
2216 // our own window origin is at leftOrigin/rightOrigin
2217 //
2218
2219 void wxWindowMac::MacPaintGrowBox()
2220 {
2221 if ( IsTopLevel() )
2222 return ;
2223
2224 if ( MacHasScrollBarCorner() )
2225 {
2226 Rect rect ;
2227
2228 CGContextRef cgContext = (CGContextRef) MacGetCGContextRef() ;
2229 wxASSERT( cgContext ) ;
2230
2231 m_peer->GetRect( &rect ) ;
2232
2233 int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2234 CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
2235 CGPoint cgpoint = CGPointMake( rect.right - size , rect.bottom - size ) ;
2236 CGContextSaveGState( cgContext );
2237
2238 if ( m_backgroundColour.Ok() )
2239 {
2240 CGContextSetFillColorWithColor( cgContext, m_backgroundColour.GetCGColor() );
2241 }
2242 else
2243 {
2244 CGContextSetRGBFillColor( cgContext, 1.0, 1.0 , 1.0 , 1.0 );
2245 }
2246 CGContextFillRect( cgContext, cgrect );
2247 CGContextRestoreGState( cgContext );
2248 }
2249 }
2250
2251 void wxWindowMac::MacPaintBorders( int WXUNUSED(leftOrigin) , int WXUNUSED(rightOrigin) )
2252 {
2253 if ( IsTopLevel() )
2254 return ;
2255
2256 Rect rect ;
2257 bool hasFocus = m_peer->NeedsFocusRect() && m_peer->HasFocus() ;
2258
2259 // back to the surrounding frame rectangle
2260 m_peer->GetRect( &rect ) ;
2261 InsetRect( &rect, -1 , -1 ) ;
2262
2263 {
2264 CGRect cgrect = CGRectMake( rect.left , rect.top , rect.right - rect.left ,
2265 rect.bottom - rect.top ) ;
2266
2267 HIThemeFrameDrawInfo info ;
2268 memset( &info, 0 , sizeof(info) ) ;
2269
2270 info.version = 0 ;
2271 info.kind = 0 ;
2272 info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
2273 info.isFocused = hasFocus ;
2274
2275 CGContextRef cgContext = (CGContextRef) GetParent()->MacGetCGContextRef() ;
2276 wxASSERT( cgContext ) ;
2277
2278 if ( HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER) )
2279 {
2280 info.kind = kHIThemeFrameTextFieldSquare ;
2281 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
2282 }
2283 else if ( HasFlag(wxSIMPLE_BORDER) )
2284 {
2285 info.kind = kHIThemeFrameListBox ;
2286 HIThemeDrawFrame( &cgrect , &info , cgContext , kHIThemeOrientationNormal ) ;
2287 }
2288 else if ( hasFocus )
2289 {
2290 HIThemeDrawFocusRect( &cgrect , true , cgContext , kHIThemeOrientationNormal ) ;
2291 }
2292 #if 0 // TODO REMOVE now done in a separate call earlier in drawing the window itself
2293 m_peer->GetRect( &rect ) ;
2294 if ( MacHasScrollBarCorner() )
2295 {
2296 int variant = (m_hScrollBar == NULL ? m_vScrollBar : m_hScrollBar ) ->GetWindowVariant();
2297 int size = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2298 CGRect cgrect = CGRectMake( rect.right - size , rect.bottom - size , size , size ) ;
2299 CGPoint cgpoint = CGPointMake( rect.right - size , rect.bottom - size ) ;
2300 HIThemeGrowBoxDrawInfo info ;
2301 memset( &info, 0, sizeof(info) ) ;
2302 info.version = 0 ;
2303 info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ;
2304 info.kind = kHIThemeGrowBoxKindNone ;
2305 // contrary to the docs ...SizeSmall does not work
2306 info.size = kHIThemeGrowBoxSizeNormal ;
2307 info.direction = 0 ;
2308 HIThemeDrawGrowBox( &cgpoint , &info , cgContext , kHIThemeOrientationNormal ) ;
2309 }
2310 #endif
2311 }
2312 }
2313
2314 void wxWindowMac::RemoveChild( wxWindowBase *child )
2315 {
2316 if ( child == m_hScrollBar )
2317 m_hScrollBar = NULL ;
2318 if ( child == m_vScrollBar )
2319 m_vScrollBar = NULL ;
2320
2321 wxWindowBase::RemoveChild( child ) ;
2322 }
2323
2324 void wxWindowMac::DoUpdateScrollbarVisibility()
2325 {
2326 bool triggerSizeEvent = false;
2327
2328 if ( m_hScrollBar )
2329 {
2330 bool showHScrollBar = m_hScrollBarAlwaysShown || m_hScrollBar->IsNeeded();
2331
2332 if ( m_hScrollBar->IsShown() != showHScrollBar )
2333 {
2334 m_hScrollBar->Show( showHScrollBar );
2335 triggerSizeEvent = true;
2336 }
2337 }
2338
2339 if ( m_vScrollBar)
2340 {
2341 bool showVScrollBar = m_vScrollBarAlwaysShown || m_vScrollBar->IsNeeded();
2342
2343 if ( m_vScrollBar->IsShown() != showVScrollBar )
2344 {
2345 m_vScrollBar->Show( showVScrollBar ) ;
2346 triggerSizeEvent = true;
2347 }
2348 }
2349
2350 MacRepositionScrollBars() ;
2351 if ( triggerSizeEvent )
2352 {
2353 wxSizeEvent event(GetSize(), m_windowId);
2354 event.SetEventObject(this);
2355 HandleWindowEvent(event);
2356 }
2357 }
2358
2359 // New function that will replace some of the above.
2360 void wxWindowMac::SetScrollbar(int orient, int pos, int thumb,
2361 int range, bool refresh)
2362 {
2363 if ( orient == wxHORIZONTAL && m_hScrollBar )
2364 m_hScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
2365 else if ( orient == wxVERTICAL && m_vScrollBar )
2366 m_vScrollBar->SetScrollbar(pos, thumb, range, thumb, refresh);
2367
2368 DoUpdateScrollbarVisibility();
2369 }
2370
2371 // Does a physical scroll
2372 void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
2373 {
2374 if ( dx == 0 && dy == 0 )
2375 return ;
2376
2377 int width , height ;
2378 GetClientSize( &width , &height ) ;
2379
2380 {
2381 // note there currently is a bug in OSX which makes inefficient refreshes in case an entire control
2382 // area is scrolled, this does not occur if width and height are 2 pixels less,
2383 // TODO: write optimal workaround
2384 wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
2385 if ( rect )
2386 scrollrect.Intersect( *rect ) ;
2387
2388 if ( m_peer->GetNeedsDisplay() )
2389 {
2390 // because HIViewScrollRect does not scroll the already invalidated area we have two options:
2391 // in case there is already a pending redraw on that area
2392 // either immediate redraw or full invalidate
2393 #if 1
2394 // is the better overall solution, as it does not slow down scrolling
2395 m_peer->SetNeedsDisplay() ;
2396 #else
2397 // this would be the preferred version for fast drawing controls
2398 HIViewRender(m_peer->GetControlRef()) ;
2399 #endif
2400 }
2401
2402 // as the native control might be not a 0/0 wx window coordinates, we have to offset
2403 scrollrect.Offset( -MacGetLeftBorderSize() , -MacGetTopBorderSize() ) ;
2404 m_peer->ScrollRect( &scrollrect , dx , dy ) ;
2405
2406 #if 0
2407 // this would be the preferred version for fast drawing controls
2408 HIViewRender(m_peer->GetControlRef()) ;
2409 #endif
2410 }
2411
2412 wxWindowMac *child;
2413 int x, y, w, h;
2414 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
2415 {
2416 child = node->GetData();
2417 if (child == NULL)
2418 continue;
2419 if (child == m_vScrollBar)
2420 continue;
2421 if (child == m_hScrollBar)
2422 continue;
2423 if (child->IsTopLevel())
2424 continue;
2425
2426 child->GetPosition( &x, &y );
2427 child->GetSize( &w, &h );
2428 if (rect)
2429 {
2430 wxRect rc( x, y, w, h );
2431 if (rect->Intersects( rc ))
2432 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
2433 }
2434 else
2435 {
2436 child->SetSize( x + dx, y + dy, w, h, wxSIZE_AUTO|wxSIZE_ALLOW_MINUS_ONE );
2437 }
2438 }
2439 }
2440
2441 void wxWindowMac::MacOnScroll( wxScrollEvent &event )
2442 {
2443 if ( event.GetEventObject() == m_vScrollBar || event.GetEventObject() == m_hScrollBar )
2444 {
2445 wxScrollWinEvent wevent;
2446 wevent.SetPosition(event.GetPosition());
2447 wevent.SetOrientation(event.GetOrientation());
2448 wevent.SetEventObject(this);
2449
2450 if (event.GetEventType() == wxEVT_SCROLL_TOP)
2451 wevent.SetEventType( wxEVT_SCROLLWIN_TOP );
2452 else if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
2453 wevent.SetEventType( wxEVT_SCROLLWIN_BOTTOM );
2454 else if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
2455 wevent.SetEventType( wxEVT_SCROLLWIN_LINEUP );
2456 else if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
2457 wevent.SetEventType( wxEVT_SCROLLWIN_LINEDOWN );
2458 else if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
2459 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEUP );
2460 else if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
2461 wevent.SetEventType( wxEVT_SCROLLWIN_PAGEDOWN );
2462 else if (event.GetEventType() == wxEVT_SCROLL_THUMBTRACK)
2463 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBTRACK );
2464 else if (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE)
2465 wevent.SetEventType( wxEVT_SCROLLWIN_THUMBRELEASE );
2466
2467 HandleWindowEvent(wevent);
2468 }
2469 }
2470
2471 // Get the window with the focus
2472 wxWindowMac *wxWindowBase::DoFindFocus()
2473 {
2474 ControlRef control ;
2475 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
2476 return wxFindControlFromMacControl( control ) ;
2477 }
2478
2479 void wxWindowMac::OnInternalIdle()
2480 {
2481 // This calls the UI-update mechanism (querying windows for
2482 // menu/toolbar/control state information)
2483 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2484 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2485 }
2486
2487 // Raise the window to the top of the Z order
2488 void wxWindowMac::Raise()
2489 {
2490 m_peer->SetZOrder( true , NULL ) ;
2491 }
2492
2493 // Lower the window to the bottom of the Z order
2494 void wxWindowMac::Lower()
2495 {
2496 m_peer->SetZOrder( false , NULL ) ;
2497 }
2498
2499 // static wxWindow *gs_lastWhich = NULL;
2500
2501 bool wxWindowMac::MacSetupCursor( const wxPoint& pt )
2502 {
2503 // first trigger a set cursor event
2504
2505 wxPoint clientorigin = GetClientAreaOrigin() ;
2506 wxSize clientsize = GetClientSize() ;
2507 wxCursor cursor ;
2508 if ( wxRect2DInt( clientorigin.x , clientorigin.y , clientsize.x , clientsize.y ).Contains( wxPoint2DInt( pt ) ) )
2509 {
2510 wxSetCursorEvent event( pt.x , pt.y );
2511
2512 bool processedEvtSetCursor = HandleWindowEvent(event);
2513 if ( processedEvtSetCursor && event.HasCursor() )
2514 {
2515 cursor = event.GetCursor() ;
2516 }
2517 else
2518 {
2519 // the test for processedEvtSetCursor is here to prevent using m_cursor
2520 // if the user code caught EVT_SET_CURSOR() and returned nothing from
2521 // it - this is a way to say that our cursor shouldn't be used for this
2522 // point
2523 if ( !processedEvtSetCursor && m_cursor.Ok() )
2524 cursor = m_cursor ;
2525
2526 if ( !wxIsBusy() && !GetParent() )
2527 cursor = *wxSTANDARD_CURSOR ;
2528 }
2529
2530 if ( cursor.Ok() )
2531 cursor.MacInstall() ;
2532 }
2533
2534 return cursor.Ok() ;
2535 }
2536
2537 wxString wxWindowMac::MacGetToolTipString( wxPoint &WXUNUSED(pt) )
2538 {
2539 #if wxUSE_TOOLTIPS
2540 if ( m_tooltip )
2541 return m_tooltip->GetTip() ;
2542 #endif
2543
2544 return wxEmptyString ;
2545 }
2546
2547 void wxWindowMac::ClearBackground()
2548 {
2549 Refresh() ;
2550 Update() ;
2551 }
2552
2553 void wxWindowMac::Update()
2554 {
2555 wxTopLevelWindowMac* top = MacGetTopLevelWindow();
2556 if (top)
2557 top->MacPerformUpdates() ;
2558 }
2559
2560 wxTopLevelWindowMac* wxWindowMac::MacGetTopLevelWindow() const
2561 {
2562 wxTopLevelWindowMac* win = NULL ;
2563 WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
2564 if ( window )
2565 win = wxFindWinFromMacWindow( window ) ;
2566
2567 return win ;
2568 }
2569
2570 const wxRect& wxWindowMac::MacGetClippedClientRect() const
2571 {
2572 MacUpdateClippedRects() ;
2573
2574 return m_cachedClippedClientRect ;
2575 }
2576
2577 const wxRect& wxWindowMac::MacGetClippedRect() const
2578 {
2579 MacUpdateClippedRects() ;
2580
2581 return m_cachedClippedRect ;
2582 }
2583
2584 const wxRect&wxWindowMac:: MacGetClippedRectWithOuterStructure() const
2585 {
2586 MacUpdateClippedRects() ;
2587
2588 return m_cachedClippedRectWithOuterStructure ;
2589 }
2590
2591 const wxRegion& wxWindowMac::MacGetVisibleRegion( bool includeOuterStructures )
2592 {
2593 static wxRegion emptyrgn ;
2594
2595 if ( !m_isBeingDeleted && IsShownOnScreen() )
2596 {
2597 MacUpdateClippedRects() ;
2598 if ( includeOuterStructures )
2599 return m_cachedClippedRegionWithOuterStructure ;
2600 else
2601 return m_cachedClippedRegion ;
2602 }
2603 else
2604 {
2605 return emptyrgn ;
2606 }
2607 }
2608
2609 void wxWindowMac::MacUpdateClippedRects() const
2610 {
2611 if ( m_cachedClippedRectValid )
2612 return ;
2613
2614 // includeOuterStructures is true if we try to draw somthing like a focus ring etc.
2615 // also a window dc uses this, in this case we only clip in the hierarchy for hard
2616 // borders like a scrollwindow, splitter etc otherwise we end up in a paranoia having
2617 // to add focus borders everywhere
2618
2619 Rect r, rIncludingOuterStructures ;
2620
2621 m_peer->GetRect( &r ) ;
2622 r.left -= MacGetLeftBorderSize() ;
2623 r.top -= MacGetTopBorderSize() ;
2624 r.bottom += MacGetBottomBorderSize() ;
2625 r.right += MacGetRightBorderSize() ;
2626
2627 r.right -= r.left ;
2628 r.bottom -= r.top ;
2629 r.left = 0 ;
2630 r.top = 0 ;
2631
2632 rIncludingOuterStructures = r ;
2633 InsetRect( &rIncludingOuterStructures , -4 , -4 ) ;
2634
2635 wxRect cl = GetClientRect() ;
2636 Rect rClient = { cl.y , cl.x , cl.y + cl.height , cl.x + cl.width } ;
2637
2638 int x , y ;
2639 wxSize size ;
2640 const wxWindow* child = this ;
2641 const wxWindow* parent = NULL ;
2642
2643 while ( !child->IsTopLevel() && ( parent = child->GetParent() ) != NULL )
2644 {
2645 if ( parent->MacIsChildOfClientArea(child) )
2646 {
2647 size = parent->GetClientSize() ;
2648 wxPoint origin = parent->GetClientAreaOrigin() ;
2649 x = origin.x ;
2650 y = origin.y ;
2651 }
2652 else
2653 {
2654 // this will be true for scrollbars, toolbars etc.
2655 size = parent->GetSize() ;
2656 y = parent->MacGetTopBorderSize() ;
2657 x = parent->MacGetLeftBorderSize() ;
2658 size.x -= parent->MacGetLeftBorderSize() + parent->MacGetRightBorderSize() ;
2659 size.y -= parent->MacGetTopBorderSize() + parent->MacGetBottomBorderSize() ;
2660 }
2661
2662 parent->MacWindowToRootWindow( &x, &y ) ;
2663 MacRootWindowToWindow( &x , &y ) ;
2664
2665 Rect rparent = { y , x , y + size.y , x + size.x } ;
2666
2667 // the wxwindow and client rects will always be clipped
2668 SectRect( &r , &rparent , &r ) ;
2669 SectRect( &rClient , &rparent , &rClient ) ;
2670
2671 // the structure only at 'hard' borders
2672 if ( parent->MacClipChildren() ||
2673 ( parent->GetParent() && parent->GetParent()->MacClipGrandChildren() ) )
2674 {
2675 SectRect( &rIncludingOuterStructures , &rparent , &rIncludingOuterStructures ) ;
2676 }
2677
2678 child = parent ;
2679 }
2680
2681 m_cachedClippedRect = wxRect( r.left , r.top , r.right - r.left , r.bottom - r.top ) ;
2682 m_cachedClippedClientRect = wxRect( rClient.left , rClient.top ,
2683 rClient.right - rClient.left , rClient.bottom - rClient.top ) ;
2684 m_cachedClippedRectWithOuterStructure = wxRect(
2685 rIncludingOuterStructures.left , rIncludingOuterStructures.top ,
2686 rIncludingOuterStructures.right - rIncludingOuterStructures.left ,
2687 rIncludingOuterStructures.bottom - rIncludingOuterStructures.top ) ;
2688
2689 m_cachedClippedRegionWithOuterStructure = wxRegion( m_cachedClippedRectWithOuterStructure ) ;
2690 m_cachedClippedRegion = wxRegion( m_cachedClippedRect ) ;
2691 m_cachedClippedClientRegion = wxRegion( m_cachedClippedClientRect ) ;
2692
2693 m_cachedClippedRectValid = true ;
2694 }
2695
2696 /*
2697 This function must not change the updatergn !
2698 */
2699 bool wxWindowMac::MacDoRedraw( void* updatergnr , long time )
2700 {
2701 bool handled = false ;
2702 Rect updatebounds ;
2703 RgnHandle updatergn = (RgnHandle) updatergnr ;
2704 GetRegionBounds( updatergn , &updatebounds ) ;
2705
2706 // wxLogDebug(wxT("update for %s bounds %d, %d, %d, %d"), wxString(GetClassInfo()->GetClassName()).c_str(), updatebounds.left, updatebounds.top , updatebounds.right , updatebounds.bottom ) ;
2707
2708 if ( !EmptyRgn(updatergn) )
2709 {
2710 RgnHandle newupdate = NewRgn() ;
2711 wxSize point = GetClientSize() ;
2712 wxPoint origin = GetClientAreaOrigin() ;
2713 SetRectRgn( newupdate , origin.x , origin.y , origin.x + point.x , origin.y + point.y ) ;
2714 SectRgn( newupdate , updatergn , newupdate ) ;
2715
2716 // first send an erase event to the entire update area
2717 {
2718 // for the toplevel window this really is the entire area
2719 // for all the others only their client area, otherwise they
2720 // might be drawing with full alpha and eg put blue into
2721 // the grow-box area of a scrolled window (scroll sample)
2722 wxDC* dc = new wxWindowDC(this);
2723 if ( IsTopLevel() )
2724 dc->SetClippingRegion(wxRegion(HIShapeCreateWithQDRgn(updatergn)));
2725 else
2726 dc->SetClippingRegion(wxRegion(HIShapeCreateWithQDRgn(newupdate)));
2727
2728 wxEraseEvent eevent( GetId(), dc );
2729 eevent.SetEventObject( this );
2730 HandleWindowEvent( eevent );
2731 delete dc ;
2732 }
2733
2734 MacPaintGrowBox();
2735
2736 // calculate a client-origin version of the update rgn and set m_updateRegion to that
2737 OffsetRgn( newupdate , -origin.x , -origin.y ) ;
2738 m_updateRegion = wxRegion(HIShapeCreateWithQDRgn(newupdate)) ;
2739 DisposeRgn( newupdate ) ;
2740
2741 if ( !m_updateRegion.Empty() )
2742 {
2743 // paint the window itself
2744
2745 wxPaintEvent event;
2746 event.SetTimestamp(time);
2747 event.SetEventObject(this);
2748 HandleWindowEvent(event);
2749 handled = true ;
2750 }
2751
2752 // now we cannot rely on having its borders drawn by a window itself, as it does not
2753 // get the updateRgn wide enough to always do so, so we do it from the parent
2754 // this would also be the place to draw any custom backgrounds for native controls
2755 // in Composited windowing
2756 wxPoint clientOrigin = GetClientAreaOrigin() ;
2757
2758 wxWindowMac *child;
2759 int x, y, w, h;
2760 for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext())
2761 {
2762 child = node->GetData();
2763 if (child == NULL)
2764 continue;
2765 if (child == m_vScrollBar)
2766 continue;
2767 if (child == m_hScrollBar)
2768 continue;
2769 if (child->IsTopLevel())
2770 continue;
2771 if (!child->IsShown())
2772 continue;
2773
2774 // only draw those in the update region (add a safety margin of 10 pixels for shadow effects
2775
2776 child->GetPosition( &x, &y );
2777 child->GetSize( &w, &h );
2778 Rect childRect = { y , x , y + h , x + w } ;
2779 OffsetRect( &childRect , clientOrigin.x , clientOrigin.y ) ;
2780 InsetRect( &childRect , -10 , -10) ;
2781
2782 if ( RectInRgn( &childRect , updatergn ) )
2783 {
2784 // paint custom borders
2785 wxNcPaintEvent eventNc( child->GetId() );
2786 eventNc.SetEventObject( child );
2787 if ( !child->HandleWindowEvent( eventNc ) )
2788 {
2789 child->MacPaintBorders(0, 0) ;
2790 }
2791 }
2792 }
2793 }
2794
2795 return handled ;
2796 }
2797
2798
2799 WXWindow wxWindowMac::MacGetTopLevelWindowRef() const
2800 {
2801 wxWindowMac *iter = (wxWindowMac*)this ;
2802
2803 while ( iter )
2804 {
2805 if ( iter->IsTopLevel() )
2806 {
2807 wxTopLevelWindow* toplevel = wxDynamicCast(iter,wxTopLevelWindow);
2808 if ( toplevel )
2809 return toplevel->MacGetWindowRef();
2810 #if wxUSE_POPUPWIN
2811 wxPopupWindow* popupwin = wxDynamicCast(iter,wxPopupWindow);
2812 if ( popupwin )
2813 return popupwin->MacGetPopupWindowRef();
2814 #endif
2815 }
2816 iter = iter->GetParent() ;
2817 }
2818
2819 return NULL ;
2820 }
2821
2822 bool wxWindowMac::MacHasScrollBarCorner() const
2823 {
2824 /* Returns whether the scroll bars in a wxScrolledWindow should be
2825 * shortened. Scroll bars should be shortened if either:
2826 *
2827 * - both scroll bars are visible, or
2828 *
2829 * - there is a resize box in the parent frame's corner and this
2830 * window shares the bottom and right edge with the parent
2831 * frame.
2832 */
2833
2834 if ( m_hScrollBar == NULL && m_vScrollBar == NULL )
2835 return false;
2836
2837 if ( ( m_hScrollBar && m_hScrollBar->IsShown() )
2838 && ( m_vScrollBar && m_vScrollBar->IsShown() ) )
2839 {
2840 // Both scroll bars visible
2841 return true;
2842 }
2843 else
2844 {
2845 wxPoint thisWindowBottomRight = GetScreenRect().GetBottomRight();
2846
2847 for ( const wxWindow *win = this; win; win = win->GetParent() )
2848 {
2849 const wxFrame *frame = wxDynamicCast( win, wxFrame ) ;
2850 if ( frame )
2851 {
2852 if ( frame->GetWindowStyleFlag() & wxRESIZE_BORDER )
2853 {
2854 // Parent frame has resize handle
2855 wxPoint frameBottomRight = frame->GetScreenRect().GetBottomRight();
2856
2857 // Note: allow for some wiggle room here as wxMac's
2858 // window rect calculations seem to be imprecise
2859 if ( abs( thisWindowBottomRight.x - frameBottomRight.x ) <= 2
2860 && abs( thisWindowBottomRight.y - frameBottomRight.y ) <= 2 )
2861 {
2862 // Parent frame has resize handle and shares
2863 // right bottom corner
2864 return true ;
2865 }
2866 else
2867 {
2868 // Parent frame has resize handle but doesn't
2869 // share right bottom corner
2870 return false ;
2871 }
2872 }
2873 else
2874 {
2875 // Parent frame doesn't have resize handle
2876 return false ;
2877 }
2878 }
2879 }
2880
2881 // No parent frame found
2882 return false ;
2883 }
2884 }
2885
2886 void wxWindowMac::MacCreateScrollBars( long style )
2887 {
2888 wxASSERT_MSG( m_vScrollBar == NULL && m_hScrollBar == NULL , wxT("attempt to create window twice") ) ;
2889
2890 if ( style & ( wxVSCROLL | wxHSCROLL ) )
2891 {
2892 int scrlsize = MAC_SCROLLBAR_SIZE ;
2893 if ( GetWindowVariant() == wxWINDOW_VARIANT_SMALL || GetWindowVariant() == wxWINDOW_VARIANT_MINI )
2894 {
2895 scrlsize = MAC_SMALL_SCROLLBAR_SIZE ;
2896 }
2897
2898 int adjust = MacHasScrollBarCorner() ? scrlsize - 1: 0 ;
2899 int width, height ;
2900 GetClientSize( &width , &height ) ;
2901
2902 wxPoint vPoint(width - scrlsize, 0) ;
2903 wxSize vSize(scrlsize, height - adjust) ;
2904 wxPoint hPoint(0, height - scrlsize) ;
2905 wxSize hSize(width - adjust, scrlsize) ;
2906
2907 // we have to set the min size to a smaller value, otherwise they cannot get smaller (InitialSize sets MinSize)
2908 if ( style & wxVSCROLL )
2909 {
2910 m_vScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, vPoint, vSize , wxVERTICAL);
2911 m_vScrollBar->SetMinSize( wxDefaultSize );
2912 }
2913
2914 if ( style & wxHSCROLL )
2915 {
2916 m_hScrollBar = new wxScrollBar((wxWindow*)this, wxID_ANY, hPoint, hSize , wxHORIZONTAL);
2917 m_hScrollBar->SetMinSize( wxDefaultSize );
2918 }
2919 }
2920
2921 // because the create does not take into account the client area origin
2922 // we might have a real position shift
2923 MacRepositionScrollBars() ;
2924 }
2925
2926 bool wxWindowMac::MacIsChildOfClientArea( const wxWindow* child ) const
2927 {
2928 bool result = ((child == NULL) || ((child != m_hScrollBar) && (child != m_vScrollBar)));
2929
2930 return result ;
2931 }
2932
2933 void wxWindowMac::MacRepositionScrollBars()
2934 {
2935 if ( !m_hScrollBar && !m_vScrollBar )
2936 return ;
2937
2938 int scrlsize = m_hScrollBar ? m_hScrollBar->GetSize().y : ( m_vScrollBar ? m_vScrollBar->GetSize().x : MAC_SCROLLBAR_SIZE ) ;
2939 int adjust = MacHasScrollBarCorner() ? scrlsize - 1 : 0 ;
2940
2941 // get real client area
2942 int width, height ;
2943 GetSize( &width , &height );
2944
2945 width -= MacGetLeftBorderSize() + MacGetRightBorderSize();
2946 height -= MacGetTopBorderSize() + MacGetBottomBorderSize();
2947
2948 wxPoint vPoint( width - scrlsize, 0 ) ;
2949 wxSize vSize( scrlsize, height - adjust ) ;
2950 wxPoint hPoint( 0 , height - scrlsize ) ;
2951 wxSize hSize( width - adjust, scrlsize ) ;
2952
2953 #if 0
2954 int x = 0, y = 0, w, h ;
2955 GetSize( &w , &h ) ;
2956
2957 MacClientToRootWindow( &x , &y ) ;
2958 MacClientToRootWindow( &w , &h ) ;
2959
2960 wxWindowMac *iter = (wxWindowMac*)this ;
2961
2962 int totW = 10000 , totH = 10000;
2963 while ( iter )
2964 {
2965 if ( iter->IsTopLevel() )
2966 {
2967 iter->GetSize( &totW , &totH ) ;
2968 break ;
2969 }
2970
2971 iter = iter->GetParent() ;
2972 }
2973
2974 if ( x == 0 )
2975 {
2976 hPoint.x = -1 ;
2977 hSize.x += 1 ;
2978 }
2979 if ( y == 0 )
2980 {
2981 vPoint.y = -1 ;
2982 vSize.y += 1 ;
2983 }
2984
2985 if ( w - x >= totW )
2986 {
2987 hSize.x += 1 ;
2988 vPoint.x += 1 ;
2989 }
2990 if ( h - y >= totH )
2991 {
2992 vSize.y += 1 ;
2993 hPoint.y += 1 ;
2994 }
2995 #endif
2996
2997 if ( m_vScrollBar )
2998 m_vScrollBar->SetSize( vPoint.x , vPoint.y, vSize.x, vSize.y , wxSIZE_ALLOW_MINUS_ONE );
2999 if ( m_hScrollBar )
3000 m_hScrollBar->SetSize( hPoint.x , hPoint.y, hSize.x, hSize.y, wxSIZE_ALLOW_MINUS_ONE );
3001 }
3002
3003 bool wxWindowMac::AcceptsFocus() const
3004 {
3005 return MacCanFocus() && wxWindowBase::AcceptsFocus();
3006 }
3007
3008 void wxWindowMac::MacSuperChangedPosition()
3009 {
3010 // only window-absolute structures have to be moved i.e. controls
3011
3012 m_cachedClippedRectValid = false ;
3013
3014 wxWindowMac *child;
3015 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3016 while ( node )
3017 {
3018 child = node->GetData();
3019 child->MacSuperChangedPosition() ;
3020
3021 node = node->GetNext();
3022 }
3023 }
3024
3025 void wxWindowMac::MacTopLevelWindowChangedPosition()
3026 {
3027 // only screen-absolute structures have to be moved i.e. glcanvas
3028
3029 wxWindowMac *child;
3030 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3031 while ( node )
3032 {
3033 child = node->GetData();
3034 child->MacTopLevelWindowChangedPosition() ;
3035
3036 node = node->GetNext();
3037 }
3038 }
3039
3040 long wxWindowMac::MacGetLeftBorderSize() const
3041 {
3042 if ( IsTopLevel() )
3043 return 0 ;
3044
3045 SInt32 border = 0 ;
3046
3047 if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER))
3048 {
3049 // this metric is only the 'outset' outside the simple frame rect
3050 GetThemeMetric( kThemeMetricEditTextFrameOutset , &border ) ;
3051 border += 1 ;
3052 }
3053 else if (HasFlag(wxSIMPLE_BORDER))
3054 {
3055 // this metric is only the 'outset' outside the simple frame rect
3056 GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
3057 border += 1 ;
3058 }
3059
3060 return border ;
3061 }
3062
3063 long wxWindowMac::MacGetRightBorderSize() const
3064 {
3065 // they are all symmetric in mac themes
3066 return MacGetLeftBorderSize() ;
3067 }
3068
3069 long wxWindowMac::MacGetTopBorderSize() const
3070 {
3071 // they are all symmetric in mac themes
3072 return MacGetLeftBorderSize() ;
3073 }
3074
3075 long wxWindowMac::MacGetBottomBorderSize() const
3076 {
3077 // they are all symmetric in mac themes
3078 return MacGetLeftBorderSize() ;
3079 }
3080
3081 long wxWindowMac::MacRemoveBordersFromStyle( long style )
3082 {
3083 return style & ~wxBORDER_MASK ;
3084 }
3085
3086 // Find the wxWindowMac at the current mouse position, returning the mouse
3087 // position.
3088 wxWindowMac * wxFindWindowAtPointer( wxPoint& pt )
3089 {
3090 pt = wxGetMousePosition();
3091 wxWindowMac* found = wxFindWindowAtPoint(pt);
3092
3093 return found;
3094 }
3095
3096 // Get the current mouse position.
3097 wxPoint wxGetMousePosition()
3098 {
3099 int x, y;
3100
3101 wxGetMousePosition( &x, &y );
3102
3103 return wxPoint(x, y);
3104 }
3105
3106 void wxWindowMac::OnMouseEvent( wxMouseEvent &event )
3107 {
3108 if ( event.GetEventType() == wxEVT_RIGHT_DOWN )
3109 {
3110 // copied from wxGTK : CS
3111 // VZ: shouldn't we move this to base class then?
3112
3113 // generate a "context menu" event: this is similar to wxEVT_RIGHT_DOWN
3114 // except that:
3115 //
3116 // (a) it's a command event and so is propagated to the parent
3117 // (b) under MSW it can be generated from kbd too
3118 // (c) it uses screen coords (because of (a))
3119 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
3120 this->GetId(),
3121 this->ClientToScreen(event.GetPosition()));
3122 evtCtx.SetEventObject(this);
3123 if ( ! HandleWindowEvent(evtCtx) )
3124 event.Skip() ;
3125 }
3126 else
3127 {
3128 event.Skip() ;
3129 }
3130 }
3131
3132 void wxWindowMac::OnPaint( wxPaintEvent & WXUNUSED(event) )
3133 {
3134 if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL
3135 && GetBackgroundStyle() != wxBG_STYLE_TRANSPARENT )
3136 CallNextEventHandler(
3137 (EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() ,
3138 (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
3139 }
3140
3141 void wxWindowMac::MacHandleControlClick(WXWidget WXUNUSED(control),
3142 wxInt16 WXUNUSED(controlpart),
3143 bool WXUNUSED(mouseStillDown))
3144 {
3145 }
3146
3147 Rect wxMacGetBoundsForControl( wxWindow* window , const wxPoint& pos , const wxSize &size , bool adjustForOrigin )
3148 {
3149 int x, y, w, h ;
3150
3151 window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin ) ;
3152 Rect bounds = { y, x, y + h, x + w };
3153
3154 return bounds ;
3155 }
3156
3157 wxInt32 wxWindowMac::MacControlHit(WXEVENTHANDLERREF WXUNUSED(handler) , WXEVENTREF WXUNUSED(event) )
3158 {
3159 return eventNotHandledErr ;
3160 }
3161
3162 bool wxWindowMac::Reparent(wxWindowBase *newParentBase)
3163 {
3164 wxWindowMac *newParent = (wxWindowMac *)newParentBase;
3165 if ( !wxWindowBase::Reparent(newParent) )
3166 return false;
3167
3168 // copied from MacPostControlCreate
3169 ControlRef container = (ControlRef) GetParent()->GetHandle() ;
3170
3171 wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
3172
3173 ::EmbedControl( m_peer->GetControlRef() , container ) ;
3174
3175 return true;
3176 }
3177
3178 bool wxWindowMac::SetTransparent(wxByte alpha)
3179 {
3180 SetBackgroundStyle(wxBG_STYLE_TRANSPARENT);
3181
3182 if ( alpha != m_macAlpha )
3183 {
3184 m_macAlpha = alpha ;
3185 Refresh() ;
3186 }
3187 return true ;
3188 }
3189
3190
3191 bool wxWindowMac::CanSetTransparent()
3192 {
3193 return true ;
3194 }
3195
3196 wxByte wxWindowMac::GetTransparent() const
3197 {
3198 return m_macAlpha ;
3199 }
3200
3201 bool wxWindowMac::IsShownOnScreen() const
3202 {
3203 #if TARGET_API_MAC_OSX
3204 if ( m_peer && m_peer->Ok() )
3205 {
3206 bool peerVis = m_peer->IsVisible();
3207 bool wxVis = wxWindowBase::IsShownOnScreen();
3208 if( peerVis != wxVis )
3209 {
3210 // CS : put a breakpoint here to investigate differences
3211 // between native an wx visibilities
3212 // the only place where I've encountered them until now
3213 // are the hiding/showing sequences where the vis-changed event is
3214 // first sent to the innermost control, while wx does things
3215 // from the outmost control
3216 wxVis = wxWindowBase::IsShownOnScreen();
3217 return wxVis;
3218 }
3219
3220 return m_peer->IsVisible();
3221 }
3222 #endif
3223
3224 return wxWindowBase::IsShownOnScreen();
3225 }
wxWidgets (Impactor)