]> git.saurik.com Git - wxWidgets.git/blobdiff - src/mac/carbon/window.cpp
using new API (no visual difference)
[wxWidgets.git] / src / mac / carbon / window.cpp
index 7116cf645fe9271df3943caedcb6ac4a07e09e7a..bc118c77417dd1fe15fd9ebdfdafeb08b8d88091 100644 (file)
     #include "wx/caret.h"
 #endif
 
     #include "wx/caret.h"
 #endif
 
-#define MAC_SCROLLBAR_SIZE 15
-#define MAC_SMALL_SCROLLBAR_SIZE 11
+#if wxUSE_DRAG_AND_DROP
+#include "wx/dnd.h"
+#endif
 
 #include "wx/mac/uma.h"
 
 
 #include "wx/mac/uma.h"
 
+#define MAC_SCROLLBAR_SIZE 15
+#define MAC_SMALL_SCROLLBAR_SIZE 11
+
 #ifndef __DARWIN__
 #include <Windows.h>
 #include <ToolUtils.h>
 #ifndef __DARWIN__
 #include <Windows.h>
 #include <ToolUtils.h>
 #endif
 #endif
 
 #endif
 #endif
 
-#if  wxUSE_DRAG_AND_DROP
-#include "wx/dnd.h"
-#endif
-
 #include <string.h>
 
 extern wxList wxPendingDelete;
 #include <string.h>
 
 extern wxList wxPendingDelete;
