]> git.saurik.com Git - wxWidgets.git/blobdiff - src/mac/carbon/app.cpp
Fix client data handling: delete client data for all items when a
[wxWidgets.git] / src / mac / carbon / app.cpp
index cb46018f471393317189594ca0edc58ab0c7695d..3fd360674802b1013b9db4c4de3d4944349d76d0 100644 (file)
 #  include <Devices.h>
 #endif
 
-extern char *wxBuffer;
 extern wxList wxPendingDelete;
 extern wxList *wxWinMacWindowList;
 extern wxList *wxWinMacControlList;
 
+// statics for implementation
+
 static bool s_inYield = FALSE;
+static bool s_inOnIdle = FALSE;
+
+#if TARGET_CARBON
+static bool s_inReceiveEvent = FALSE ;
+static EventTime sleepTime = kEventDurationNoWait ;
+#else
+static long sleepTime = 0 ;
+#endif
 
 wxApp *wxTheApp = NULL;
 
@@ -83,8 +92,8 @@ wxApp *wxTheApp = NULL;
 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
     EVT_IDLE(wxApp::OnIdle)
-        EVT_END_SESSION(wxApp::OnEndSession)
-        EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
+    EVT_END_SESSION(wxApp::OnEndSession)
+    EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 END_EVENT_TABLE()
 #endif
 
@@ -109,95 +118,37 @@ long      wxApp::s_macPreferencesMenuItemId = 0 ;
 long      wxApp::s_macExitMenuItemId = wxID_EXIT ;
 wxString  wxApp::s_macHelpMenuTitleName = "&Help" ;
 
+//----------------------------------------------------------------------
+// Core Apple Event Support
+//----------------------------------------------------------------------
+
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
-pascal OSErr AEHandlePreferences( const AppleEvent *event , AppleEvent *reply , long refcon ) ;
-
 
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {
-    // GD: UNUSED wxApp* app = (wxApp*) refcon ;
     return wxTheApp->MacHandleAEODoc( (AppleEvent*) event , reply) ;
 }
 
 pascal OSErr AEHandleOApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {
-    // GD: UNUSED wxApp* app = (wxApp*) refcon ;
     return wxTheApp->MacHandleAEOApp( (AppleEvent*) event , reply ) ;
 }
 
 pascal OSErr AEHandlePDoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {
-    // GD: UNUSED wxApp* app = (wxApp*) refcon ;
     return wxTheApp->MacHandleAEPDoc( (AppleEvent*) event , reply ) ;
 }
 
 pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {
-    // GD: UNUSED wxApp* app = (wxApp*) refcon ;
     return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
 }
 
