]> git.saurik.com Git - wxWidgets.git/blobdiff - src/osx/carbon/app.cpp
changing disclosure triangle to allow for label
[wxWidgets.git] / src / osx / carbon / app.cpp
index a75a5112791edbd1017e102887922ca70e09cd54..0ec20f24c4e385eac9dd6ea929b30aa0e06fbb18 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        src/mac/carbon/app.cpp
+// Name:        src/osx/carbon/app.cpp
 // Purpose:     wxApp
 // Author:      Stefan Csomor
 // Modified by:
 // Purpose:     wxApp
 // Author:      Stefan Csomor
 // Modified by:
 #include "wx/filename.h"
 #include "wx/link.h"
 #include "wx/thread.h"
 #include "wx/filename.h"
 #include "wx/link.h"
 #include "wx/thread.h"
+#include "wx/evtloop.h"
 
 #include <string.h>
 
 // mac
 
 #include <string.h>
 
 // mac
+#if wxOSX_USE_CARBON
+#include "wx/osx/uma.h"
+#else
+#include "wx/osx/private.h"
+#endif
 
 
-#include "wx/mac/uma.h"
-
-#ifdef __DARWIN__
-#  include <CoreServices/CoreServices.h>
-#  if defined(WXMAKINGDLL_CORE)
-#    include <mach-o/dyld.h>
-#  endif
+#if defined(WXMAKINGDLL_CORE)
+#   include <mach-o/dyld.h>
 #endif
 
 // Keep linker from discarding wxStockGDIMac
 wxFORCE_LINK_MODULE(gdiobj)
 
 #endif
 
 // Keep linker from discarding wxStockGDIMac
 wxFORCE_LINK_MODULE(gdiobj)
 
-// statics for implementation
-static bool s_inYield = false;
-static bool s_inReceiveEvent = false ;
-static EventTime sleepTime = kEventDurationNoWait ;
-
-
 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
     EVT_IDLE(wxApp::OnIdle)
 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
     EVT_IDLE(wxApp::OnIdle)
@@ -84,15 +79,25 @@ wxString  wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
 
 bool      wxApp::sm_isEmbedded = false; // Normally we're not a plugin
 
 
 bool      wxApp::sm_isEmbedded = false; // Normally we're not a plugin
 
+#if wxOSX_USE_CARBON
+
 //----------------------------------------------------------------------
 // Core Apple Event Support
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 // Core Apple Event Support
 //----------------------------------------------------------------------
 
+AEEventHandlerUPP sODocHandler = NULL ;
+AEEventHandlerUPP sGURLHandler = NULL ;
+AEEventHandlerUPP sOAppHandler = NULL ;
+AEEventHandlerUPP sPDocHandler = NULL ;
+AEEventHandlerUPP sRAppHandler = NULL ;
+AEEventHandlerUPP sQuitHandler = NULL ;
+
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
+pascal OSErr AEHandleGURL( const AppleEvent *event , AppleEvent *reply , SRefCon refcon ) ;
 
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
 {
 
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , SRefCon WXUNUSED(refcon) )
 {
@@ -179,7 +184,7 @@ short wxApp::MacHandleAEGURL(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
     if (err != noErr)
         return err;
 
     if (err != noErr)
         return err;
 
-    url[actualSize] = '\0';    // Terminate the C string 
+    url[actualSize] = '\0';    // Terminate the C string
 
     ProcessSerialNumber PSN ;
     PSN.highLongOfPSN = 0 ;
 
     ProcessSerialNumber PSN ;
     PSN.highLongOfPSN = 0 ;
@@ -248,7 +253,7 @@ short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNU
     if ( win )
     {
         wxCommandEvent exitEvent(wxEVT_COMMAND_MENU_SELECTED, s_macExitMenuItemId);
     if ( win )
     {
         wxCommandEvent exitEvent(wxEVT_COMMAND_MENU_SELECTED, s_macExitMenuItemId);
-        if (!win->ProcessEvent(exitEvent))
+        if (!win->GetEventHandler()->ProcessEvent(exitEvent))
             win->Close(true) ;
     }
     else
             win->Close(true) ;
     }
     else
@@ -268,6 +273,8 @@ short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNU
     return noErr ;
 }
 
     return noErr ;
 }
 