@@ -158,9 +158,14 @@ enum
 
 static const EventTypeSpec eventList[] =
 {
 
 static const EventTypeSpec eventList[] =
 {
+    { kEventClassCommand, kEventProcessCommand } ,
+    { kEventClassCommand, kEventCommandUpdateStatus } ,
+
     { kEventClassControl , kEventControlHit } ,
 
     { kEventClassControl , kEventControlHit } ,
 
-#if TARGET_API_MAC_OSX
+    { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
+    { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
+
     { kEventClassControl , kEventControlDraw } ,
     { kEventClassControl , kEventControlVisibilityChanged } ,
     { kEventClassControl , kEventControlEnabledStateChanged } ,
     { kEventClassControl , kEventControlDraw } ,
     { kEventClassControl , kEventControlVisibilityChanged } ,
     { kEventClassControl , kEventControlEnabledStateChanged } ,
@@ -173,7 +178,6 @@ static const EventTypeSpec eventList[] =
 
 //    { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
 //    { kEventClassControl , kEventControlBoundsChanged } ,
 
 //    { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
 //    { kEventClassControl , kEventControlBoundsChanged } ,
-#endif
 } ;
 
 static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 } ;
 
 static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
@@ -484,6 +488,205 @@ static pascal OSStatus wxMacWindowServiceEventHandler( EventHandlerCallRef handl
     return result ;
 }
 
     return result ;
 }
 
+pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+    OSStatus result = eventNotHandledErr ;
+    wxWindowMac* focus = (wxWindowMac*) data ;
+
+    wchar_t* uniChars = NULL ;
+    UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
+
+    UniChar* charBuf;
+    UInt32 dataSize = 0 ;
+    int numChars = 0 ;
+    UniChar buf[2] ;
+    if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
+    {
+        numChars = dataSize / sizeof( UniChar) ;
+        charBuf = buf ;
+
+        if ( dataSize > sizeof(buf) )
+            charBuf = new UniChar[ numChars ] ;
+        else
+            charBuf = buf ;
+
+        uniChars = new wchar_t[ numChars ] ;
+        GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
+#if SIZEOF_WCHAR_T == 2
+        uniChars = charBuf ;
+        memcpy( uniChars , charBuf , dataSize ) ;
+#else
+        // the resulting string will never have more chars than the utf16 version, so this is safe
+        wxMBConvUTF16 converter ;
+        numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
+#endif
+    }
+
+    switch ( GetEventKind( event ) )
+    {
+        case kEventTextInputUpdateActiveInputArea :
+            {
+                // An IME input event may return several characters, but we need to send one char at a time to
+                // EVT_CHAR
+                for (int pos=0 ; pos < numChars ; pos++)
+                {
+                    WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
+                    WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
+                    wxTheApp->MacSetCurrentEvent( event , handler ) ;
+
+                    UInt32 message = (0  << 8) + ((char)uniChars[pos] );
+                    if ( wxTheApp->MacSendCharEvent(
+                                                    focus , message , 0 , when , 0 , 0 , uniChars[pos] ) )
+                    {
+                        result = noErr ;
+                    }
+
+                    wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
+                }
+            }
+            break ;
+        case kEventTextInputUnicodeForKeyEvent :
+            {
+                UInt32 keyCode, modifiers ;
+                Point point ;
+                EventRef rawEvent ;
+                unsigned char charCode ;
+
+                GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
+                GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
+                GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
+                GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
+                GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
+
+                UInt32 message = (keyCode << 8) + charCode;
+
+                // An IME input event may return several characters, but we need to send one char at a time to
+                // EVT_CHAR
+                for (int pos=0 ; pos < numChars ; pos++)
+                {
+                    WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
+                    WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
+                    wxTheApp->MacSetCurrentEvent( event , handler ) ;
+
+                    if ( wxTheApp->MacSendCharEvent(
+                        focus , message , modifiers , when , point.h , point.v , uniChars[pos] ) )
+                    {
+                        result = noErr ;
+                    }
+
+                    wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
+                }
+            }
+            break;
+        default:
+            break ;
+    }
+
+    delete [] uniChars ;
+    if ( charBuf != buf )
+        delete [] charBuf ;
+    
+    return result ;
+}
+
+static pascal OSStatus wxMacWindowCommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+    OSStatus result = eventNotHandledErr ;
+    wxWindowMac* focus = (wxWindowMac*) data ;
+
+    HICommand command ;
+
+    wxMacCarbonEvent cEvent( event ) ;
+    cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
+
+    wxMenuItem* item = NULL ;
+    wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
+    int id = wxMacCommandToId( command.commandID ) ;
+
+    if ( item )
+    {
+        wxASSERT( itemMenu != NULL ) ;
+
+        switch ( cEvent.GetKind() )
+        {
+            case kEventProcessCommand :
+                {
+                    if (item->IsCheckable())
+                        item->Check( !item->IsChecked() ) ;
+
+                    if ( itemMenu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) )
+                        result = noErr ;
+                    else
+                    {
+                        wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED , id);
+                        event.SetEventObject(focus);
+                        event.SetInt(item->IsCheckable() ? item->IsChecked() : -1);
+
+                        if ( focus->GetEventHandler()->ProcessEvent(event) )
+                            result = noErr ;
+                    }
+                }
+            break ;
+
+            case kEventCommandUpdateStatus:
+                {
+                    wxUpdateUIEvent event(id);
+                    event.SetEventObject( itemMenu );
+
+                    bool processed = false;
+
+                    // Try the menu's event handler
+                    {
+                        wxEvtHandler *handler = itemMenu->GetEventHandler();
+                        if ( handler )
+                            processed = handler->ProcessEvent(event);
+                    }
+
+                    // Try the window the menu was popped up from
+                    // (and up through the hierarchy)
+                    if ( !processed )
+                    {
+                        const wxMenuBase *menu = itemMenu;
+                        while ( menu )
+                        {
+                            wxWindow *win = menu->GetInvokingWindow();
+                            if ( win )
+                            {
+                                processed = win->GetEventHandler()->ProcessEvent(event);
+                                break;
+                            }
+
+                            menu = menu->GetParent();
+                        }
+                    }
+
+                    if ( !processed )
+                    {
+                        processed = focus->GetEventHandler()->ProcessEvent(event);
+                    }
+
+                    if ( processed )
+                    {
+                        // if anything changed, update the changed attribute
+                        if (event.GetSetText())
+                            itemMenu->SetLabel(id, event.GetText());
+                        if (event.GetSetChecked())
+                            itemMenu->Check(id, event.GetChecked());
+                        if (event.GetSetEnabled())
+                            itemMenu->Enable(id, event.GetEnabled());
+
+                        result = noErr ;
+                    }
+                }
+                break ;
+
+            default :
+                break ;
+        }
+    }
+    return result ;
+}
+
 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
     EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
 pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
     EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