-pascal OSErr AEHandlePreferences( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
-{
-    // GD: UNUSED wxApp* app = (wxApp*) refcon ;
-
-    wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
-    wxMenu* menu = NULL ;
-    wxMenuItem* item = NULL ;
-    if ( mbar )
-    {
-        item = mbar->FindItem( wxApp::s_macPreferencesMenuItemId , &menu ) ;
-    }
-    if ( item != NULL && menu != NULL && mbar != NULL )
-               menu->SendEvent( wxApp::s_macPreferencesMenuItemId ,  -1 ) ;
-       return noErr ;
-}
-
-// new virtual public method in wxApp
-void wxApp::MacOpenFile(const wxString & fileName )
-{
-    wxDocManager* dm = wxDocManager::GetDocumentManager() ;
-    if ( dm )
-        dm->CreateDocument(fileName , wxDOC_SILENT ) ;
-}
+// AEODoc Calls MacOpenFile on each of the files passed
 
-void wxApp::MacPrintFile(const wxString & fileName )
-{
-    wxDocManager* dm = wxDocManager::GetDocumentManager() ;
-    if ( dm )
-    {
-        wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
-        if ( doc )
-        {
-            wxView* view = doc->GetFirstView() ;
-            if( view )
-            {
-                wxPrintout *printout = view->OnCreatePrintout();
-                if (printout)
-                {
-                    wxPrinter printer;
-                    printer.Print(view->GetFrame(), printout, TRUE);
-                    delete printout;
-                }
-            }
-            if (doc->Close())
-            {
-                doc->DeleteAllViews();
-                dm->RemoveDocument(doc) ;
-            }
-        }
-    }
-}
-
-void wxApp::MacNewFile()
-{
-}
-
-// new implementation, which parses the event and calls
-// MacOpenFile on each of the files it's passed
 short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
 {
     AEDescList docList;
@@ -230,6 +181,8 @@ short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
     return noErr;
 }
 
+// AEPDoc Calls MacPrintFile on each of the files passed
+
 short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply))
 {
     AEDescList docList;
@@ -262,237 +215,238 @@ short wxApp::MacHandleAEPDoc(const WXEVENTREF event , WXEVENTREF WXUNUSED(reply)
     return noErr;
 }
 
+// AEOApp calls MacNewFile
+
 short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 {
     MacNewFile() ;
     return noErr ;
 }
 
+// AEQuit attempts to quite the application 
+
 short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 {
-    wxWindow* win = GetTopWindow() ;
/*   wxWindow* win = GetTopWindow() ;
     if ( win )
     {
         win->Close(TRUE ) ;
     }
     else
+ */
     {
         ExitMainLoop() ;
     }
     return noErr ;
 }
 
-char StringMac[] =  "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
-                    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
-                    "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
-                    "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
-                    "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
-                    "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
-
-char StringANSI[] = "\x0a\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
-                    "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
-                    "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
-                    "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
-                    "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
-                    "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
+//----------------------------------------------------------------------
+// Support Routines linking the Mac...File Calls to the Document Manager
+//----------------------------------------------------------------------
 
-void wxMacConvertFromPC( const char *from , char *to , int len )
+void wxApp::MacOpenFile(const wxString & fileName )
 {
-    char *c ;
-    if ( from == to )
-    {
-        for( int i = 0 ; i < len ; ++ i )
-        {
-            c = strchr( StringANSI , *from ) ;
-            if ( c != NULL )
-            {
-                *to = StringMac[ c - StringANSI] ;
-            }
-            ++to ;
-            ++from ;
-        }
-    }
-    else
-    {
-        for( int i = 0 ; i < len ; ++ i )
-        {
-            c = strchr( StringANSI , *from ) ;
-            if ( c != NULL )
-            {
-                *to = StringMac[ c - StringANSI] ;
-            }
-            else
-            {
-                *to = *from ;
-            }
-            ++to ;
-            ++from ;
-        }
-    }
+    wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+    if ( dm )
+        dm->CreateDocument(fileName , wxDOC_SILENT ) ;
 }
 
-void wxMacConvertToPC( const char *from , char *to , int len )
+void wxApp::MacPrintFile(const wxString & fileName )
 {
-    char *c ;
-    if ( from == to )
-    {
-        for( int i = 0 ; i < len ; ++ i )
-        {
-            c = strchr( StringMac , *from ) ;
-            if ( c != NULL )
-            {
-                *to = StringANSI[ c - StringMac] ;
-            }
-            ++to ;
-            ++from ;
-        }
-    }
-    else
+    wxDocManager* dm = wxDocManager::GetDocumentManager() ;
+    if ( dm )
     {
-        for( int i = 0 ; i < len ; ++ i )
+        wxDocument *doc = dm->CreateDocument(fileName , wxDOC_SILENT ) ;
+        if ( doc )
         {
-            c = strchr( StringMac , *from ) ;
-            if ( c != NULL )
+            wxView* view = doc->GetFirstView() ;
+            if( view )
             {
-                *to = StringANSI[ c - StringMac] ;
+                wxPrintout *printout = view->OnCreatePrintout();
+                if (printout)
+                {
+                    wxPrinter printer;
+                    printer.Print(view->GetFrame(), printout, TRUE);
+                    delete printout;
+                }
             }
-            else
+            if (doc->Close())
             {
-                *to = *from ;
+                doc->DeleteAllViews();
+                dm->RemoveDocument(doc) ;
             }
-            ++to ;
-            ++from ;
         }
     }
 }
 
-void wxMacConvertFromPC( char * p )
+void wxApp::MacNewFile()
 {
-    char *ptr = p ;
-    int len = strlen ( p ) ;
-
-    wxMacConvertFromPC( ptr , ptr , len ) ;
 }
 
-void wxMacConvertFromPCForControls( char * p )
-{
-    char *ptr = p ;
-    int len = strlen ( p ) ;
+//----------------------------------------------------------------------
+// Carbon Event Handler
+//----------------------------------------------------------------------
 
-    wxMacConvertFromPC( ptr , ptr , len ) ;
-    for ( unsigned int i = 0 ; i < strlen ( ptr ) ; i++ )
-    {
-        if ( ptr[i] == '&' && ptr[i]+1 != ' ' )
-        {
-            memmove( &ptr[i] , &ptr[i+1] , strlen( &ptr[i+1] ) + 1) ;
-        }
-    }
-}
+#if TARGET_CARBON
 
-void wxMacConvertFromPC( unsigned char *p )
-{
-    char *ptr = (char*) p + 1 ;
-    int len = p[0] ;
+       static const EventTypeSpec eventList[] = 
+       {
+           { kEventClassCommand, kEventProcessCommand } ,
+           { kEventClassCommand, kEventCommandUpdateStatus } ,
+           
+           { kEventClassApplication , kEventAppActivated } ,
+           { kEventClassApplication , kEventAppDeactivated } ,
+           // handling the quit event is not recommended by apple
+           // rather using the quit apple event - which we do
+           
+           { kEventClassAppleEvent , kEventAppleEvent } ,
+           
+       { kEventClassMouse , kEventMouseDown } ,
+       } ;
 
-    wxMacConvertFromPC( ptr , ptr , len ) ;
+static pascal OSStatus MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+    OSStatus result = eventNotHandledErr ;
+    UInt32 kind = GetEventKind( event ) ;
+    
+    return result ;
 }
 
-extern char *wxBuffer ;
+// due to the rather low-level event API of wxWindows, we cannot use RunApplicationEventLoop 
+// but have to use ReceiveNextEvent dealing with events manually, therefore we also have
+// deal with clicks in the menu bar explicitely
 
-wxString wxMacMakeMacStringFromPC( const char * p )
+static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
-    const char *ptr = p ;
-    int len = strlen ( p ) ;
-    char *buf = wxBuffer ;
-
-    if ( len >= BUFSIZ + 512 )
+    OSStatus result = eventNotHandledErr ;
+    
+    switch( GetEventKind(event) )
     {
-        buf = new char [len+1] ;
-    }
+       case kEventMouseDown :
+       {
+                       Point point ;
+                       WindowRef window ;
+               
+                       GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
+                               sizeof( Point ), NULL, &point );
+                   short windowPart = ::FindWindow(point, &window);
+
+                       if ( windowPart == inMenuBar )
+                       {
+                               MenuSelect( point ) ;
+                               result = noErr ;
+                       }
+       }
+       break ;
+    }  
 
