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