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