-    wxMacConvertFromPC( ptr , buf , len ) ;
-    buf[len] = 0 ;
-    wxString result( buf ) ;
-    if ( buf != wxBuffer )
-        delete buf ;
     return result ;
 }
 
-
-void wxMacConvertToPC( char * p )
+static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
-    char *ptr = p ;
-    int len = strlen ( p ) ;
+    OSStatus result = eventNotHandledErr ;
 
-    wxMacConvertToPC( ptr , ptr , len ) ;
-}
+       HICommand command ;
+       
+       GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL,
+               sizeof( HICommand ), NULL, &command );
 
-void wxMacConvertToPC( unsigned char *p )
-{
-    char *ptr = (char*) p + 1 ;
-    int len = p[0] ;
+       MenuCommand id = command.commandID ;
+       if ( id == kHICommandPreferences )
+               id = wxApp::s_macPreferencesMenuItemId ;
+               
+    wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+    wxMenu* menu = NULL ;
+    wxMenuItem* item = NULL ;
 
-    wxMacConvertToPC( ptr , ptr , len ) ;
+    if ( mbar )
+        item = mbar->FindItem( id , &menu ) ;
+
+    if ( item == NULL || menu == NULL || mbar == NULL )
+       return result ;
+       
+       switch( GetEventKind( event ) )
+       {
+               case kEventProcessCommand :
+              {
+                       if (item->IsCheckable())
+                       {
+                           item->Check( !item->IsChecked() ) ;
+                       }
+                               
+                               menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+                               result = noErr ;
+                       }
+                       break ;
+               case kEventCommandUpdateStatus:
+                       // eventually trigger an updateui round
+                               result = noErr ;
+                       break ;
+               default :
+                       break ;
+       }   
+    
+    return result ;
 }
 
-wxString wxMacMakePCStringFromMac( const char * p )
+static pascal OSStatus ApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
-    const char *ptr = p ;
-    int len = strlen ( p ) ;
-    char *buf = wxBuffer ;
-
-    if ( len >= BUFSIZ + 512 )
-    {
-        buf = new char [len+1] ;
-    }
-
-    wxMacConvertToPC( ptr , buf , len ) ;
-    buf[len] = 0 ;
-
-    wxString result( buf ) ;
-    if ( buf != wxBuffer )
-        delete buf ;
+    OSStatus result = eventNotHandledErr ;
+       switch ( GetEventKind( event ) )
+       {
+               case kEventAppActivated :
+                       {
+                               wxTheApp->MacResume( true ) ;
+                               result = noErr ;
+                       }
+                       break ;
+               case kEventAppDeactivated :
+                       {
+                               wxTheApp->MacSuspend( true ) ;
+                               result = noErr ;
+                       }
+                       break ;
+               default :
+                       break ;
+       }
     return result ;
 }
 
-wxString wxMacMakeStringFromMacString( const char* from , bool mac2pcEncoding )
+pascal OSStatus wxAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
-    if (mac2pcEncoding)
-    {
-      return wxMacMakePCStringFromMac( from ) ;
-    }
-    else
-    {
-      return wxString( from ) ;
+    OSStatus result = eventNotHandledErr ;
+    switch( GetEventClass( event ) )
+    {
+       case kEventClassCommand :
+               result = CommandEventHandler( handler , event , data ) ;
+               break ;
+       case kEventClassApplication :
+               result = ApplicationEventHandler( handler , event , data ) ;
+               break ;
+       case kEventClassMenu :
+               result = MenuEventHandler( handler , event , data ) ;
+               break ;
+       case kEventClassMouse :
+               result = MouseEventHandler( handler , event , data ) ;
+               break ;
+       case kEventClassAppleEvent :
+               {
+                       EventRecord rec ;
+                       wxMacConvertEventToRecord( event , &rec ) ;
+                       result = AEProcessAppleEvent( &rec ) ;
+               }
+               break ;
+       default :
+               break ;
     }
-}
 
