]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/osx/carbon/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
notify the event loop that synthesized events are on the queue, wait for them to...
[wxWidgets.git] / src / osx / carbon / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/osx/carbon/window.cpp
3// Purpose: wxWindowMac
4// Author: Stefan Csomor
5// Modified by:
6// Created: 1998-01-01
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#include "wx/wxprec.h"
13
14#include "wx/window.h"
15
16#ifndef WX_PRECOMP
17 #include "wx/log.h"
18 #include "wx/app.h"
19 #include "wx/utils.h"
20 #include "wx/panel.h"
21 #include "wx/frame.h"
22 #include "wx/dc.h"
23 #include "wx/dcclient.h"
24 #include "wx/button.h"
25 #include "wx/menu.h"
26 #include "wx/dialog.h"
27 #include "wx/settings.h"
28 #include "wx/msgdlg.h"
29 #include "wx/scrolbar.h"
30 #include "wx/statbox.h"
31 #include "wx/textctrl.h"
32 #include "wx/toolbar.h"
33 #include "wx/layout.h"
34 #include "wx/statusbr.h"
35 #include "wx/menuitem.h"
36 #include "wx/treectrl.h"
37 #include "wx/listctrl.h"
38#endif
39
40#include "wx/tooltip.h"
41#include "wx/spinctrl.h"
42#include "wx/geometry.h"
43
44#if wxUSE_LISTCTRL
45 #include "wx/listctrl.h"
46#endif
47
48#if wxUSE_TREECTRL
49 #include "wx/treectrl.h"
50#endif
51
52#if wxUSE_CARET
53 #include "wx/caret.h"
54#endif
55
56#if wxUSE_POPUPWIN
57 #include "wx/popupwin.h"
58#endif
59
60#if wxUSE_DRAG_AND_DROP
61#include "wx/dnd.h"
62#endif
63
64#if wxOSX_USE_CARBON
65#include "wx/osx/uma.h"
66#else
67#include "wx/osx/private.h"
68// bring in theming
69#include <Carbon/Carbon.h>
70#endif
71
72#define MAC_SCROLLBAR_SIZE 15
73#define MAC_SMALL_SCROLLBAR_SIZE 11
74
75#include <string.h>
76
77#define wxMAC_DEBUG_REDRAW 0
78#ifndef wxMAC_DEBUG_REDRAW
79#define wxMAC_DEBUG_REDRAW 0
80#endif
81
82// Get the window with the focus
83WXWidget wxWidgetImpl::FindFocus()
84{
85 ControlRef control = NULL ;
86 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
87 return control;
88}
89
90// no compositing to take into account under carbon
91wxWidgetImpl* wxWidgetImpl::FindBestFromWXWidget(WXWidget control)
92{
93 return FindFromWXWidget(control);
94}
95
96// ---------------------------------------------------------------------------
97// Carbon Events
98// ---------------------------------------------------------------------------
99
100static const EventTypeSpec eventList[] =
101{
102 { kEventClassCommand, kEventProcessCommand } ,
103 { kEventClassCommand, kEventCommandUpdateStatus } ,
104
105 { kEventClassControl , kEventControlGetClickActivation } ,
106 { kEventClassControl , kEventControlHit } ,
107
108 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
109 { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
110
111 { kEventClassControl , kEventControlDraw } ,
112
113 { kEventClassControl , kEventControlVisibilityChanged } ,
114 { kEventClassControl , kEventControlEnabledStateChanged } ,
115 { kEventClassControl , kEventControlHiliteChanged } ,
116
117 { kEventClassControl , kEventControlActivate } ,
118 { kEventClassControl , kEventControlDeactivate } ,
119
120 { kEventClassControl , kEventControlSetFocusPart } ,
121 { kEventClassControl , kEventControlFocusPartChanged } ,
122
123 { kEventClassService , kEventServiceGetTypes },
124 { kEventClassService , kEventServiceCopy },
125 { kEventClassService , kEventServicePaste },
126
127// { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
128// { kEventClassControl , kEventControlBoundsChanged } ,
129} ;
130
131static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
132{
133 OSStatus result = eventNotHandledErr ;
134 static wxWindowMac* targetFocusWindow = NULL;
135 static wxWindowMac* formerFocusWindow = NULL;
136
137 wxMacCarbonEvent cEvent( event ) ;
138
139 ControlRef controlRef ;
140 wxWindowMac* thisWindow = (wxWindowMac*) data ;
141
142 cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
143
144 switch ( GetEventKind( event ) )
145 {
146 case kEventControlDraw :
147 {
148 HIShapeRef updateRgn = NULL ;
149 HIMutableShapeRef allocatedRgn = NULL ;
150 wxRegion visRegion = thisWindow->MacGetVisibleRegion() ;
151
152 // according to the docs: redraw entire control if param not present
153 if ( cEvent.GetParameter<HIShapeRef>(kEventParamShape, &updateRgn) != noErr )
154 {
155 updateRgn = visRegion.GetWXHRGN();
156 }
157 else
158 {
159 if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
160 {
161 // as this update region is in native window locals we must adapt it to wx window local
162 allocatedRgn = HIShapeCreateMutableCopy(updateRgn);
163 HIShapeOffset(allocatedRgn, thisWindow->MacGetLeftBorderSize() , thisWindow->MacGetTopBorderSize());
164 // hide the given region by the new region that must be shifted
165 updateRgn = allocatedRgn ;
166 }
167 }
168
169#if wxMAC_DEBUG_REDRAW
170 if ( thisWindow->MacIsUserPane() )
171 {
172 static float color = 0.5 ;
173 static int channel = 0 ;
174 HIRect bounds;
175 CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
176
177 HIViewGetBounds( controlRef, &bounds );
178 CGContextSetRGBFillColor( cgContext, channel == 0 ? color : 0.5 ,
179 channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
180 CGContextFillRect( cgContext, bounds );
181 color += 0.1 ;
182 if ( color > 0.9 )
183 {
184 color = 0.5 ;
185 channel++ ;
186 if ( channel == 3 )
187 channel = 0 ;
188 }
189 }
190#endif
191
192 {
193 CGContextRef cgContext = NULL ;
194 OSStatus err = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) ;
195 if ( err != noErr )
196 {
197 // for non-composite drawing, since we don't support it ourselves, send it through the
198 // the default handler
199 // CallNextEventHandler( handler,event ) ;
200 // result = noErr ;
201 if ( allocatedRgn )
202 CFRelease( allocatedRgn ) ;
203 break;
204 }
205
206 thisWindow->MacSetCGContextRef( cgContext ) ;
207
208 {
209 wxMacCGContextStateSaver sg( cgContext ) ;
210 CGFloat alpha = (CGFloat)1.0 ;
211 {
212 wxWindow* iter = thisWindow ;
213 while ( iter )
214 {
215 alpha *= (CGFloat)( iter->GetTransparent()/255.0 ) ;
216 if ( iter->IsTopLevel() )
217 iter = NULL ;
218 else
219 iter = iter->GetParent() ;
220 }
221 }
222 CGContextSetAlpha( cgContext, alpha ) ;
223
224 if ( thisWindow->GetBackgroundStyle() == wxBG_STYLE_TRANSPARENT )
225 {
226 HIRect bounds;
227 HIViewGetBounds( controlRef, &bounds );
228 CGContextClearRect( cgContext, bounds );
229 }
230
231 if ( !HIShapeIsEmpty(updateRgn) )
232 {
233 // refcount increase because wxRegion constructor takes ownership of the native region
234 CFRetain(updateRgn);
235 thisWindow->GetUpdateRegion() = wxRegion(updateRgn);
236 if ( !thisWindow->MacDoRedraw( cEvent.GetTicks() ) )
237 {
238 // for native controls: call their native paint method
239 if ( !thisWindow->MacIsUserPane() ||
240 ( thisWindow->IsTopLevel() && thisWindow->GetBackgroundStyle() == wxBG_STYLE_SYSTEM ) )
241 {
242 if ( thisWindow->GetBackgroundStyle() != wxBG_STYLE_TRANSPARENT )
243 {
244 CallNextEventHandler( handler,event ) ;
245 result = noErr ;
246 }
247 }
248 }
249 else
250 {
251 result = noErr ;
252 }
253 thisWindow->MacPaintChildrenBorders();
254 }
255 thisWindow->MacSetCGContextRef( NULL ) ;
256 }
257 }
258
259 if ( allocatedRgn )
260 CFRelease( allocatedRgn ) ;
261 }
262 break ;
263
264 case kEventControlVisibilityChanged :
265 // we might have two native controls attributed to the same wxWindow instance
266 // eg a scrollview and an embedded textview, make sure we only fire for the 'outer'
267 // control, as otherwise native and wx visibility are different
268 if ( thisWindow->GetPeer() != NULL && thisWindow->GetPeer()->GetControlRef() == controlRef )
269 {
270 thisWindow->MacVisibilityChanged() ;
271 }
272 break ;
273
274 case kEventControlEnabledStateChanged :
275 thisWindow->MacEnabledStateChanged();
276 break ;
277
278 case kEventControlHiliteChanged :
279 thisWindow->MacHiliteChanged() ;
280 break ;
281
282 case kEventControlActivate :
283 case kEventControlDeactivate :
284 // FIXME: we should have a virtual function for this!
285#if wxUSE_TREECTRL
286 if ( thisWindow->IsKindOf( CLASSINFO( wxTreeCtrl ) ) )
287 thisWindow->Refresh();
288#endif
289#if wxUSE_LISTCTRL
290 if ( thisWindow->IsKindOf( CLASSINFO( wxListCtrl ) ) )
291 thisWindow->Refresh();
292#endif
293 break ;
294
295 //
296 // focus handling
297 // different handling on OS X
298 //
299
300 case kEventControlFocusPartChanged :
301 // the event is emulated by wxmac for systems lower than 10.5
302 {
303 if ( UMAGetSystemVersion() < 0x1050 )
304 {
305 // as it is synthesized here, we have to manually avoid propagation
306 result = noErr;
307 }
308 ControlPartCode previousControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPreviousPart , typeControlPartCode );
309 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlCurrentPart , typeControlPartCode );
310
311 if ( thisWindow->MacGetTopLevelWindow() && thisWindow->GetPeer()->NeedsFocusRect() )
312 {
313 thisWindow->MacInvalidateBorders();
314 }
315
316 if ( currentControlPart == 0 )
317 {
318 // kill focus
319#if wxUSE_CARET
320 if ( thisWindow->GetCaret() )
321 thisWindow->GetCaret()->OnKillFocus();
322#endif
323
324 wxLogTrace(wxT("Focus"), wxT("focus lost(%p)"), static_cast<void*>(thisWindow));
325
326 // remove this as soon as posting the synthesized event works properly
327 static bool inKillFocusEvent = false ;
328
329 if ( !inKillFocusEvent )
330 {
331 inKillFocusEvent = true ;
332 wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
333 event.SetEventObject(thisWindow);
334 event.SetWindow(targetFocusWindow);
335 thisWindow->HandleWindowEvent(event) ;
336 inKillFocusEvent = false ;
337 targetFocusWindow = NULL;
338 }
339 }
340 else if ( previousControlPart == 0 )
341 {
342 // set focus
343 // panel wants to track the window which was the last to have focus in it
344 wxLogTrace(wxT("Focus"), wxT("focus set(%p)"), static_cast<void*>(thisWindow));
345 wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
346 thisWindow->HandleWindowEvent(eventFocus);
347
348#if wxUSE_CARET
349 if ( thisWindow->GetCaret() )
350 thisWindow->GetCaret()->OnSetFocus();
351#endif
352
353 wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
354 event.SetEventObject(thisWindow);
355 event.SetWindow(formerFocusWindow);
356 thisWindow->HandleWindowEvent(event) ;
357 formerFocusWindow = NULL;
358 }
359 }
360 break;
361 case kEventControlSetFocusPart :
362 {
363 Boolean focusEverything = false ;
364 if ( cEvent.GetParameter<Boolean>(kEventParamControlFocusEverything , &focusEverything ) == noErr )
365 {
366 // put a breakpoint here to catch focus everything events
367 }
368 ControlPartCode controlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
369 if ( controlPart != kControlFocusNoPart )
370 {
371 targetFocusWindow = thisWindow;
372 wxLogTrace(wxT("Focus"), wxT("focus to be set(%p)"), static_cast<void*>(thisWindow));
373 }
374 else
375 {
376 formerFocusWindow = thisWindow;
377 wxLogTrace(wxT("Focus"), wxT("focus to be lost(%p)"), static_cast<void*>(thisWindow));
378 }
379
380 ControlPartCode previousControlPart = 0;
381 verify_noerr( HIViewGetFocusPart(controlRef, &previousControlPart));
382
383 if ( thisWindow->MacIsUserPane() )
384 {
385 if ( controlPart != kControlFocusNoPart )
386 cEvent.SetParameter<ControlPartCode>( kEventParamControlPart, typeControlPartCode, 1 ) ;
387 result = noErr ;
388 }
389 else
390 result = CallNextEventHandler(handler, event);
391
392 if ( UMAGetSystemVersion() < 0x1050 )
393 {
394// set back to 0 if problems arise
395#if 1
396 if ( result == noErr )
397 {
398 ControlPartCode currentControlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
399 // synthesize the event focus changed event
400 EventRef evRef = NULL ;
401
402 OSStatus err = MacCreateEvent(
403 NULL , kEventClassControl , kEventControlFocusPartChanged , TicksToEventTime( TickCount() ) ,
404 kEventAttributeUserEvent , &evRef );
405 verify_noerr( err );
406
407 wxMacCarbonEvent iEvent( evRef ) ;
408 iEvent.SetParameter<ControlRef>( kEventParamDirectObject , controlRef );
409 iEvent.SetParameter<EventTargetRef>( kEventParamPostTarget, typeEventTargetRef, GetControlEventTarget( controlRef ) );
410 iEvent.SetParameter<ControlPartCode>( kEventParamControlPreviousPart, typeControlPartCode, previousControlPart );
411 iEvent.SetParameter<ControlPartCode>( kEventParamControlCurrentPart, typeControlPartCode, currentControlPart );
412
413#if 1
414 // TODO test this first, avoid double posts etc...
415 PostEventToQueue( GetMainEventQueue(), evRef , kEventPriorityHigh );
416#else
417 wxMacWindowControlEventHandler( NULL , evRef , data ) ;
418#endif
419 ReleaseEvent( evRef ) ;
420 }
421#else
422 // old implementation, to be removed if the new one works
423 if ( controlPart == kControlFocusNoPart )
424 {
425#if wxUSE_CARET
426 if ( thisWindow->GetCaret() )
427 thisWindow->GetCaret()->OnKillFocus();
428#endif
429
430 wxLogTrace(wxT("Focus"), wxT("focus lost(%p)"), static_cast<void*>(thisWindow));
431
432 static bool inKillFocusEvent = false ;
433
434 if ( !inKillFocusEvent )
435 {
436 inKillFocusEvent = true ;
437 wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
438 event.SetEventObject(thisWindow);
439 thisWindow->HandleWindowEvent(event) ;
440 inKillFocusEvent = false ;
441 }
442 }
443 else
444 {
445 // panel wants to track the window which was the last to have focus in it
446 wxLogTrace(wxT("Focus"), wxT("focus set(%p)"), static_cast<void*>(thisWindow));
447 wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
448 thisWindow->HandleWindowEvent(eventFocus);
449
450 #if wxUSE_CARET
451 if ( thisWindow->GetCaret() )
452 thisWindow->GetCaret()->OnSetFocus();
453 #endif
454
455 wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
456 event.SetEventObject(thisWindow);
457 thisWindow->HandleWindowEvent(event) ;
458 }
459#endif
460 }
461 }
462 break ;
463
464 case kEventControlHit :
465 result = thisWindow->MacControlHit( handler , event ) ;
466 break ;
467
468 case kEventControlGetClickActivation :
469 {
470 // fix to always have a proper activation for DataBrowser controls (stay in bkgnd otherwise)
471 WindowRef owner = cEvent.GetParameter<WindowRef>(kEventParamWindowRef);
472 if ( !IsWindowActive(owner) )
473 {
474 cEvent.SetParameter(kEventParamClickActivation,typeClickActivationResult, (UInt32) kActivateAndIgnoreClick) ;
475 result = noErr ;
476 }
477 }
478 break ;
479
480 default :
481 break ;
482 }
483
484 return result ;
485}
486
487static pascal OSStatus
488wxMacWindowServiceEventHandler(EventHandlerCallRef WXUNUSED(handler),
489 EventRef event,
490 void *data)
491{
492 OSStatus result = eventNotHandledErr ;
493
494 wxMacCarbonEvent cEvent( event ) ;
495
496 ControlRef controlRef ;
497 wxWindowMac* thisWindow = (wxWindowMac*) data ;
498 wxTextCtrl* textCtrl = wxDynamicCast( thisWindow , wxTextCtrl ) ;
499 cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
500
501 switch ( GetEventKind( event ) )
502 {
503 case kEventServiceGetTypes :
504 if ( textCtrl )
505 {
506 long from, to ;
507 textCtrl->GetSelection( &from , &to ) ;
508
509 CFMutableArrayRef copyTypes = 0 , pasteTypes = 0;
510 if ( from != to )
511 copyTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServiceCopyTypes , typeCFMutableArrayRef ) ;
512 if ( textCtrl->IsEditable() )
513 pasteTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServicePasteTypes , typeCFMutableArrayRef ) ;
514
515 static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt', 'PICT', 'MooV', 'AIFF' */ };
516 for ( size_t i = 0 ; i < WXSIZEOF(textDataTypes) ; ++i )
517 {
518 CFStringRef typestring = CreateTypeStringWithOSType(textDataTypes[i]);
519 if ( typestring )
520 {
521 if ( copyTypes )
522 CFArrayAppendValue(copyTypes, typestring) ;
523 if ( pasteTypes )
524 CFArrayAppendValue(pasteTypes, typestring) ;
525
526 CFRelease( typestring ) ;
527 }
528 }
529
530 result = noErr ;
531 }
532 break ;
533
534 case kEventServiceCopy :
535 if ( textCtrl )
536 {
537 long from, to ;
538
539 textCtrl->GetSelection( &from , &to ) ;
540 wxString val = textCtrl->GetValue() ;
541 val = val.Mid( from , to - from ) ;
542 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
543 verify_noerr( PasteboardClear( pasteboard ) ) ;
544 PasteboardSynchronize( pasteboard );
545 // TODO add proper conversion
546 CFDataRef data = CFDataCreate( kCFAllocatorDefault, (const UInt8*)val.c_str(), val.length() );
547 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) 1, CFSTR("com.apple.traditional-mac-plain-text"), data, 0);
548 CFRelease( data );
549 result = noErr ;
550 }
551 break ;
552
553 case kEventServicePaste :
554 if ( textCtrl )
555 {
556 PasteboardRef pasteboard = cEvent.GetParameter<PasteboardRef>( kEventParamPasteboardRef, typePasteboardRef );
557 PasteboardSynchronize( pasteboard );
558 ItemCount itemCount;
559 verify_noerr( PasteboardGetItemCount( pasteboard, &itemCount ) );
560 for( UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++ )
561 {
562 PasteboardItemID itemID;
563 if ( PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ) == noErr )
564 {
565 CFDataRef flavorData = NULL;
566 if ( PasteboardCopyItemFlavorData( pasteboard, itemID, CFSTR("com.apple.traditional-mac-plain-text"), &flavorData ) == noErr )
567 {
568 CFIndex flavorDataSize = CFDataGetLength( flavorData );
569 char *content = new char[flavorDataSize+1] ;
570 memcpy( content, CFDataGetBytePtr( flavorData ), flavorDataSize );
571 content[flavorDataSize]=0;
572 CFRelease( flavorData );
573#if wxUSE_UNICODE
574 textCtrl->WriteText( wxString( content , wxConvLocal ) );
575#else
576 textCtrl->WriteText( wxString( content ) ) ;
577#endif
578
579 delete[] content ;
580 result = noErr ;
581 }
582 }
583 }
584 }
585 break ;
586
587 default:
588 break ;
589 }
590
591 return result ;
592}
593
594WXDLLEXPORT pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
595{
596 OSStatus result = eventNotHandledErr ;
597 wxWindowMac* focus = (wxWindowMac*) data ;
598
599 wchar_t* uniChars = NULL ;
600 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
601
602 UniChar* charBuf = NULL;
603 ByteCount dataSize = 0 ;
604 int numChars = 0 ;
605 UniChar buf[2] ;
606 if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
607 {
608 numChars = dataSize / sizeof( UniChar) + 1;
609 charBuf = buf ;
610
611 if ( (size_t) numChars * 2 > sizeof(buf) )
612 charBuf = new UniChar[ numChars ] ;
613 else
614 charBuf = buf ;
615
616 uniChars = new wchar_t[ numChars ] ;
617 GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
618 charBuf[ numChars - 1 ] = 0;
619 // the resulting string will never have more chars than the utf16 version, so this is safe
620 wxMBConvUTF16 converter ;
621 numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
622 }
623
624 switch ( GetEventKind( event ) )
625 {
626 case kEventTextInputUpdateActiveInputArea :
627 {
628 // An IME input event may return several characters, but we need to send one char at a time to
629 // EVT_CHAR
630 for (int pos=0 ; pos < numChars ; pos++)
631 {
632 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
633 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
634 wxTheApp->MacSetCurrentEvent( event , handler ) ;
635
636 UInt32 message = uniChars[pos] < 128 ? (char)uniChars[pos] : '?';
637/*
638 NB: faking a charcode here is problematic. The kEventTextInputUpdateActiveInputArea event is sent
639 multiple times to update the active range during inline input, so this handler will often receive
640 uncommited text, which should usually not trigger side effects. It might be a good idea to check the
641 kEventParamTextInputSendFixLen parameter and verify if input is being confirmed (see CarbonEvents.h).
642 On the other hand, it can be useful for some applications to react to uncommitted text (for example,
643 to update a status display), as long as it does not disrupt the inline input session. Ideally, wx
644 should add new event types to support advanced text input. For now, I would keep things as they are.
645
646 However, the code that was being used caused additional problems:
647 UInt32 message = (0 << 8) + ((char)uniChars[pos] );
648 Since it simply truncated the unichar to the last byte, it ended up causing weird bugs with inline
649 input, such as switching to another field when one attempted to insert the character U+4E09 (the kanji
650 for "three"), because it was truncated to 09 (kTabCharCode), which was later "converted" to WXK_TAB
651 (still 09) in wxMacTranslateKey; or triggering the default button when one attempted to insert U+840D
652 (the kanji for "name"), which got truncated to 0D and interpreted as a carriage return keypress.
653 Note that even single-byte characters could have been misinterpreted, since MacRoman charcodes only
654 overlap with Unicode within the (7-bit) ASCII range.
655 But simply passing a NUL charcode would disable text updated events, because wxTextCtrl::OnChar checks
656 for codes within a specific range. Therefore I went for the solution seen above, which keeps ASCII
657 characters as they are and replaces the rest with '?', ensuring that update events are triggered.
658 It would be better to change wxTextCtrl::OnChar to look at the actual unicode character instead, but
659 I don't have time to look into that right now.
660 -- CL
661*/
662 if ( wxTheApp->MacSendCharEvent( focus , message , 0 , when , uniChars[pos] ) )
663 {
664 result = noErr ;
665 }
666
667 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
668 }
669 }
670 break ;
671 case kEventTextInputUnicodeForKeyEvent :
672 {
673 UInt32 keyCode, modifiers ;
674 EventRef rawEvent ;
675 unsigned char charCode ;
676
677 GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
678 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, 1, NULL, &charCode );
679 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
680 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
681
682 UInt32 message = (keyCode << 8) + charCode;
683
684 // An IME input event may return several characters, but we need to send one char at a time to
685 // EVT_CHAR
686 for (int pos=0 ; pos < numChars ; pos++)
687 {
688 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
689 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
690 wxTheApp->MacSetCurrentEvent( event , handler ) ;
691
692 if ( wxTheApp->MacSendCharEvent( focus , message , modifiers , when , uniChars[pos] ) )
693 {
694 result = noErr ;
695 }
696
697 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
698 }
699 }
700 break;
701 default:
702 break ;
703 }
704
705 delete [] uniChars ;
706 if ( charBuf != buf )
707 delete [] charBuf ;
708
709 return result ;
710}
711
712static pascal OSStatus
713wxMacWindowCommandEventHandler(EventHandlerCallRef WXUNUSED(handler),
714 EventRef event,
715 void *data)
716{
717 OSStatus result = eventNotHandledErr ;
718 wxWindowMac* focus = (wxWindowMac*) data ;
719
720 HICommand command ;
721
722 wxMacCarbonEvent cEvent( event ) ;
723 cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
724
725 wxMenuItem* item = NULL ;
726 wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
727
728 if ( item )
729 {
730 wxASSERT( itemMenu != NULL ) ;
731
732 switch ( cEvent.GetKind() )
733 {
734 case kEventProcessCommand :
735 if ( itemMenu->HandleCommandProcess( item, focus ) )
736 result = noErr;
737 break ;
738
739 case kEventCommandUpdateStatus:
740 if ( itemMenu->HandleCommandUpdateStatus( item, focus ) )
741 result = noErr;
742 break ;
743
744 default :
745 break ;
746 }
747 }
748 return result ;
749}
750
751pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
752{
753 EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
754 EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
755 wxTheApp->MacSetCurrentEvent( event , handler ) ;
756 OSStatus result = eventNotHandledErr ;
757
758 switch ( GetEventClass( event ) )
759 {
760 case kEventClassCommand :
761 result = wxMacWindowCommandEventHandler( handler , event , data ) ;
762 break ;
763
764 case kEventClassControl :
765 result = wxMacWindowControlEventHandler( handler, event, data ) ;
766 break ;
767
768 case kEventClassService :
769 result = wxMacWindowServiceEventHandler( handler, event , data ) ;
770 break ;
771
772 case kEventClassTextInput :
773 result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
774 break ;
775
776 default :
777 break ;
778 }
779
780 wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
781
782 return result ;
783}
784
785DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
786
787// ---------------------------------------------------------------------------
788// Scrollbar Tracking for all
789// ---------------------------------------------------------------------------
790
791pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode ) ;
792pascal void wxMacLiveScrollbarActionProc( ControlRef control , ControlPartCode partCode )
793{
794 if ( partCode != 0)
795 {
796 wxWindow* wx = wxFindWindowFromWXWidget( (WXWidget) control ) ;
797 if ( wx )
798 {
799 wxEventType scrollEvent = wxEVT_NULL;
800 switch ( partCode )
801 {
802 case kControlUpButtonPart:
803 scrollEvent = wxEVT_SCROLL_LINEUP;
804 break;
805
806 case kControlDownButtonPart:
807 scrollEvent = wxEVT_SCROLL_LINEDOWN;
808 break;
809
810 case kControlPageUpPart:
811 scrollEvent = wxEVT_SCROLL_PAGEUP;
812 break;
813
814 case kControlPageDownPart:
815 scrollEvent = wxEVT_SCROLL_PAGEDOWN;
816 break;
817
818 case kControlIndicatorPart:
819 scrollEvent = wxEVT_SCROLL_THUMBTRACK;
820 // when this is called as a live proc, mouse is always still down
821 // so no need for thumbrelease
822 // scrollEvent = wxEVT_SCROLL_THUMBRELEASE;
823 break;
824 }
825 wx->TriggerScrollEvent(scrollEvent) ;
826 }
827 }
828}
829wxMAC_DEFINE_PROC_GETTER( ControlActionUPP , wxMacLiveScrollbarActionProc ) ;
830
831wxWidgetImplType* wxWidgetImpl::CreateUserPane( wxWindowMac* wxpeer,
832 wxWindowMac* WXUNUSED(parent),
833 wxWindowID WXUNUSED(id),
834 const wxPoint& pos,
835 const wxSize& size,
836 long WXUNUSED(style),
837 long WXUNUSED(extraStyle))
838{
839 OSStatus err = noErr;
840 Rect bounds = wxMacGetBoundsForControl( wxpeer , pos , size ) ;
841 wxMacControl* c = new wxMacControl(wxpeer, false, true) ;
842 UInt32 features = 0
843 | kControlSupportsEmbedding
844 | kControlSupportsLiveFeedback
845 | kControlGetsFocusOnClick
846// | kControlHasSpecialBackground
847// | kControlSupportsCalcBestRect
848 | kControlHandlesTracking
849 | kControlSupportsFocus
850 | kControlWantsActivate
851 | kControlWantsIdle ;
852
853 err =::CreateUserPaneControl( MAC_WXHWND(wxpeer->GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , c->GetControlRefAddr() );
854 verify_noerr( err );
855 return c;
856}
857
858
859void wxMacControl::InstallEventHandler( WXWidget control )
860{
861 wxWidgetImpl::Associate( control ? control : (WXWidget) m_controlRef , this ) ;
862 ::InstallControlEventHandler( control ? (ControlRef) control : m_controlRef , GetwxMacWindowEventHandlerUPP(),
863 GetEventTypeCount(eventList), eventList, GetWXPeer(), NULL);
864}
865
866IMPLEMENT_DYNAMIC_CLASS( wxMacControl , wxWidgetImpl )
867
868wxMacControl::wxMacControl()
869{
870 Init();
871}
872
873wxMacControl::wxMacControl(wxWindowMac* peer , bool isRootControl, bool isUserPane ) :
874 wxWidgetImpl( peer, isRootControl, isUserPane )
875{
876 Init();
877}
878
879wxMacControl::~wxMacControl()
880{
881 if ( m_controlRef && !IsRootControl() )
882 {
883 wxASSERT_MSG( m_controlRef != NULL , wxT("Control Handle already NULL, Dispose called twice ?") );
884 wxASSERT_MSG( IsValidControlHandle(m_controlRef) , wxT("Invalid Control Handle (maybe already released) in Dispose") );
885
886 wxWidgetImpl::RemoveAssociations( this ) ;
887 // we cannot check the ref count here anymore, as autorelease objects might delete their refs later
888 // we can have situations when being embedded, where the control gets deleted behind our back, so only
889 // CFRelease if we are safe
890 if ( IsValidControlHandle(m_controlRef) )
891 CFRelease(m_controlRef);
892 }
893 m_controlRef = NULL;
894}
895
896void wxMacControl::Init()
897{
898 m_controlRef = NULL;
899 m_macControlEventHandler = NULL;
900}
901
902void wxMacControl::RemoveFromParent()
903{
904 // nothing to do here for carbon
905 HIViewRemoveFromSuperview(m_controlRef);
906}
907
908void wxMacControl::Embed( wxWidgetImpl *parent )
909{
910 HIViewAddSubview((ControlRef)parent->GetWXWidget(), m_controlRef);
911}
912
913void wxMacControl::SetNeedsDisplay( const wxRect* rect )
914{
915 if ( !IsVisible() )
916 return;
917
918 if ( rect != NULL )
919 {
920 HIRect updatearea = CGRectMake( rect->x , rect->y , rect->width , rect->height);
921 HIViewSetNeedsDisplayInRect( m_controlRef, &updatearea, true );
922 }
923 else
924 HIViewSetNeedsDisplay( m_controlRef , true );
925}
926
927void wxMacControl::Raise()
928{
929 verify_noerr( HIViewSetZOrder( m_controlRef, kHIViewZOrderAbove, NULL ) );
930}
931
932void wxMacControl::Lower()
933{
934 verify_noerr( HIViewSetZOrder( m_controlRef, kHIViewZOrderBelow, NULL ) );
935}
936
937void wxMacControl::GetContentArea(int &left , int &top , int &width , int &height) const
938{
939 HIShapeRef rgn = NULL;
940 Rect content ;
941
942 if ( HIViewCopyShape(m_controlRef, kHIViewContentMetaPart, &rgn) == noErr)
943 {
944 CGRect cgrect;
945 HIShapeGetBounds(rgn, &cgrect);
946 content = (Rect){ (short)cgrect.origin.y,
947 (short)cgrect.origin.x,
948 (short)(cgrect.origin.y+cgrect.size.height),
949 (short)(cgrect.origin.x+cgrect.size.width) };
950 CFRelease(rgn);
951 }
952 else
953 {
954 GetControlBounds(m_controlRef, &content);
955 content.right -= content.left;
956 content.left = 0;
957 content.bottom -= content.top;
958 content.top = 0;
959 }
960
961 left = content.left;
962 top = content.top;
963
964 width = content.right - content.left ;
965 height = content.bottom - content.top ;
966}
967
968void wxMacControl::Move(int x, int y, int width, int height)
969{
970 UInt32 attr = 0 ;
971 GetWindowAttributes( GetControlOwner(m_controlRef) , &attr ) ;
972
973 HIRect hir = CGRectMake(x,y,width,height);
974 if ( !(attr & kWindowCompositingAttribute) )
975 {
976 HIRect parent;
977 HIViewGetFrame( HIViewGetSuperview(m_controlRef), &parent );
978 hir.origin.x += parent.origin.x;
979 hir.origin.y += parent.origin.y;
980 }
981 HIViewSetFrame ( m_controlRef , &hir );
982}
983
984void wxMacControl::GetPosition( int &x, int &y ) const
985{
986 Rect r;
987 GetControlBounds( m_controlRef , &r );
988 x = r.left;
989 y = r.top;
990
991 UInt32 attr = 0 ;
992 GetWindowAttributes( GetControlOwner(m_controlRef) , &attr ) ;
993
994 if ( !(attr & kWindowCompositingAttribute) )
995 {
996 HIRect parent;
997 HIViewGetFrame( HIViewGetSuperview(m_controlRef), &parent );
998 x -= (int)parent.origin.x;
999 y -= (int)parent.origin.y;
1000 }
1001
1002}
1003
1004void wxMacControl::GetSize( int &width, int &height ) const
1005{
1006 Rect r;
1007 GetControlBounds( m_controlRef , &r );
1008 width = r.right - r.left;
1009 height = r.bottom - r.top;
1010}
1011
1012void wxMacControl::SetControlSize( wxWindowVariant variant )
1013{
1014 ControlSize size ;
1015 switch ( variant )
1016 {
1017 case wxWINDOW_VARIANT_NORMAL :
1018 size = kControlSizeNormal;
1019 break ;
1020
1021 case wxWINDOW_VARIANT_SMALL :
1022 size = kControlSizeSmall;
1023 break ;
1024
1025 case wxWINDOW_VARIANT_MINI :
1026 // not always defined in the headers
1027 size = 3 ;
1028 break ;
1029
1030 case wxWINDOW_VARIANT_LARGE :
1031 size = kControlSizeLarge;
1032 break ;
1033
1034 default:
1035 wxFAIL_MSG(wxT("unexpected window variant"));
1036 break ;
1037 }
1038
1039 SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
1040}
1041
1042void wxMacControl::ScrollRect( const wxRect *rect, int dx, int dy )
1043{
1044 if (GetNeedsDisplay() )
1045 {
1046 // because HIViewScrollRect does not scroll the already invalidated area we have two options:
1047 // in case there is already a pending redraw on that area
1048 // either immediate redraw or full invalidate
1049#if 1
1050 // is the better overall solution, as it does not slow down scrolling
1051 SetNeedsDisplay() ;
1052#else
1053 // this would be the preferred version for fast drawing controls
1054 HIViewRender(GetControlRef()) ;
1055#endif
1056 }
1057
1058 // note there currently is a bug in OSX (10.3 +?) which makes inefficient refreshes in case an entire control
1059 // area is scrolled, this does not occur if width and height are 2 pixels less,
1060 // TODO: write optimal workaround
1061
1062 HIRect scrollarea = CGRectMake( rect->x , rect->y , rect->width , rect->height);
1063 HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1064
1065#if 0
1066 // this would be the preferred version for fast drawing controls
1067 HIViewRender(GetControlRef()) ;
1068#endif
1069}
1070
1071bool wxMacControl::CanFocus() const
1072{
1073 // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
1074 // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning,
1075 // but the value range is nowhere documented
1076 Boolean keyExistsAndHasValidFormat ;
1077 CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue( CFSTR("AppleKeyboardUIMode" ) ,
1078 kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat );
1079
1080 if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
1081 {
1082 return true ;
1083 }
1084 else
1085 {
1086 UInt32 features = 0 ;
1087 GetControlFeatures( m_controlRef, &features ) ;
1088
1089 return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
1090 }
1091}
1092
1093bool wxMacControl::GetNeedsDisplay() const
1094{
1095 return HIViewGetNeedsDisplay( m_controlRef );
1096}
1097
1098void wxWidgetImpl::Convert( wxPoint *pt , wxWidgetImpl *from , wxWidgetImpl *to )
1099{
1100 HIPoint hiPoint;
1101
1102 hiPoint.x = pt->x;
1103 hiPoint.y = pt->y;
1104 HIViewConvertPoint( &hiPoint , (ControlRef) from->GetWXWidget() , (ControlRef) to->GetWXWidget() );
1105 pt->x = (int)hiPoint.x;
1106 pt->y = (int)hiPoint.y;
1107}
1108
1109bool wxMacControl::SetFocus()
1110{
1111 // as we cannot rely on the control features to find out whether we are in full keyboard mode,
1112 // we can only leave in case of an error
1113
1114 OSStatus err = SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, kControlFocusNextPart );
1115 if ( err == errCouldntSetFocus )
1116 return false ;
1117 SetUserFocusWindow(GetControlOwner( m_controlRef ) );
1118
1119 return true;
1120}
1121
1122bool wxMacControl::HasFocus() const
1123{
1124 ControlRef control;
1125 GetKeyboardFocus( GetUserFocusWindow() , &control );
1126 return control == m_controlRef;
1127}
1128
1129void wxMacControl::SetCursor(const wxCursor& cursor)
1130{
1131 wxWindowMac *mouseWin = 0 ;
1132 WindowRef window = GetControlOwner( m_controlRef ) ;
1133
1134 wxNonOwnedWindow* tlwwx = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) window ) ;
1135 if ( tlwwx != NULL )
1136 {
1137 ControlPartCode part ;
1138 ControlRef control ;
1139 Point pt ;
1140#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
1141 HIPoint hiPoint ;
1142 HIGetMousePosition(kHICoordSpaceWindow, window, &hiPoint);
1143 pt.h = hiPoint.x;
1144 pt.v = hiPoint.y;
1145#else
1146 GetGlobalMouse( &pt );
1147 int x = pt.h;
1148 int y = pt.v;
1149 tlwwx->ScreenToClient(&x, &y);
1150 pt.h = x;
1151 pt.v = y;
1152#endif
1153 control = FindControlUnderMouse( pt , window , &part ) ;
1154 if ( control )
1155 mouseWin = wxFindWindowFromWXWidget( (WXWidget) control ) ;
1156 }
1157
1158 if ( mouseWin == tlwwx && !wxIsBusy() )
1159 cursor.MacInstall() ;
1160}
1161
1162void wxMacControl::CaptureMouse()
1163{
1164}
1165
1166void wxMacControl::ReleaseMouse()
1167{
1168}
1169
1170//
1171// subclass specifics
1172//
1173
1174OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
1175{
1176 return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
1177}
1178
1179OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
1180{
1181 return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
1182}
1183
1184OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
1185{
1186 return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
1187}
1188
1189OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
1190{
1191 return SendEventToEventTargetWithOptions( event,
1192 HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
1193}
1194
1195OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
1196{
1197 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
1198
1199 event.SetParameter<HICommand>(kEventParamDirectObject,command);
1200
1201 return SendEvent( event , inOptions );
1202}
1203
1204OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions )
1205{
1206 HICommand command;
1207
1208 memset( &command, 0 , sizeof(command) );
1209 command.commandID = commandID;
1210 return SendHICommand( command , inOptions );
1211}
1212
1213void wxMacControl::PerformClick()
1214{
1215 HIViewSimulateClick (m_controlRef, kControlButtonPart, 0, NULL );
1216}
1217
1218wxInt32 wxMacControl::GetValue() const
1219{
1220 return ::GetControl32BitValue( m_controlRef );
1221}
1222
1223wxInt32 wxMacControl::GetMaximum() const
1224{
1225 return ::GetControl32BitMaximum( m_controlRef );
1226}
1227
1228wxInt32 wxMacControl::GetMinimum() const
1229{
1230 return ::GetControl32BitMinimum( m_controlRef );
1231}
1232
1233void wxMacControl::SetValue( wxInt32 v )
1234{
1235 ::SetControl32BitValue( m_controlRef , v );
1236}
1237
1238void wxMacControl::SetMinimum( wxInt32 v )
1239{
1240 ::SetControl32BitMinimum( m_controlRef , v );
1241}
1242
1243void wxMacControl::SetMaximum( wxInt32 v )
1244{
1245 ::SetControl32BitMaximum( m_controlRef , v );
1246}
1247
1248void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
1249{
1250 ::SetControl32BitMinimum( m_controlRef , minimum );
1251 ::SetControl32BitMaximum( m_controlRef , maximum );
1252 ::SetControl32BitValue( m_controlRef , value );
1253}
1254
1255void wxMacControl::VisibilityChanged(bool WXUNUSED(shown))
1256{
1257}
1258
1259void wxMacControl::SuperChangedPosition()
1260{
1261}
1262
1263void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack )
1264{
1265 m_font = font;
1266#if wxOSX_USE_CORE_TEXT
1267 if ( UMAGetSystemVersion() >= 0x1050 )
1268 {
1269 HIViewPartCode part = 0;
1270 HIThemeTextHorizontalFlush flush = kHIThemeTextHorizontalFlushDefault;
1271 if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1272 flush = kHIThemeTextHorizontalFlushCenter;
1273 else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1274 flush = kHIThemeTextHorizontalFlushRight;
1275 HIViewSetTextFont( m_controlRef , part , (CTFontRef) font.OSXGetCTFont() );
1276 HIViewSetTextHorizontalFlush( m_controlRef, part, flush );
1277
1278 if ( foreground != *wxBLACK || ignoreBlack == false )
1279 {
1280 ControlFontStyleRec fontStyle;
1281 foreground.GetRGBColor( &fontStyle.foreColor );
1282 fontStyle.flags = kControlUseForeColorMask;
1283 ::SetControlFontStyle( m_controlRef , &fontStyle );
1284 }
1285 }
1286#endif
1287#if wxOSX_USE_ATSU_TEXT
1288 ControlFontStyleRec fontStyle;
1289 if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
1290 {
1291 switch ( font.MacGetThemeFontID() )
1292 {
1293 case kThemeSmallSystemFont :
1294 fontStyle.font = kControlFontSmallSystemFont;
1295 break;
1296
1297 case 109 : // mini font
1298 fontStyle.font = -5;
1299 break;
1300
1301 case kThemeSystemFont :
1302 fontStyle.font = kControlFontBigSystemFont;
1303 break;
1304
1305 default :
1306 fontStyle.font = kControlFontBigSystemFont;
1307 break;
1308 }
1309
1310 fontStyle.flags = kControlUseFontMask;
1311 }
1312 else
1313 {
1314 fontStyle.font = font.MacGetFontNum();
1315 fontStyle.style = font.MacGetFontStyle();
1316 fontStyle.size = font.GetPointSize();
1317 fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
1318 }
1319
1320 fontStyle.just = teJustLeft;
1321 fontStyle.flags |= kControlUseJustMask;
1322 if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1323 fontStyle.just = teJustCenter;
1324 else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1325 fontStyle.just = teJustRight;
1326
1327
1328 // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1329 // won't get grayed out by the system anymore
1330
1331 if ( foreground != *wxBLACK || ignoreBlack == false )
1332 {
1333 foreground.GetRGBColor( &fontStyle.foreColor );
1334 fontStyle.flags |= kControlUseForeColorMask;
1335 }
1336
1337 ::SetControlFontStyle( m_controlRef , &fontStyle );
1338#endif
1339}
1340
1341void wxMacControl::SetBackgroundColour( const wxColour &WXUNUSED(col) )
1342{
1343// HITextViewSetBackgroundColor( m_textView , color );
1344}
1345
1346bool wxMacControl::SetBackgroundStyle(wxBackgroundStyle style)
1347{
1348 if ( style != wxBG_STYLE_PAINT )
1349 {
1350 OSStatus err = HIViewChangeFeatures(m_controlRef , 0 , kHIViewIsOpaque);
1351 verify_noerr( err );
1352 }
1353 else
1354 {
1355 OSStatus err = HIViewChangeFeatures(m_controlRef , kHIViewIsOpaque , 0);
1356 verify_noerr( err );
1357 }
1358
1359 return true ;
1360}
1361
1362void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1363{
1364 ::SetControl32BitMinimum( m_controlRef , minimum );
1365 ::SetControl32BitMaximum( m_controlRef , maximum );
1366}
1367
1368short wxMacControl::HandleKey( SInt16 keyCode, SInt16 charCode, EventModifiers modifiers )
1369{
1370 return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1371}
1372
1373void wxMacControl::SetActionProc( ControlActionUPP actionProc )
1374{
1375 SetControlAction( m_controlRef , actionProc );
1376}
1377
1378SInt32 wxMacControl::GetViewSize() const
1379{
1380 return GetControlViewSize( m_controlRef );
1381}
1382
1383bool wxMacControl::IsVisible() const
1384{
1385 return IsControlVisible( m_controlRef );
1386}
1387
1388void wxMacControl::SetVisibility( bool visible )
1389{
1390 SetControlVisibility( m_controlRef , visible, true );
1391}
1392
1393bool wxMacControl::IsEnabled() const
1394{
1395 return IsControlEnabled( m_controlRef );
1396}
1397
1398bool wxMacControl::IsActive() const
1399{
1400 return IsControlActive( m_controlRef );
1401}
1402
1403void wxMacControl::Enable( bool enable )
1404{
1405 if ( enable )
1406 EnableControl( m_controlRef );
1407 else
1408 DisableControl( m_controlRef );
1409}
1410
1411void wxMacControl::SetDrawingEnabled( bool enable )
1412{
1413 if ( enable )
1414 {
1415 HIViewSetDrawingEnabled( m_controlRef , true );
1416 HIViewSetNeedsDisplay( m_controlRef, true);
1417 }
1418 else
1419 {
1420 HIViewSetDrawingEnabled( m_controlRef , false );
1421 }
1422}
1423
1424void wxMacControl::GetRectInWindowCoords( Rect *r )
1425{
1426 GetControlBounds( m_controlRef , r ) ;
1427
1428 WindowRef tlwref = GetControlOwner( m_controlRef ) ;
1429
1430 wxNonOwnedWindow* tlwwx = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) tlwref ) ;
1431 if ( tlwwx != NULL )
1432 {
1433 ControlRef rootControl = tlwwx->GetPeer()->GetControlRef() ;
1434 HIPoint hiPoint = CGPointMake( 0 , 0 ) ;
1435 HIViewConvertPoint( &hiPoint , HIViewGetSuperview(m_controlRef) , rootControl ) ;
1436 OffsetRect( r , (short) hiPoint.x , (short) hiPoint.y ) ;
1437 }
1438}
1439
1440void wxMacControl::GetBestRect( wxRect *rect ) const
1441{
1442 short baselineoffset;
1443 Rect r = {0,0,0,0};
1444
1445 GetBestControlRect( m_controlRef , &r , &baselineoffset );
1446 *rect = wxRect( r.left, r.top, r.right - r.left, r.bottom-r.top );
1447}
1448
1449void wxMacControl::GetBestRect( Rect *r ) const
1450{
1451 short baselineoffset;
1452 GetBestControlRect( m_controlRef , r , &baselineoffset );
1453}
1454
1455void wxMacControl::SetLabel( const wxString &title , wxFontEncoding encoding)
1456{
1457 SetControlTitleWithCFString( m_controlRef , wxCFStringRef( title , encoding ) );
1458}
1459
1460void wxMacControl::GetFeatures( UInt32 * features )
1461{
1462 GetControlFeatures( m_controlRef , features );
1463}
1464
1465void wxMacControl::PulseGauge()
1466{
1467}
1468
1469// SetNeedsDisplay would not invalidate the children
1470static void InvalidateControlAndChildren( HIViewRef control )
1471{
1472 HIViewSetNeedsDisplay( control , true );
1473 UInt16 childrenCount = 0;
1474 OSStatus err = CountSubControls( control , &childrenCount );
1475 if ( err == errControlIsNotEmbedder )
1476 return;
1477
1478 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1479
1480 for ( UInt16 i = childrenCount; i >=1; --i )
1481 {
1482 HIViewRef child;
1483
1484 err = GetIndexedSubControl( control , i , & child );
1485 if ( err == errControlIsNotEmbedder )
1486 return;
1487
1488 InvalidateControlAndChildren( child );
1489 }
1490}
1491
1492void wxMacControl::InvalidateWithChildren()
1493{
1494 InvalidateControlAndChildren( m_controlRef );
1495}
1496
1497OSType wxMacCreator = 'WXMC';
1498OSType wxMacControlProperty = 'MCCT';
1499
1500void wxMacControl::SetReferenceInNativeControl()
1501{
1502 void * data = this;
1503 verify_noerr( SetControlProperty ( m_controlRef ,
1504 wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1505}
1506
1507wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1508{
1509 wxMacControl* ctl = NULL;
1510 ByteCount actualSize;
1511 if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1512 &actualSize , &ctl ) == noErr )
1513 {
1514 return ctl;
1515 }
1516 return NULL;
1517}
1518
1519wxBitmap wxMacControl::GetBitmap() const
1520{
1521 return wxNullBitmap;
1522}
1523
1524void wxMacControl::SetBitmap( const wxBitmap& WXUNUSED(bmp) )
1525{
1526 // implemented in the respective subclasses
1527}
1528
1529void wxMacControl::SetBitmapPosition( wxDirection WXUNUSED(dir) )
1530{
1531 // implemented in the same subclasses that implement SetBitmap()
1532}
1533
1534void wxMacControl::SetScrollThumb( wxInt32 WXUNUSED(pos), wxInt32 WXUNUSED(viewsize) )
1535{
1536 // implemented in respective subclass
1537}
1538
1539//
1540// Tab Control
1541//
1542
1543OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1544{
1545 return ::SetTabEnabled( m_controlRef , tabNo , enable );
1546}
1547
1548
1549
1550// Control Factory
1551
1552wxWidgetImplType* wxWidgetImpl::CreateContentView( wxNonOwnedWindow* now )
1553{
1554 // There is a bug in 10.2.X for ::GetRootControl returning the window view instead of
1555 // the content view, so we have to retrieve it explicitly
1556
1557 wxMacControl* contentview = new wxMacControl(now , true /*isRootControl*/);
1558 HIViewFindByID( HIViewGetRoot( (WindowRef) now->GetWXWindow() ) , kHIViewWindowContentID ,
1559 contentview->GetControlRefAddr() ) ;
1560 if ( !contentview->IsOk() )
1561 {
1562 // compatibility mode fallback
1563 GetRootControl( (WindowRef) now->GetWXWindow() , contentview->GetControlRefAddr() ) ;
1564 }
1565
1566 // the root control level handler
1567 if ( !now->IsNativeWindowWrapper() )
1568 contentview->InstallEventHandler() ;
1569
1570 return contentview;
1571}
wxWidgets (Impactor)