+#endif
+
 //----------------------------------------------------------------------
 // Support Routines linking the Mac...File Calls to the Document Manager
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 // Support Routines linking the Mac...File Calls to the Document Manager
 //----------------------------------------------------------------------
@@ -350,9 +357,9 @@ void wxApp::MacReopenApp()
                 // make sure we don't show 'virtual toplevel windows' like wxTaskBarIconWindow
                 if ( firstHidden == NULL && ( wxDynamicCast( win, wxFrame ) || wxDynamicCast( win, wxDialog ) ) )
                    firstHidden = win ;
                 // make sure we don't show 'virtual toplevel windows' like wxTaskBarIconWindow
                 if ( firstHidden == NULL && ( wxDynamicCast( win, wxFrame ) || wxDynamicCast( win, wxDialog ) ) )
                    firstHidden = win ;
-            } 
+            }
             else if ( win->IsIconized() )
             else if ( win->IsIconized() )
-            { 
+            {
                 if ( firstIconized == NULL )
                     firstIconized = win ;
             }
                 if ( firstIconized == NULL )
                     firstIconized = win ;
             }
@@ -378,6 +385,8 @@ void wxApp::MacReopenApp()
 
 // if no native match they just return the passed-in id
 
 
 // if no native match they just return the passed-in id
 
+#if wxOSX_USE_CARBON
+
 struct IdPair
 {
     UInt32 macId ;
 struct IdPair
 {
     UInt32 macId ;
@@ -490,7 +499,7 @@ wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
 
         // is it part of the application or the Help menu, then look for the id directly
         if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
 
         // is it part of the application or the Help menu, then look for the id directly
         if ( ( GetMenuHandle( kwxMacAppleMenuId ) != NULL && command.menu.menuRef == GetMenuHandle( kwxMacAppleMenuId ) ) ||
-             ( helpMenuHandle != NULL && command.menu.menuRef == helpMenuHandle ) || 
+             ( helpMenuHandle != NULL && command.menu.menuRef == helpMenuHandle ) ||
              wxMenuBar::MacGetWindowMenuHMenu() != NULL && command.menu.menuRef == wxMenuBar::MacGetWindowMenuHMenu() )
         {
             wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
              wxMenuBar::MacGetWindowMenuHMenu() != NULL && command.menu.menuRef == wxMenuBar::MacGetWindowMenuHMenu() )
         {
             wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
@@ -499,22 +508,26 @@ wxMenu* wxFindMenuFromMacCommand( const HICommand &command , wxMenuItem* &item )
         }
         else
         {
         }
         else
         {
-            URefCon refCon ;
+            URefCon refCon = NULL ;
 
             GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
             itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
 
             GetMenuItemRefCon( command.menu.menuRef , command.menu.menuItemIndex , &refCon ) ;
             itemMenu = wxFindMenuFromMacMenu( command.menu.menuRef ) ;
-            if ( itemMenu != NULL )
-                item = (wxMenuItem*) refCon ;
+            if ( itemMenu != NULL && refCon != 0)
+                item = ((wxMenuItemImpl*) refCon)->GetWXPeer() ;
         }
     }
 #endif
     return itemMenu ;
 }
 
         }
     }
 #endif
     return itemMenu ;
 }
 
+#endif
+
 //----------------------------------------------------------------------
 // Carbon Event Handler
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 // Carbon Event Handler
 //----------------------------------------------------------------------
 