-wxString wxMacMakeStringFromPascal( StringPtr from , bool mac2pcEncoding )
-{
-  // this is safe since a pascal string can never be larger than 256 bytes
-  char s[256] ;
-  CopyPascalStringToC( from , s ) ;
-    if (mac2pcEncoding)
-    {
-      return wxMacMakePCStringFromMac( s ) ;
-    }
-    else
-    {
-      return wxString( s ) ;
-    }
+    return result ;
 }
 
-void wxMacStringToPascal( const char * from , StringPtr to , bool pc2macEncoding )
-{
-    if (pc2macEncoding)
-    {
-      CopyCStringToPascal( wxMacMakeMacStringFromPC( from ) , to ) ;
-    }
-    else
-    {
-      CopyCStringToPascal( from , to ) ;
-    }
-}
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler )
+
+#endif
 
 #if defined(WXMAKINGDLL) && !defined(__DARWIN__)
 // we know it's there ;-)
@@ -515,34 +469,6 @@ bool wxApp::Initialize()
     wxStAppResource::OpenSharedLibraryResource(NULL);
 #endif
 
-#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
-    AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
-                           NewAEEventHandlerUPP(AEHandleODoc) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
-                           NewAEEventHandlerUPP(AEHandleOApp) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
-                           NewAEEventHandlerUPP(AEHandlePDoc) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
-                           NewAEEventHandlerUPP(AEHandleQuit) ,
-                           (long) wxTheApp , FALSE ) ;
-#else
-    AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
-                           NewAEEventHandlerProc(AEHandleODoc) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
-                           NewAEEventHandlerProc(AEHandleOApp) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
-                           NewAEEventHandlerProc(AEHandlePDoc) ,
-                           (long) wxTheApp , FALSE ) ;
-    AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
-                           NewAEEventHandlerProc(AEHandleQuit) ,
-                           (long) wxTheApp , FALSE ) ;
-#endif
-
 #ifndef __DARWIN__
     // test the minimal configuration necessary
 
@@ -605,12 +531,14 @@ bool wxApp::Initialize()
 
 #ifndef __DARWIN__
     // now avoid exceptions thrown for new (bad_alloc)
-    std::__throws_bad_alloc = FALSE ;
+       // FIXME CS for some changes outside wxMac does not compile anymore
+#if 0
+    std::__throws_bad_alloc = 0 ;
 #endif
 
-    s_macCursorRgn = ::NewRgn() ;
+#endif
 
-    wxBuffer = new char[BUFSIZ + 512];
+    s_macCursorRgn = ::NewRgn() ;
 
     wxClassInfo::InitializeClasses();
 
@@ -657,12 +585,55 @@ bool wxApp::Initialize()
 
   wxMacCreateNotifierTable() ;
 
-
   UMAShowArrowCursor() ;
 
   return TRUE;
 }
 