@@ -493,6 +696,10 @@ pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef
 
     switch ( GetEventClass( event ) )
     {
 
     switch ( GetEventClass( event ) )
     {
+        case kEventClassCommand :
+            result = wxMacWindowCommandEventHandler( handler , event , data ) ;
+            break ;
+
         case kEventClassControl :
             result = wxMacWindowControlEventHandler( handler, event, data ) ;
             break ;
         case kEventClassControl :
             result = wxMacWindowControlEventHandler( handler, event, data ) ;
             break ;
@@ -501,6 +708,10 @@ pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef
             result = wxMacWindowServiceEventHandler( handler, event , data ) ;
             break ;
 
             result = wxMacWindowServiceEventHandler( handler, event , data ) ;
             break ;
 
+        case kEventClassTextInput :
+            result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
+            break ;
+
         default :
             break ;
     }
         default :
             break ;
     }
@@ -751,7 +962,6 @@ void wxWindowMac::Init()
     wxWindowBase::SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 }
 
     wxWindowBase::SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 }
 
-// Destructor
 wxWindowMac::~wxWindowMac()
 {
     SendDestroyEvent();
 wxWindowMac::~wxWindowMac()
 {
     SendDestroyEvent();
@@ -772,7 +982,7 @@ wxWindowMac::~wxWindowMac()
             break;
         }
     }
             break;
         }
     }
-#endif // __WXUNIVERSAL__
+#endif
 
     // destroy children before destroying this window itself
     DestroyChildren();
 
     // destroy children before destroying this window itself
     DestroyChildren();
@@ -1046,14 +1256,22 @@ void wxWindowMac::MacSetBackgroundBrush( const wxBrush &brush )
 
 bool wxWindowMac::MacCanFocus() const
 {
 
 bool wxWindowMac::MacCanFocus() const
 {
-    // there is currently no way to determine whether the window is running in full keyboard
-    // access mode, therefore we cannot rely on these features, yet the only other way would be
-    // to issue a SetKeyboardFocus event and verify after whether it succeeded, this would risk problems
-    // in event handlers...
-    UInt32 features = 0 ;
-    m_peer->GetFeatures( &features ) ;
+    // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
+    // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning, but the value range
+    // is nowhere documented
+    Boolean keyExistsAndHasValidFormat ;
+    CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue ( CFSTR("AppleKeyboardUIMode" ) ,
+        kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat);  
+    
+    if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
+        return true ;
+    else
+    {
+        UInt32 features = 0 ;
+        m_peer->GetFeatures( &features ) ;
 
 
-    return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
+        return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
+    }
 }
 
 void wxWindowMac::SetFocus()
 }
 
 void wxWindowMac::SetFocus()
@@ -1555,15 +1773,19 @@ bool wxWindowMac::DoPopupMenu(wxMenu *menu, int x, int y)
     long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() , y, x, 0) ;
     if ( HiWord(menuResult) != 0 )
     {
     long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() , y, x, 0) ;
     if ( HiWord(menuResult) != 0 )
     {
-        MenuCommand id ;
-        GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &id ) ;
+        MenuCommand macid;
+        GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
+        int id = wxMacCommandToId( macid );
         wxMenuItem* item = NULL ;
         wxMenu* realmenu ;
         item = menu->FindItem( id, &realmenu ) ;
         wxMenuItem* item = NULL ;
         wxMenu* realmenu ;
         item = menu->FindItem( id, &realmenu ) ;
-        if (item->IsCheckable())
-            item->Check( !item->IsChecked() ) ;
+        if ( item )
+        {
+            if (item->IsCheckable())
+                item->Check( !item->IsChecked() ) ;
 
 
-        menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+            menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+        }
     }
 
     menu->MacAfterDisplay( true ) ;
     }
 
     menu->MacAfterDisplay( true ) ;