+#if wxOSX_USE_CARBON
+
 static const EventTypeSpec eventList[] =
 {
     { kEventClassCommand, kEventProcessCommand } ,
 static const EventTypeSpec eventList[] =
 {
     { kEventClassCommand, kEventProcessCommand } ,
@@ -550,22 +563,31 @@ wxMacAppMenuEventHandler( EventHandlerCallRef WXUNUSED(handler),
 
     if ( menu )
     {
 
     if ( menu )
     {
-        wxEventType type=0;
-        MenuCommand cmd=0;
         switch (GetEventKind(event))
         {
             case kEventMenuOpening:
         switch (GetEventKind(event))
         {
             case kEventMenuOpening:
-                type = wxEVT_MENU_OPEN;
+                menu->HandleMenuOpened();
                 break;
 
             case kEventMenuClosed:
                 break;
 
             case kEventMenuClosed:
-                type = wxEVT_MENU_CLOSE;
+                menu->HandleMenuClosed();
                 break;
 
             case kEventMenuTargetItem:
                 break;
 
             case kEventMenuTargetItem:
-                cmd = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
-                if (cmd != 0)
-                    type = wxEVT_MENU_HIGHLIGHT;
+                {
+                    HICommand command ;
+
+                    command.menu.menuRef = menuRef;
+                    command.menu.menuItemIndex = cEvent.GetParameter<MenuItemIndex>(kEventParamMenuItemIndex,typeMenuItemIndex) ;
+                    command.commandID = cEvent.GetParameter<MenuCommand>(kEventParamMenuCommand,typeMenuCommand) ;
+                    if (command.commandID != 0)
+                    {
+                        wxMenuItem* item = NULL ;
+                        wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
+                        if ( itemMenu && item )
+                            itemMenu->HandleMenuItemHighlighted( item );
+                    }
+                }
                 break;
 
             default:
                 break;
 
             default:
@@ -573,29 +595,11 @@ wxMacAppMenuEventHandler( EventHandlerCallRef WXUNUSED(handler),
                 break;
         }
 
                 break;
         }
 
-        if ( type )
-        {
-            wxMenuEvent wxevent(type, cmd, menu);
-            wxevent.SetEventObject(menu);
-
-            wxEvtHandler* handler = menu->GetEventHandler();
-            if (handler && handler->ProcessEvent(wxevent))
-            {
-                // handled
-            }
-            else
-            {
-                wxWindow *win = menu->GetInvokingWindow();
-                if (win)
-                    win->HandleWindowEvent(wxevent);
-                }
-            }
     }
 #endif
     return eventNotHandledErr;
 }
 
     }
 #endif
     return eventNotHandledErr;
 }
 
-#ifndef __LP64__
 static pascal OSStatus
 wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
                              EventRef event ,
 static pascal OSStatus
 wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
                              EventRef event ,
@@ -610,7 +614,6 @@ wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
 
     wxMenuItem* item = NULL ;
     wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
 
     wxMenuItem* item = NULL ;
     wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
-    int id = wxMacCommandToId( command.commandID ) ;
 
     if ( item )
     {
 
     if ( item )
     {
@@ -619,11 +622,13 @@ wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
         switch ( cEvent.GetKind() )
         {
             case kEventProcessCommand :
         switch ( cEvent.GetKind() )
         {
             case kEventProcessCommand :
-                result = itemMenu->MacHandleCommandProcess( item, id );
+                if ( itemMenu->HandleCommandProcess( item ) )
+                    result = noErr;
             break ;
 
         case kEventCommandUpdateStatus:
             break ;
 
         case kEventCommandUpdateStatus:
-                result = itemMenu->MacHandleCommandUpdateStatus( item, id );
+            if ( itemMenu->HandleCommandUpdateStatus( item ) )
+                    result = noErr;
             break ;
 
         default :
             break ;
 
         default :
@@ -632,7 +637,6 @@ wxMacAppCommandEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
     }
     return result ;
 }
     }
     return result ;
 }
-#endif
 
 static pascal OSStatus
 wxMacAppApplicationEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
 
 static pascal OSStatus
 wxMacAppApplicationEventHandler( EventHandlerCallRef WXUNUSED(handler) ,
@@ -726,8 +730,9 @@ pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef eve
 }
 
 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
 }
 
 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacAppEventHandler )
+#endif
 
 
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
 
 pascal static void
 wxMacAssertOutputHandler(OSType WXUNUSED(componentSignature),
 
 pascal static void
 wxMacAssertOutputHandler(OSType WXUNUSED(componentSignature),
@@ -773,7 +778,7 @@ wxMacAssertOutputHandler(OSType WXUNUSED(componentSignature),
 #endif
 }
 
 #endif
 }
 
-#endif //__WXDEBUG__
+#endif // wxDEBUG_LEVEL
 
 extern "C" void macPostedEventCallback(void *WXUNUSED(unused))
 {
 
 extern "C" void macPostedEventCallback(void *WXUNUSED(unused))
 {
@@ -784,13 +789,10 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 {
     // Mac-specific
 
 {
     // Mac-specific
 
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL && wxOSX_USE_COCOA_OR_CARBON
     InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
 #endif
 
     InstallDebugAssertOutputHandler( NewDebugAssertOutputHandlerUPP( wxMacAssertOutputHandler ) );
 #endif
 
-    UMAInitToolbox( 4, sm_isEmbedded ) ;
-// TODO CHECK Can Be Removed    SetEventMask( everyEvent ) ;
-
     // Mac OS X passes a process serial number command line argument when
     // the application is launched from the Finder. This argument must be
     // removed from the command line arguments before being handled by the
     // Mac OS X passes a process serial number command line argument when
     // the application is launched from the Finder. This argument must be
     // removed from the command line arguments before being handled by the
@@ -828,28 +830,43 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 
     /* connect posted events to common-mode run loop so that wxPostEvent events
        are handled even while we're in the menu or on a scrollbar */
 
     /* connect posted events to common-mode run loop so that wxPostEvent events
        are handled even while we're in the menu or on a scrollbar */
+       /*
     CFRunLoopSourceContext event_posted_context = {0};
     event_posted_context.perform = macPostedEventCallback;
     m_macEventPosted = CFRunLoopSourceCreate(NULL,0,&event_posted_context);
     CFRunLoopAddSource(CFRunLoopGetCurrent(), m_macEventPosted, kCFRunLoopCommonModes);
        // run loop takes ownership
        CFRelease(m_macEventPosted);
     CFRunLoopSourceContext event_posted_context = {0};
     event_posted_context.perform = macPostedEventCallback;
     m_macEventPosted = CFRunLoopSourceCreate(NULL,0,&event_posted_context);
     CFRunLoopAddSource(CFRunLoopGetCurrent(), m_macEventPosted, kCFRunLoopCommonModes);
        // run loop takes ownership
        CFRelease(m_macEventPosted);
-
+        */
     return true;
 }
 
     return true;
 }
 
-AEEventHandlerUPP sODocHandler = NULL ;
-AEEventHandlerUPP sGURLHandler = NULL ;
-AEEventHandlerUPP sOAppHandler = NULL ;
-AEEventHandlerUPP sPDocHandler = NULL ;
-AEEventHandlerUPP sRAppHandler = NULL ;
-AEEventHandlerUPP sQuitHandler = NULL ;
+bool wxApp::CallOnInit()
+{
+    wxMacAutoreleasePool autoreleasepool;
+    return OnInit();
+}
 
 bool wxApp::OnInitGui()
 {
     if ( !wxAppBase::OnInitGui() )
         return false ;
 
 bool wxApp::OnInitGui()
 {
     if ( !wxAppBase::OnInitGui() )
         return false ;
-#ifndef __LP64__
+
+    if ( !DoInitGui() )
+        return false;
+
+    return true ;
+}
+
+bool wxApp::ProcessIdle()
+{
+    wxMacAutoreleasePool autoreleasepool;
+    return wxAppBase::ProcessIdle();
+}
+
+#if wxOSX_USE_CARBON
+bool wxApp::DoInitGui()
+{
     InstallStandardEventHandler( GetApplicationEventTarget() ) ;
     if (!sm_isEmbedded)
     {
     InstallStandardEventHandler( GetApplicationEventTarget() ) ;
     if (!sm_isEmbedded)
     {
@@ -857,7 +874,6 @@ bool wxApp::OnInitGui()
             GetwxMacAppEventHandlerUPP(),
             GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
     }
             GetwxMacAppEventHandlerUPP(),
             GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
     }
-#endif
 
     if (!sm_isEmbedded)
     {
 
     if (!sm_isEmbedded)
     {
@@ -885,24 +901,11 @@ bool wxApp::OnInitGui()
     if ( !wxMacInitCocoa() )
         return false;
 
     if ( !wxMacInitCocoa() )
         return false;
 
-    return true ;
+    return true;
 }
 
 }
 
-void wxApp::CleanUp()
+void wxApp::DoCleanUp()
 {
 {
-#if wxUSE_TOOLTIPS
-    wxToolTip::RemoveToolTips() ;
-#endif
-
-    if (m_macEventPosted)
-       {
-               CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m_macEventPosted, kCFRunLoopCommonModes);
-               m_macEventPosted = NULL;
-       }
-
-    // One last chance for pending objects to be cleaned up
-    wxTheApp->DeletePendingObjects();
-
     if (!sm_isEmbedded)
         RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
 
     if (!sm_isEmbedded)
         RemoveEventHandler( (EventHandlerRef)(wxTheApp->m_macEventHandler) );
 
@@ -928,6 +931,23 @@ void wxApp::CleanUp()
         DisposeAEEventHandlerUPP( sRAppHandler ) ;
         DisposeAEEventHandlerUPP( sQuitHandler ) ;
     }
         DisposeAEEventHandlerUPP( sRAppHandler ) ;
         DisposeAEEventHandlerUPP( sQuitHandler ) ;
     }
+}
+
+#endif
+
+void wxApp::CleanUp()
+{
+#if wxUSE_TOOLTIPS
+    wxToolTip::RemoveToolTips() ;
+#endif
+
+    if (m_macEventPosted)
+       {
+               CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m_macEventPosted, kCFRunLoopCommonModes);
+               m_macEventPosted = NULL;
+       }
+
+    DoCleanUp();
 
     wxAppBase::CleanUp();
 }
 
     wxAppBase::CleanUp();
 }
@@ -936,7 +956,7 @@ void wxApp::CleanUp()
 // misc initialization stuff
 //----------------------------------------------------------------------
 
 // misc initialization stuff
 //----------------------------------------------------------------------
 
-#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
+#if wxOSX_USE_CARBON && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
 {
     OSStatus err = noErr ;
 bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
 {
     OSStatus err = noErr ;
@@ -1037,15 +1057,31 @@ wxApp::wxApp()
     m_macEventPosted = NULL ;
 }
 
     m_macEventPosted = NULL ;
 }
 
+CFMutableArrayRef GetAutoReleaseArray()
+{
+    static CFMutableArrayRef array = 0;
+    if ( array == 0)
+        array= CFArrayCreateMutable(kCFAllocatorDefault,0,&kCFTypeArrayCallBacks);
+    return array;
+}
+
+void wxApp::MacAddToAutorelease( void* cfrefobj )
+{
+    CFArrayAppendValue( GetAutoReleaseArray(), cfrefobj );
+}
+
 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
 {
     // If they are pending events, we must process them: pending events are
     // either events to the threads other than main or events posted with
     // wxPostEvent() functions
 #ifndef __WXUNIVERSAL__
 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
 {
     // If they are pending events, we must process them: pending events are
     // either events to the threads other than main or events posted with
     // wxPostEvent() functions
 #ifndef __WXUNIVERSAL__
+#if wxUSE_MENUS
   if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
     wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
 #endif
   if (!wxMenuBar::MacGetInstalledMenuBar() && wxMenuBar::MacGetCommonMenuBar())
     wxMenuBar::MacGetCommonMenuBar()->MacInstallMenuBar();
 #endif
+#endif
+    CFArrayRemoveAllValues( GetAutoReleaseArray() );
 }
 
 void wxApp::WakeUpIdle()
 }
 
 void wxApp::WakeUpIdle()
@@ -1081,134 +1117,13 @@ void wxCYield()
     wxYield() ;
 }
 
     wxYield() ;
 }
 