+bool wxApp::OnInitGui()
+{
+       if( !wxAppBase::OnInitGui() )
+               return false ;
+               
+#if TARGET_CARBON              
+       InstallStandardEventHandler( GetApplicationEventTarget() ) ;
+       
+       InstallApplicationEventHandler(
+               GetwxAppEventHandlerUPP(), 
+               GetEventTypeCount(eventList), eventList, wxTheApp, &((EventHandlerRef)wxTheApp->m_macEventHandler));    
+#endif
+               
+#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
+    AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+                           NewAEEventHandlerUPP(AEHandleODoc) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+                           NewAEEventHandlerUPP(AEHandleOApp) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+                           NewAEEventHandlerUPP(AEHandlePDoc) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+                           NewAEEventHandlerUPP(AEHandleQuit) ,
+                           0 , FALSE ) ;
+#else
+    AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+                           NewAEEventHandlerProc(AEHandleODoc) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+                           NewAEEventHandlerProc(AEHandleOApp) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+                           NewAEEventHandlerProc(AEHandlePDoc) ,
+                           0 , FALSE ) ;
+    AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+                           NewAEEventHandlerProc(AEHandleQuit) ,
+                           0 , FALSE ) ;
+#endif
+
+       return TRUE ;
+}
+
 void wxApp::CleanUp()
 {
     wxToolTip::RemoveToolTips() ;
@@ -696,9 +667,6 @@ void wxApp::CleanUp()
 
     wxBitmap::CleanUpHandlers();
 
-    delete[] wxBuffer;
-    wxBuffer = NULL;
-
     wxMacDestroyNotifierTable() ;
     if (wxWinMacWindowList) {
         delete wxWinMacWindowList ;
@@ -1119,6 +1087,7 @@ bool wxMacConvertEventToRecord( EventRef event , EventRecord *rec)
     return converted ;
 }
 
+/*
 pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
     OSStatus result = eventNotHandledErr ;
@@ -1147,30 +1116,9 @@ pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , Even
     }
     return result ;
 }
-
+*/
 #endif
 
-bool wxApp::OnInit()
-{
-    if ( ! wxAppBase::OnInit() )
-        return FALSE ;
-
-#if 0 // TARGET_CARBON
-       static const EventTypeSpec eventList[] =
-       {
-           { kEventClassKeyboard, kEventRawKeyDown } ,
-           { kEventClassKeyboard, kEventRawKeyRepeat } ,
-           { kEventClassKeyboard, kEventRawKeyUp } ,
-           { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
-
-           { kEventClassTextInput , kEventTextInputUnicodeForKeyEvent } ,
-       } ;
-
-       InstallApplicationEventHandler(NewEventHandlerUPP(wxMacApplicationEventHandler)
-           , WXSIZEOF(eventList), eventList, this, NULL);
-#endif
-    return TRUE ;
-}
 // Static member initialization
 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 
@@ -1202,18 +1150,6 @@ int wxApp::MainLoop()
 {
        m_keepGoing = TRUE;
 
-#if TARGET_CARBON
-       if ( UMAGetSystemVersion() >= 0x1000 )
-       {
-               if ( s_macPreferencesMenuItemId )
-               {
-                       EnableMenuCommand( NULL , kHICommandPreferences ) ;
-                   AEInstallEventHandler( kCoreEventClass , kAEShowPreferences ,
-                                          NewAEEventHandlerUPP(AEHandlePreferences) ,
-                                          (long) wxTheApp , FALSE ) ;
-               }
-       }
-#endif
        while (m_keepGoing)
        {
            MacDoOneEvent() ;
@@ -1234,15 +1170,26 @@ bool wxApp::ProcessIdle()
 
 void wxApp::ExitMainLoop()
 {
-  m_keepGoing = FALSE;
+#if TARGET_CARBON
+       if (s_inReceiveEvent)
+               QuitApplicationEventLoop() ;
+       else
+               m_keepGoing = FALSE;
+#else
+       m_keepGoing = FALSE;
+#endif
 }
 
 // Is a message/event pending?
 bool wxApp::Pending()
 {
+#if TARGET_CARBON
+       return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
+#else
     EventRecord event ;
 
-  return EventAvail( everyEvent , &event ) ;
+       return EventAvail( everyEvent , &event ) ;
+#endif
 }
 
 // Dispatch a message.
@@ -1253,8 +1200,6 @@ void wxApp::Dispatch()
 
 void wxApp::OnIdle(wxIdleEvent& event)
 {
-   static bool s_inOnIdle = FALSE;
-
     // Avoid recursion (via ProcessEvent default case)
     if ( s_inOnIdle )
         return;
@@ -1397,21 +1342,51 @@ bool wxApp::Yield(bool onlyIfNeeded)
 #if wxUSE_THREADS
     YieldToAnyThread() ;
 #endif
+       // by definition yield should handle all non-processed events
+#if TARGET_CARBON
+       EventRef theEvent;
+
+       OSStatus status = noErr ;
+       do
+       {
+               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 )
+               {
+                       m_keepGoing = false ;
+               }
+               else
+               {
+                       MacHandleOneEvent( theEvent ) ;
+                       ReleaseEvent(theEvent);
+               }
+       } while( status == noErr ) ;
+#else
     EventRecord event ;
 
-    long sleepTime = 1 ; //::GetCaretTime();
+       // having a larger value here leads to large performance slowdowns
+       // so we cannot give background apps more processor time here
+       // we do so however having a large sleep value in the main event loop
+    long sleepTime = 0 ; 
 
-    while ( !wxTheApp->IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
+    while ( !IsExiting() && WaitNextEvent(everyEvent, &event,sleepTime, (RgnHandle) wxApp::s_macCursorRgn))
     {
-        wxTheApp->MacHandleModifierEvents( &event ) ;
-        wxTheApp->MacHandleOneEvent( &event );
+        MacHandleModifierEvents( &event ) ;
+        MacHandleOneEvent( &event );
         if ( event.what != kHighLevelEvent )
             SetRectRgn( (RgnHandle) wxApp::s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
     }
-    wxTheApp->MacHandleModifierEvents( &event ) ;
+    MacHandleModifierEvents( &event ) ;
+#endif
 
     wxMacProcessNotifierAndPendingEvents() ;
-
     s_inYield = FALSE;
 
     return TRUE;
@@ -1421,24 +1396,26 @@ bool wxApp::Yield(bool onlyIfNeeded)
 
 void wxApp::MacSuspend( bool convertClipboard )
 {
+#if !TARGET_CARBON
     // we have to deactive the top level windows manually
 
     wxNode* node = wxTopLevelWindows.First();
     while (node)
     {
         wxTopLevelWindow* win = (wxTopLevelWindow*) node->Data();
-        win->MacActivate( MacGetCurrentEvent() , false ) ;
+        win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
 
         node = node->Next();
     }
 
+    ::HideFloatingWindows() ;
+#endif
     s_lastMouseDown = 0 ;
+
     if( convertClipboard )
     {
         MacConvertPrivateToPublicScrap() ;
     }
-
-    ::HideFloatingWindows() ;
 }
 
 extern wxList wxModalDialogs;
@@ -1451,8 +1428,8 @@ void wxApp::MacResume( bool convertClipboard )
         MacConvertPublicToPrivateScrap() ;
     }
 
+#if !TARGET_CARBON
     ::ShowFloatingWindows() ;
-
     // raise modal dialogs in case a non modal window was selected to activate the app
 
     wxNode* node = wxModalDialogs.First();
@@ -1463,6 +1440,7 @@ void wxApp::MacResume( bool convertClipboard )
 
         node = node->Next();
     }
+#endif
 }
 
 void wxApp::MacConvertPrivateToPublicScrap()
@@ -1475,11 +1453,34 @@ void wxApp::MacConvertPublicToPrivateScrap()
 
 void wxApp::MacDoOneEvent()
 {
-  EventRecord event ;
+#if TARGET_CARBON
+       EventRef theEvent;
 
-    long sleepTime = 1; // GetCaretTime() / 4 ;
+       s_inReceiveEvent = true ;
+       OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ;
+       s_inReceiveEvent = false ;
+       if ( status == eventLoopTimedOutErr )
+       {
+        if ( wxTheApp->ProcessIdle() )
+               sleepTime = kEventDurationNoWait ;
+        else
+               sleepTime = kEventDurationForever ;
+       }
+       else if ( status == eventLoopQuitErr )
+       {
+               m_keepGoing = false ;
+       }
+       else
+       {
+               MacHandleOneEvent( theEvent ) ;
+               ReleaseEvent(theEvent);
+       }
+#else
+       EventRecord event ;
+
+       EventMask eventMask = everyEvent ;
 
-    if (WaitNextEvent(everyEvent, &event, sleepTime, (RgnHandle) s_macCursorRgn))
+    if (WaitNextEvent(eventMask, &event, sleepTime, (RgnHandle) s_macCursorRgn))
     {
         MacHandleModifierEvents( &event ) ;
         MacHandleOneEvent( &event );
@@ -1492,76 +1493,28 @@ void wxApp::MacDoOneEvent()
         if ( window )
             ::IdleControls( window ) ;
 
-        wxTheApp->ProcessIdle() ;
+        if ( wxTheApp->ProcessIdle() )
+               sleepTime = 0 ;
+        else
+               sleepTime = GetCaretTime() / 2 ;
     }
     if ( event.what != kHighLevelEvent )
         SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
-
+#endif
     // repeaters
 
     DeletePendingObjects() ;
     wxMacProcessNotifierAndPendingEvents() ;
 }
 
-void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
-{
-    EventRecord* ev = (EventRecord*) evr ;
-#if TARGET_CARBON
-    if ( ev->what == mouseDown || ev->what == mouseUp || ev->what == activateEvt ||
-        ev->what == keyDown || ev->what == autoKey || ev->what == keyUp || ev->what == kHighLevelEvent ||
-        ev->what == nullEvent
-        )
-    {
-        // in these cases the modifiers are already correctly setup by carbon
-    }
-    else
-    {
-        EventRecord nev ;
-        WaitNextEvent( 0 , &nev , 0 , NULL ) ;
-        ev->modifiers = nev.modifiers ;
-        // KeyModifiers unfortunately don't include btnState...
-//        ev->modifiers = GetCurrentKeyModifiers() ; 
-    }
-#endif
-    if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
-    {
-        wxKeyEvent event(wxEVT_KEY_DOWN);
-
-        event.m_shiftDown = ev->modifiers & shiftKey;
-        event.m_controlDown = ev->modifiers & controlKey;
-        event.m_altDown = ev->modifiers & optionKey;
-        event.m_metaDown = ev->modifiers & cmdKey;
-
-        event.m_x = ev->where.h;
-        event.m_y = ev->where.v;
-        event.m_timeStamp = ev->when;
-        wxWindow* focus = wxWindow::FindFocus() ;
-        event.SetEventObject(focus);
-
-        if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
-        {
-            event.m_keyCode = WXK_CONTROL ;
-            event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
-            focus->GetEventHandler()->ProcessEvent( event ) ;
-        }
-        if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
-        {
-            event.m_keyCode = WXK_SHIFT ;
-            event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
-            focus->GetEventHandler()->ProcessEvent( event ) ;
-        }
-        if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
-        {
-            event.m_keyCode = WXK_ALT ;
-            event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
-            focus->GetEventHandler()->ProcessEvent( event ) ;
-        }
-        s_lastModifiers = ev->modifiers ;
-    }
-}
-
 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
 {
+#if TARGET_CARBON
+       EventTargetRef theTarget;
+       theTarget = GetEventDispatcherTarget();
+    m_macCurrentEvent = evr ;
+       SendEventToEventTarget ((EventRef) evr , theTarget);
+#else
     EventRecord* ev = (EventRecord*) evr ;
     m_macCurrentEvent = ev ;
 
@@ -1613,9 +1566,53 @@ void wxApp::MacHandleOneEvent( WXEVENTREF evr )
         default:
             break;
     }
+#endif
     wxMacProcessNotifierAndPendingEvents() ;
 }
 
+#if !TARGET_CARBON
+bool s_macIsInModalLoop = false ;
+
+void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
+{
+    EventRecord* ev = (EventRecord*) evr ;
+    if ( ev->modifiers != s_lastModifiers && wxWindow::FindFocus() != NULL )
+    {
+        wxKeyEvent event(wxEVT_KEY_DOWN);
+
+        event.m_shiftDown = ev->modifiers & shiftKey;
+        event.m_controlDown = ev->modifiers & controlKey;
+        event.m_altDown = ev->modifiers & optionKey;
+        event.m_metaDown = ev->modifiers & cmdKey;
+
+        event.m_x = ev->where.h;
+        event.m_y = ev->where.v;
+        event.m_timeStamp = ev->when;
+        wxWindow* focus = wxWindow::FindFocus() ;
+        event.SetEventObject(focus);
+
+        if ( (ev->modifiers ^ s_lastModifiers ) & controlKey )
+        {
+            event.m_keyCode = WXK_CONTROL ;
+            event.SetEventType( ( ev->modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+            focus->GetEventHandler()->ProcessEvent( event ) ;
+        }
+        if ( (ev->modifiers ^ s_lastModifiers ) & shiftKey )
+        {
+            event.m_keyCode = WXK_SHIFT ;
+            event.SetEventType( ( ev->modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+            focus->GetEventHandler()->ProcessEvent( event ) ;
+        }
+        if ( (ev->modifiers ^ s_lastModifiers ) & optionKey )
+        {
+            event.m_keyCode = WXK_ALT ;
+            event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+            focus->GetEventHandler()->ProcessEvent( event ) ;
+        }
+        s_lastModifiers = ev->modifiers ;
+    }
+}
+
 void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
 {
     // we must avoid reentrancy problems when processing high level events eg printing
@@ -1626,8 +1623,6 @@ void wxApp::MacHandleHighLevelEvent( WXEVENTREF evr )
     s_inYield = former ;
 }
 
-bool s_macIsInModalLoop = false ;
-
 void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
 {
     EventRecord* ev = (EventRecord*) evr ;
@@ -1657,16 +1652,14 @@ void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
             else
             {
                 UInt32 menuresult = MenuSelect(ev->where) ;
-                MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
+               MacHandleMenuSelect( HiWord( menuresult ) , LoWord( menuresult ) );
                 s_lastMouseDown = 0;
             }
             break ;
-#if !TARGET_CARBON
         case inSysWindow :
             SystemClick( ev , window ) ;
             s_lastMouseDown = 0;
             break ;
-#endif
         case inDrag :
             if ( window != frontWindow && s_macIsInModalLoop && !(ev->modifiers & cmdKey ) )
             {
@@ -1784,7 +1777,6 @@ void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
                         win->MacMouseDown( ev , windowPart ) ;
                 }
             break ;
-
         default:
             break;
     }
@@ -1822,6 +1814,8 @@ void wxApp::MacHandleMouseUpEvent( WXEVENTREF evr )
     }
 }
 
+#endif 
+
 long wxMacTranslateKey(unsigned char key, unsigned char code) ;
 long wxMacTranslateKey(unsigned char key, unsigned char code)
 {
@@ -1931,6 +1925,7 @@ long wxMacTranslateKey(unsigned char key, unsigned char code)
     return retval;
 }
 
+#if !TARGET_CARBON
 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
 {
     EventRecord* ev = (EventRecord*) evr ;
@@ -1962,6 +1957,23 @@ void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
     }
 }
 
+void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
+{
+    EventRecord* ev = (EventRecord*) evr ;
+    wxToolTip::RemoveToolTips() ;
+
+    UInt32 menuresult = UMAMenuEvent(ev) ;
+    if ( HiWord( menuresult ) )
+    {
+    }
+    else
+    {
+        MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
+    }
+}
+
+#endif
+
 bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
 {
     if ( !focus )
@@ -2092,22 +2104,6 @@ bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifi
     return handled ;
 }
 
-
-void wxApp::MacHandleKeyUpEvent( WXEVENTREF evr )
-{
-    EventRecord* ev = (EventRecord*) evr ;
-    wxToolTip::RemoveToolTips() ;
-
-    UInt32 menuresult = UMAMenuEvent(ev) ;
-    if ( HiWord( menuresult ) )
-    {
-    }
-    else
-    {
-        MacSendKeyUpEvent( wxWindow::FindFocus() , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) ;
-    }
-}
-
 bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey )
 {
     if ( !focus )
@@ -2149,6 +2145,8 @@ bool wxApp::MacSendKeyUpEvent( wxWindow* focus , long keymessage , long modifier
 
     return handled ;
 }
+
+#if !TARGET_CARBON
 void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
 {
     EventRecord* ev = (EventRecord*) evr ;
@@ -2165,7 +2163,7 @@ void wxApp::MacHandleActivateEvent( WXEVENTREF evr )
         }
         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
         if ( win )
-            win->MacActivate( ev , activate ) ;
+            win->MacActivate( ev->when , activate ) ;
     }
 }
 
@@ -2194,14 +2192,12 @@ void wxApp::MacHandleDiskEvent( WXEVENTREF evr )
     EventRecord* ev = (EventRecord*) evr ;
     if ( HiWord( ev->message ) != noErr )
   {
- #if !TARGET_CARBON
         OSErr err ;
         Point point ;
          SetPt( &point , 100 , 100 ) ;
 
           err = DIBadMount( point , ev->message ) ;
         wxASSERT( err == noErr ) ;
-#endif
     }
 }
 
