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