-// Yield to other processes
-
-bool wxApp::Yield(bool onlyIfNeeded)
-{
-    if (s_inYield)
-    {
-        if ( !onlyIfNeeded )
-        {
-            wxFAIL_MSG( wxT("wxYield called recursively" ) );
-        }
-
-        return false;
-    }
-
-#if wxUSE_THREADS
-    // Yielding from a non-gui thread needs to bail out, otherwise we end up
-    // possibly sending events in the thread too.
-    if ( !wxThread::IsMain() )
-    {
-        return true;
-    }
-#endif // wxUSE_THREADS
-
-    s_inYield = true;
-
-    // by definition yield should handle all non-processed events
-
-    EventRef theEvent;
-
-    OSStatus status = noErr ;
-
-    while ( status == noErr )
-    {
-        s_inReceiveEvent = true ;
-        status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ;
-        s_inReceiveEvent = false ;
-
-        if ( status == eventLoopTimedOutErr )
-        {
-            // make sure next time the event loop will trigger idle events
-            sleepTime = kEventDurationNoWait ;
-        }
-        else if ( status == eventLoopQuitErr )
-        {
-            // according to QA1061 this may also occur when a WakeUp Process
-            // is executed
-        }
-        else
-        {
-            MacHandleOneEvent( theEvent ) ;
-            ReleaseEvent(theEvent);
-        }
-    }
-
-    s_inYield = false;
-
-    return true;
-}
-
-void wxApp::MacDoOneEvent()
-{
-    wxMacAutoreleasePool autoreleasepool;
-    EventRef theEvent;
-
-    s_inReceiveEvent = true ;
-    OSStatus status = ReceiveNextEvent(0, NULL, sleepTime, true, &theEvent) ;
-    s_inReceiveEvent = false ;
-
-    switch (status)
-    {
-        case eventLoopTimedOutErr :
-            if ( wxTheApp->ProcessIdle() )
-                sleepTime = kEventDurationNoWait ;
-            else
-                sleepTime = kEventDurationSecond;
-            break;
-
-        case eventLoopQuitErr :
-            // according to QA1061 this may also occur
-            // when a WakeUp Process is executed
-            break;
-
-        default:
-            MacHandleOneEvent( theEvent ) ;
-            ReleaseEvent( theEvent );
-            sleepTime = kEventDurationNoWait ;
-            break;
-    }
-    // repeaters
-
-    DeletePendingObjects() ;
-}
-
 // virtual
 void wxApp::MacHandleUnhandledEvent( WXEVENTREF WXUNUSED(evr) )
 {
     // Override to process unhandled events as you please
 }
 
 // virtual
 void wxApp::MacHandleUnhandledEvent( WXEVENTREF WXUNUSED(evr) )
 {
     // Override to process unhandled events as you please
 }
 
