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


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