@@ -2213,11 +2209,8 @@ void wxApp::MacHandleOSEvent( WXEVENTREF evr )
         case suspendResumeMessage :
             {
                 bool isResuming = ev->message & resumeFlag ;
-#if !TARGET_CARBON
                 bool convertClipboard = ev->message & convertClipboardFlag ;
-#else
-                bool convertClipboard = false;
-#endif
+
                 bool doesActivate = UMAGetProcessModeDoesActivateOnFGSwitch() ;
                 if ( isResuming )
                 {
@@ -2238,31 +2231,18 @@ void wxApp::MacHandleOSEvent( WXEVENTREF evr )
                     {
                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( oldFrontWindow ) ;
                         if ( win )
-                            win->MacActivate( ev , false ) ;
+                            win->MacActivate( ev->when , false ) ;
                     }
                     if ( newFrontWindow )
                     {
                         wxTopLevelWindowMac* win = wxFindWinFromMacWindow( newFrontWindow ) ;
                         if ( win )
-                            win->MacActivate( ev , true ) ;
+                            win->MacActivate( ev->when , true ) ;
                     }
                 }
                 else
                 {
                     MacSuspend( convertClipboard ) ;
-
-                    // in case this suspending did close an active window, another one might
-                    // have surfaced -> lets deactivate that one
-
-/* TODO : find out what to do on systems < 10 , perhaps FrontNonFloatingWindow
-                    WindowRef newActiveWindow = ::ActiveNonFloatingWindow() ;
-                    if ( newActiveWindow )
-                    {
-                        wxWindow* win = wxFindWinFromMacWindow( newActiveWindow ) ;
-                        if ( win )
-                            win->MacActivate( ev , false ) ;
-                    }
-*/
                 }
             }
             break ;