-CFMutableArrayRef GetAutoReleaseArray()
-{
-    static CFMutableArrayRef array = 0;
-    if ( array == 0)
-        array= CFArrayCreateMutable(kCFAllocatorDefault,0,&kCFTypeArrayCallBacks);
-    return array;
-}
-
-void wxApp::MacHandleOneEvent( WXEVENTREF evr )
-{
-    EventTargetRef theTarget;
-    theTarget = GetEventDispatcherTarget();
-    m_macCurrentEvent = evr ;
-
-    OSStatus status = SendEventToEventTarget((EventRef) evr , theTarget);
-    if (status == eventNotHandledErr)
-        MacHandleUnhandledEvent(evr);
-
-#if wxUSE_THREADS
-    wxMutexGuiLeaveOrEnter();
-#endif // wxUSE_THREADS
-
-    CFArrayRemoveAllValues( GetAutoReleaseArray() );
-}
-
-void wxApp::MacAddToAutorelease( void* cfrefobj )
-{
-    CFArrayAppendValue( GetAutoReleaseArray(), cfrefobj );
-}
+#if wxOSX_USE_CARBON
 
 long wxMacTranslateKey(unsigned char key, unsigned char code)
 {
 
 long wxMacTranslateKey(unsigned char key, unsigned char code)
 {
@@ -1375,6 +1290,7 @@ int wxMacKeyCodeToModifier(wxKeyCode key)
         return 0;
     }
 }
         return 0;
     }
 }
