]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/window.cpp
projects / wxWidgets.git / blob
? search:


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