@@ -2365,7 +2345,28 @@ void wxApp::MacHandleOSEvent( WXEVENTREF evr )
 
     }
 }
+#endif
+
+void wxApp::MacHandleMenuCommand( wxUint32 id )
+{
+        wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
+        wxMenu* menu = NULL ;
+        wxMenuItem* item = NULL ;
+        if ( mbar )
+        {
+            item = mbar->FindItem( id , &menu ) ;
+        }
+        wxCHECK_RET( item != NULL && menu != NULL && mbar != NULL, wxT("error in menu item callback") );
+            
+        if (item->IsCheckable())
+        {
+            item->Check( !item->IsChecked() ) ;
+        }
+               
+               menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+}
 
+#if !TARGET_CARBON
 void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
 {
     if (macMenuId == 0)
@@ -2387,29 +2388,8 @@ void wxApp::MacHandleMenuSelect( int macMenuId , int macMenuItemNum )
     {
         MenuCommand id ;
         GetMenuItemCommandID( GetMenuHandle(macMenuId) , macMenuItemNum , &id ) ;
-        wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar() ;
-        wxMenu* menu = NULL ;
-        wxMenuItem* item = NULL ;
-        if ( mbar )
-        {
-            item = mbar->FindItem( id , &menu ) ;
-        }
-        wxCHECK_RET( item != NULL && menu != NULL && mbar != NULL, wxT("error in menu item callback") );
-            
-        if (item->IsCheckable())
-        {
-            item->Check( !item->IsChecked() ) ;
-        }
-               
-               menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
-               /*
-        wxWindow* frontwindow = wxFindWinFromMacWindow( ::FrontWindow() )  ;
-        wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, id );
-        event.m_timeStamp =  ((EventRecord*) MacGetCurrentEvent())->when ;
-        event.SetEventObject(menu);
-        event.SetInt(item->IsCheckable() ? item->IsChecked() : -1);
-        frontwindow->GetEventHandler()->ProcessEvent(event); 
-        */
+               MacHandleMenuCommand( id ) ;
     }
     HiliteMenu(0);
 }
+#endif
\ No newline at end of file