+#endif
 
 wxMouseState wxGetMouseState()
 {
 
 wxMouseState wxGetMouseState()
 {
@@ -1384,6 +1300,7 @@ wxMouseState wxGetMouseState()
     ms.SetX(pt.x);
     ms.SetY(pt.y);
 
     ms.SetX(pt.x);
     ms.SetY(pt.y);
 
+#if wxOSX_USE_CARBON
     UInt32 buttons = GetCurrentButtonState();
     ms.SetLeftDown( (buttons & 0x01) != 0 );
     ms.SetMiddleDown( (buttons & 0x04) != 0 );
     UInt32 buttons = GetCurrentButtonState();
     ms.SetLeftDown( (buttons & 0x01) != 0 );
     ms.SetMiddleDown( (buttons & 0x04) != 0 );
@@ -1394,7 +1311,9 @@ wxMouseState wxGetMouseState()
     ms.SetShiftDown(modifiers & shiftKey);
     ms.SetAltDown(modifiers & optionKey);
     ms.SetMetaDown(modifiers & cmdKey);
     ms.SetShiftDown(modifiers & shiftKey);
     ms.SetAltDown(modifiers & optionKey);
     ms.SetMetaDown(modifiers & cmdKey);
-
+#else
+    // TODO
+#endif
     return ms;
 }
 
     return ms;
 }
 
@@ -1405,47 +1324,10 @@ bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifi
     if ( !focus )
         return false ;
 
     if ( !focus )
         return false ;
 
-    bool handled;
     wxKeyEvent event(wxEVT_KEY_DOWN) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
 
     wxKeyEvent event(wxEVT_KEY_DOWN) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
 
-    handled = focus->HandleWindowEvent( event ) ;
-    if ( handled && event.GetSkipped() )
-        handled = false ;
-
-#if wxUSE_ACCEL
-    if ( !handled )
-    {
-        wxWindow *ancestor = focus;
-        while (ancestor)
-        {
-            int command = ancestor->GetAcceleratorTable()->GetCommand( event );
-            if (command != -1)
-            {
-                wxEvtHandler * const handler = ancestor->GetEventHandler();
-
-                wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
-                handled = handler->ProcessEvent( command_event );
-
-                if ( !handled )
-                {
-                    // accelerators can also be used with buttons, try them too
-                    command_event.SetEventType(wxEVT_COMMAND_BUTTON_CLICKED);
-                    handled = handler->ProcessEvent( command_event );
-                }
-
-                break;
-            }
-
-            if (ancestor->IsTopLevel())
-                break;
-
-            ancestor = ancestor->GetParent();
-        }
-    }
-#endif // wxUSE_ACCEL
-
-    return handled ;
+    return focus->OSXHandleKeyEvent(event);
 }
 
 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
 }
 
 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
@@ -1453,25 +1335,23 @@ bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifier
     if ( !focus )
         return false ;
 
     if ( !focus )
         return false ;
 
-    bool handled;
     wxKeyEvent event( wxEVT_KEY_UP ) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
     wxKeyEvent event( wxEVT_KEY_UP ) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
-    handled = focus->HandleWindowEvent( event ) ;
 
 
-    return handled ;
+    return focus->OSXHandleKeyEvent(event) ;
 }
 
 bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
 {
     if ( !focus )
         return false ;
 }
 
 bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
 {
     if ( !focus )
         return false ;
-
     wxKeyEvent event(wxEVT_CHAR) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
     wxKeyEvent event(wxEVT_CHAR) ;
     MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
-    long keyval = event.m_keyCode ;
 
     bool handled = false ;
 
 
     bool handled = false ;
 
+#if wxOSX_USE_CARBON
+    long keyval = event.m_keyCode ;
     wxNonOwnedWindow *tlw = focus->MacGetTopLevelWindow() ;
 
     if (tlw)
     wxNonOwnedWindow *tlw = focus->MacGetTopLevelWindow() ;
 
     if (tlw)
@@ -1512,12 +1392,12 @@ bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers
     }
 
     // backdoor handler for default return and command escape
     }
 
     // backdoor handler for default return and command escape
-    if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
+    if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->AcceptsFocus() ) )
     {
         // if window is not having a focus still testing for default enter or cancel
         // TODO: add the UMA version for ActiveNonFloatingWindow
 #ifndef __LP64__
     {
         // if window is not having a focus still testing for default enter or cancel
         // TODO: add the UMA version for ActiveNonFloatingWindow
 #ifndef __LP64__
-        wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
+        wxWindow* focus = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) FrontWindow() ) ;
         if ( focus )
         {
             if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
         if ( focus )
         {
             if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
@@ -1546,12 +1426,14 @@ bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers
         }
 #endif
     }
         }
 #endif
     }
+#endif
     return handled ;
 }
 
 // This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
 void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
 {
     return handled ;
 }
 
 // This method handles common code for SendKeyDown, SendKeyUp, and SendChar events.
 void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
 {
+#if wxOSX_USE_CARBON
     short keycode, keychar ;
 
     keychar = short(keymessage & charCodeMask);
     short keycode, keychar ;
 
     keychar = short(keymessage & charCodeMask);
@@ -1582,34 +1464,34 @@ void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymess
         {
             keyval = (keyval - '0') + WXK_NUMPAD0;
         }
         {
             keyval = (keyval - '0') + WXK_NUMPAD0;
         }
-        else if (keycode >= 65 && keycode <= 81) 
+        else if (keycode >= 65 && keycode <= 81)
         {
             switch (keycode)
             {
                 case 76 :
                     keyval = WXK_NUMPAD_ENTER;
                     break;
         {
             switch (keycode)
             {
                 case 76 :
                     keyval = WXK_NUMPAD_ENTER;
                     break;
-                    
+
                 case 81:
                     keyval = WXK_NUMPAD_EQUAL;
                     break;
                 case 81:
                     keyval = WXK_NUMPAD_EQUAL;
                     break;
-                    
+
                 case 67:
                     keyval = WXK_NUMPAD_MULTIPLY;
                     break;
                 case 67:
                     keyval = WXK_NUMPAD_MULTIPLY;
                     break;
-                    
+
                 case 75:
                     keyval = WXK_NUMPAD_DIVIDE;
                     break;
                 case 75:
                     keyval = WXK_NUMPAD_DIVIDE;
                     break;
-                    
+
                 case 78:
                     keyval = WXK_NUMPAD_SUBTRACT;
                     break;
                 case 78:
                     keyval = WXK_NUMPAD_SUBTRACT;
                     break;
-                    
+
                 case 69:
                     keyval = WXK_NUMPAD_ADD;
                     break;
                 case 69:
                     keyval = WXK_NUMPAD_ADD;
                     break;
-                    
+
                 case 65:
                     keyval = WXK_NUMPAD_DECIMAL;
                     break;
                 case 65:
                     keyval = WXK_NUMPAD_DECIMAL;
                     break;
@@ -1618,7 +1500,7 @@ void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymess
             }
         }
     }
             }
         }
     }
-    
+
     event.m_shiftDown = modifiers & shiftKey;
     event.m_controlDown = modifiers & controlKey;
     event.m_altDown = modifiers & optionKey;
     event.m_shiftDown = modifiers & shiftKey;
     event.m_controlDown = modifiers & controlKey;
     event.m_altDown = modifiers & optionKey;
@@ -1634,15 +1516,27 @@ void wxApp::MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymess
     event.m_y = wherey;
     event.SetTimestamp(when);
     event.SetEventObject(focus);
     event.m_y = wherey;
     event.SetTimestamp(when);
     event.SetEventObject(focus);
+#else
+    wxUnusedVar(event);
+    wxUnusedVar(focus);
+    wxUnusedVar(keymessage);
+    wxUnusedVar(modifiers);
+    wxUnusedVar(when);
+    wxUnusedVar(wherex);
+    wxUnusedVar(wherey);
+    wxUnusedVar(uniChar);
+#endif
 }
 
 
 void wxApp::MacHideApp()
 {
 }
 
 
 void wxApp::MacHideApp()
 {
+#if wxOSX_USE_CARBON
     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
     HICommand command;
     memset( &command, 0 , sizeof(command) );
     command.commandID = kHICommandHide ;
     wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
     HICommand command;
     memset( &command, 0 , sizeof(command) );
     command.commandID = kHICommandHide ;
-    event.SetParameter<HICommand>(kEventParamDirectObject, command );       
+    event.SetParameter<HICommand>(kEventParamDirectObject, command );
     SendEventToApplication( event );
     SendEventToApplication( event );
+#endif
 }
 }