don't call SelectObject() twice in SetBrush() nor SetFont() neither

[wxWidgets.git] / src / mac / app.cpp

diff --git a/src/mac/app.cpp b/src/mac/app.cpp
index 58ee11d265470c94254c42014ddf0bae5c68a0e2..42e2c0aba8a650105bbe87cbc893b1e841c57695 100644 (file)
--- a/src/mac/app.cpp
+++ b/src/mac/app.cpp
@@ -37,6 +37,7 @@
 #include "wx/textctrl.h"
 #include "wx/menu.h"
 #include "wx/docview.h"
 #include "wx/textctrl.h"
 #include "wx/menu.h"
 #include "wx/docview.h"

+#include "wx/filename.h"

 
 #include <string.h>
 
 
 #include <string.h>
 


@@ -55,7 +56,7 @@
 
 #ifdef __DARWIN__
 #  include <CoreServices/CoreServices.h>
 
 #ifdef __DARWIN__
 #  include <CoreServices/CoreServices.h>

-#  if defined(WXMAKINGDLL)
+#  if defined(WXMAKINGDLL_CORE)

 #    include <mach-o/dyld.h>
 #  endif
 #else
 #    include <mach-o/dyld.h>
 #  endif
 #else


@@ -69,11 +70,13 @@
 extern wxList wxPendingDelete;
 extern wxList *wxWinMacWindowList;
 extern wxList *wxWinMacControlList;
 extern wxList wxPendingDelete;
 extern wxList *wxWinMacWindowList;
 extern wxList *wxWinMacControlList;

+#if wxUSE_THREADS
+extern size_t g_numberOfThreads;
+#endif // wxUSE_THREADS

 
 // statics for implementation
 
 static bool s_inYield = FALSE;
 
 // statics for implementation
 
 static bool s_inYield = FALSE;

-static bool s_inOnIdle = FALSE;

 
 #if TARGET_CARBON
 static bool s_inReceiveEvent = FALSE ;
 
 #if TARGET_CARBON
 static bool s_inReceiveEvent = FALSE ;


@@ -105,13 +108,14 @@ long      wxApp::sm_lastMessageTime = 0;
 long      wxApp::s_lastModifiers = 0 ;
 
 
 long      wxApp::s_lastModifiers = 0 ;
 
 

-bool      wxApp::s_macDefaultEncodingIsPC = true ;

 bool      wxApp::s_macSupportPCMenuShortcuts = true ;
 long      wxApp::s_macAboutMenuItemId = wxID_ABOUT ;
 bool      wxApp::s_macSupportPCMenuShortcuts = true ;
 long      wxApp::s_macAboutMenuItemId = wxID_ABOUT ;

-long      wxApp::s_macPreferencesMenuItemId = 0 ;
+long      wxApp::s_macPreferencesMenuItemId = wxID_PREFERENCES ;

 long      wxApp::s_macExitMenuItemId = wxID_EXIT ;
 wxString  wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
 
 long      wxApp::s_macExitMenuItemId = wxID_EXIT ;
 wxString  wxApp::s_macHelpMenuTitleName = wxT("&Help") ;
 

+// Normally we're not a plugin
+bool      wxApp::sm_isEmbedded = false;

 //----------------------------------------------------------------------
 // Core Apple Event Support
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 // Core Apple Event Support
 //----------------------------------------------------------------------


@@ -120,6 +124,7 @@ pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long re
 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 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 AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long refcon ) ;

 
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {
 
 pascal OSErr AEHandleODoc( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
 {


@@ -141,6 +146,11 @@ pascal OSErr AEHandleQuit( const AppleEvent *event , AppleEvent *reply , long WX
     return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
 }
 
     return wxTheApp->MacHandleAEQuit( (AppleEvent*) event , reply) ;
 }
 

+pascal OSErr AEHandleRApp( const AppleEvent *event , AppleEvent *reply , long WXUNUSED(refcon) )
+{
+    return wxTheApp->MacHandleAERApp( (AppleEvent*) event , reply) ;
+}
+

 // AEODoc Calls MacOpenFile on each of the files passed
 
 short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))
 // AEODoc Calls MacOpenFile on each of the files passed
 
 short wxApp::MacHandleAEODoc(const WXEVENTREF event, WXEVENTREF WXUNUSED(reply))


@@ -221,19 +231,27 @@ short wxApp::MacHandleAEOApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNU
 
 short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 {
 
 short wxApp::MacHandleAEQuit(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
 {

- /*   wxWindow* win = GetTopWindow() ;
+       wxWindow* win = GetTopWindow() ;

     if ( win )
     {
         win->Close(TRUE ) ;
     }
     if ( win )
     {
         win->Close(TRUE ) ;
     }

-    else
- */
+       else

     {
         ExitMainLoop() ;
     }
     return noErr ;
 }
 
     {
         ExitMainLoop() ;
     }
     return noErr ;
 }
 

+// AEROApp calls MacReopenApp
+
+short wxApp::MacHandleAERApp(const WXEVENTREF WXUNUSED(event) , WXEVENTREF WXUNUSED(reply))
+{
+    MacReopenApp() ;
+    return noErr ;
+}
+
+

 //----------------------------------------------------------------------
 // Support Routines linking the Mac...File Calls to the Document Manager
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 // Support Routines linking the Mac...File Calls to the Document Manager
 //----------------------------------------------------------------------


@@ -277,6 +295,11 @@ void wxApp::MacNewFile()
 {
 }
 
 {
 }
 

+void wxApp::MacReopenApp()
+{
+    // eventually check for open docs, if none, call MacNewFile
+}
+

 //----------------------------------------------------------------------
 // Carbon Event Handler
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 // Carbon Event Handler
 //----------------------------------------------------------------------


@@ -290,6 +313,7 @@ void wxApp::MacNewFile()
 
         { kEventClassMenu, kEventMenuOpening },
         { kEventClassMenu, kEventMenuClosed },
 
         { kEventClassMenu, kEventMenuOpening },
         { kEventClassMenu, kEventMenuClosed },

+        { kEventClassMenu, kEventMenuTargetItem },

 
         { kEventClassApplication , kEventAppActivated } ,
         { kEventClassApplication , kEventAppDeactivated } ,
 
         { kEventClassApplication , kEventAppActivated } ,
         { kEventClassApplication , kEventAppDeactivated } ,


@@ -299,14 +323,18 @@ void wxApp::MacNewFile()
         { kEventClassAppleEvent , kEventAppleEvent } ,
 
         { kEventClassMouse , kEventMouseDown } ,
         { kEventClassAppleEvent , kEventAppleEvent } ,
 
         { kEventClassMouse , kEventMouseDown } ,

+        { kEventClassMouse , kEventMouseMoved } ,
+        { kEventClassMouse , kEventMouseUp } ,
+        { kEventClassMouse , kEventMouseDragged } ,

         { 'WXMC' , 'WXMC' }
     } ;
 
 static pascal OSStatus
 MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
         { 'WXMC' , 'WXMC' }
     } ;
 
 static pascal OSStatus
 MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {

-    // FIXME: this doesn't work for multiple windows
-    wxWindow *win = wxTheApp->GetTopWindow();
+    wxMenuBar* mbar = wxMenuBar::MacGetInstalledMenuBar();
+    wxFrame* win = mbar->GetFrame();
+    

     if ( win )
     {
         // VZ: we could find the menu from its handle here by examining all
     if ( win )
     {
         // VZ: we could find the menu from its handle here by examining all


@@ -322,9 +350,29 @@ MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
                           &menuRef);
 #endif // 0
 
                           &menuRef);
 #endif // 0
 

-        wxMenuEvent wxevent(GetEventKind(event) == kEventMenuOpening
-                        ? wxEVT_MENU_OPEN
-                        : wxEVT_MENU_CLOSE);
+        wxEventType type=0;        
+        MenuCommand cmd=0;
+        switch (GetEventKind(event))
+        {
+            case kEventMenuOpening:
+                type = wxEVT_MENU_OPEN;
+                break;
+            case kEventMenuClosed:
+                type = wxEVT_MENU_CLOSE;
+                break;
+            case kEventMenuTargetItem:
+                type = wxEVT_MENU_HIGHLIGHT;
+                GetEventParameter(event, kEventParamMenuCommand,
+                                  typeMenuCommand, NULL,
+                                  sizeof(cmd), NULL, &cmd);
+                if (cmd == 0) return eventNotHandledErr;
+                break;
+            default:
+                wxFAIL_MSG(wxT("Unexpected menu event kind"));
+                break;
+        }
+
+        wxMenuEvent wxevent(type, cmd);

         wxevent.SetEventObject(win);
 
         (void)win->GetEventHandler()->ProcessEvent(wxevent);
         wxevent.SetEventObject(win);
 
         (void)win->GetEventHandler()->ProcessEvent(wxevent);


@@ -337,19 +385,36 @@ MenuEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 // but have to use ReceiveNextEvent dealing with events manually, therefore we also have
 // deal with clicks in the menu bar explicitely
 
 // but have to use ReceiveNextEvent dealing with events manually, therefore we also have
 // deal with clicks in the menu bar explicitely
 

+pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) ;
+

 static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
     OSStatus result = eventNotHandledErr ;
 
 static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 {
     OSStatus result = eventNotHandledErr ;
 

+    Point point ;
+    UInt32 modifiers = 0;
+    EventMouseButton button = 0 ;
+    UInt32 click = 0 ;
+
+    GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
+        sizeof( Point ), NULL, &point );
+    GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL,
+        sizeof( UInt32 ), NULL, &modifiers );
+    GetEventParameter( event, kEventParamMouseButton, typeMouseButton, NULL,
+        sizeof( EventMouseButton ), NULL, &button );
+    GetEventParameter( event, kEventParamClickCount, typeUInt32, NULL,
+        sizeof( UInt32 ), NULL, &click );
+
+    if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
+        modifiers += btnState ;
+
+

     switch( GetEventKind(event) )
     {
         case kEventMouseDown :
         {
     switch( GetEventKind(event) )
     {
         case kEventMouseDown :
         {

-            Point point ;

             WindowRef window ;
 
             WindowRef window ;
 

-            GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
-                sizeof( Point ), NULL, &point );

             short windowPart = ::FindWindow(point, &window);
 
             if ( windowPart == inMenuBar )
             short windowPart = ::FindWindow(point, &window);
 
             if ( windowPart == inMenuBar )


@@ -359,6 +424,20 @@ static pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef
             }
         }
         break ;
             }
         }
         break ;

+        case kEventMouseDragged :
+        case kEventMouseUp :
+        {
+            if ( wxTheApp->s_captureWindow )
+                wxMacWindowEventHandler( handler , event , (void*) wxTheApp->s_captureWindow->MacGetTopLevelWindow() ) ;
+        }
+        break ;
+        case kEventMouseMoved :
+        {
+            wxTheApp->MacHandleMouseMovedEvent( point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
+            result = noErr ;
+            break ;
+        }
+        break ;

     }
 
     return result ;
     }
 
     return result ;


@@ -382,7 +461,15 @@ static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventR
     wxMenuItem* item = NULL ;
 
     if ( mbar )
     wxMenuItem* item = NULL ;
 
     if ( mbar )

+    {

         item = mbar->FindItem( id , &menu ) ;
         item = mbar->FindItem( id , &menu ) ;

+        // it is not 100 % sure that an menu of id 0 is really ours, safety check
+        if ( id == 0 && menu != NULL && menu->GetHMenu() != command.menu.menuRef )
+        {
+            item = NULL ;
+            menu = NULL ;
+        }
+    }

 
     if ( item == NULL || menu == NULL || mbar == NULL )
         return result ;
 
     if ( item == NULL || menu == NULL || mbar == NULL )
         return result ;


@@ -402,7 +489,7 @@ static pascal OSStatus CommandEventHandler( EventHandlerCallRef handler , EventR
                break ;
         case kEventCommandUpdateStatus:
             // eventually trigger an updateui round
                break ;
         case kEventCommandUpdateStatus:
             // eventually trigger an updateui round

-                result = noErr ;
+            result = noErr ;

             break ;
            default :
                break ;
             break ;
            default :
                break ;


@@ -471,7 +558,7 @@ DEFINE_ONE_SHOT_HANDLER_GETTER( wxAppEventHandler )
 
 #endif
 
 
 #endif
 

-#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
+#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)

 // we know it's there ;-)
 WXIMPORT char std::__throws_bad_alloc ;
 #endif
 // we know it's there ;-)
 WXIMPORT char std::__throws_bad_alloc ;
 #endif


@@ -482,11 +569,11 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 
     // Mac-specific
 
 
     // Mac-specific
 

-    UMAInitToolbox( 4 ) ;
+    UMAInitToolbox( 4, sm_isEmbedded ) ;

     SetEventMask( everyEvent ) ;
     UMAShowWatchCursor() ;
 
     SetEventMask( everyEvent ) ;
     UMAShowWatchCursor() ;
 

-#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+#if defined(WXMAKINGDLL_CORE) && defined(__DARWIN__)

     // open shared library resources from here since we don't have
     //   __wxinitialize in Mach-O shared libraries
     wxStAppResource::OpenSharedLibraryResource(NULL);
     // open shared library resources from here since we don't have
     //   __wxinitialize in Mach-O shared libraries
     wxStAppResource::OpenSharedLibraryResource(NULL);


@@ -548,7 +635,7 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 
 #ifndef __DARWIN__
 #  if __option(profile)
 
 #ifndef __DARWIN__
 #  if __option(profile)

-    ProfilerInit( collectDetailed, bestTimeBase , 20000 , 40 ) ;
+    ProfilerInit( collectDetailed, bestTimeBase , 40000 , 50 ) ;

 #  endif
 #endif
 
 #  endif
 #endif
 


@@ -560,7 +647,6 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
 #endif
 
 #endif
 #endif
 
 #endif

-    wxMacSetupConverters() ;

 
     s_macCursorRgn = ::NewRgn() ;
 
 
     s_macCursorRgn = ::NewRgn() ;
 


@@ -571,16 +657,22 @@ bool wxApp::Initialize(int& argc, wxChar **argv)
     if ( argc > 1 )
     {
         static const wxChar *ARG_PSN = _T("-psn_");
     if ( argc > 1 )
     {
         static const wxChar *ARG_PSN = _T("-psn_");

-        if ( wxStrncmp(argv[1], ARG_PSN, sizeof(ARG_PSN) - 1) == 0 )
+        if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 )

         {
             // remove this argument
         {
             // remove this argument

-            memmove(argv, argv + 1, argc--);
+            --argc;
+            memmove(argv + 1, argv + 2, argc * sizeof(char *));

         }
     }
 
     if ( !wxAppBase::Initialize(argc, argv) )
         return false;
 
         }
     }
 
     if ( !wxAppBase::Initialize(argc, argv) )
         return false;
 

+#if wxUSE_INTL
+    wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
+#endif
+
+

     wxWinMacWindowList = new wxList(wxKEY_INTEGER);
     wxWinMacControlList = new wxList(wxKEY_INTEGER);
 
     wxWinMacWindowList = new wxList(wxKEY_INTEGER);
     wxWinMacControlList = new wxList(wxKEY_INTEGER);
 


@@ -599,38 +691,50 @@ bool wxApp::OnInitGui()
 #if TARGET_CARBON
     InstallStandardEventHandler( GetApplicationEventTarget() ) ;
 
 #if TARGET_CARBON
     InstallStandardEventHandler( GetApplicationEventTarget() ) ;
 

-    InstallApplicationEventHandler(
-        GetwxAppEventHandlerUPP(),
-        GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
+    if (!sm_isEmbedded)
+    {
+        InstallApplicationEventHandler(
+            GetwxAppEventHandlerUPP(),
+            GetEventTypeCount(eventList), eventList, wxTheApp, (EventHandlerRef *)&(wxTheApp->m_macEventHandler));
+    }

 #endif
 
 #endif
 

+    if (!sm_isEmbedded)
+    {

 #if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
 #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 ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+                               NewAEEventHandlerUPP(AEHandleODoc) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+                               NewAEEventHandlerUPP(AEHandleOApp) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+                               NewAEEventHandlerUPP(AEHandlePDoc) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
+                               NewAEEventHandlerUPP(AEHandleRApp) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+                               NewAEEventHandlerUPP(AEHandleQuit) ,
+                               0 , FALSE ) ;

 #else
 #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 ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEOpenDocuments ,
+                               NewAEEventHandlerProc(AEHandleODoc) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEOpenApplication ,
+                               NewAEEventHandlerProc(AEHandleOApp) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEPrintDocuments ,
+                               NewAEEventHandlerProc(AEHandlePDoc) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEReopenApplication ,
+                               NewAEEventHandlerProc(AEHandleRApp) ,
+                               0 , FALSE ) ;
+        AEInstallEventHandler( kCoreEventClass , kAEQuitApplication ,
+                               NewAEEventHandlerProc(AEHandleQuit) ,
+                               0 , FALSE ) ;

 #endif
 #endif

+    }

 
     return TRUE ;
 }
 
     return TRUE ;
 }


@@ -657,12 +761,11 @@ void wxApp::CleanUp()
 #  endif
 #endif
 
 #  endif
 #endif
 

-#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+#if defined(WXMAKINGDLL_CORE) && defined(__DARWIN__)

     // close shared library resources from here since we don't have
     //   __wxterminate in Mach-O shared libraries
     wxStAppResource::CloseSharedLibraryResource();
 #endif
     // close shared library resources from here since we don't have
     //   __wxterminate in Mach-O shared libraries
     wxStAppResource::CloseSharedLibraryResource();
 #endif

-    wxMacCleanupConverters() ;

 
     UMACleanupToolbox() ;
     if (s_macCursorRgn) {
 
     UMACleanupToolbox() ;
     if (s_macCursorRgn) {


@@ -684,9 +787,9 @@ void wxApp::CleanUp()
 // need to be able to find it with NSLookupAndBindSymbol
 short gSharedLibraryResource = kResFileNotOpened ;
 
 // need to be able to find it with NSLookupAndBindSymbol
 short gSharedLibraryResource = kResFileNotOpened ;
 

-#if defined(WXMAKINGDLL) && defined(__DARWIN__)
+#if defined(WXMAKINGDLL_CORE) && defined(__DARWIN__)

 CFBundleRef gSharedLibraryBundle = NULL;
 CFBundleRef gSharedLibraryBundle = NULL;

-#endif /* WXMAKINGDLL && __DARWIN__ */
+#endif /* WXMAKINGDLL_CORE && __DARWIN__ */

 
 wxStAppResource::wxStAppResource()
 {
 
 wxStAppResource::wxStAppResource()
 {


@@ -709,7 +812,7 @@ void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
 {
     gSharedLibraryResource = kResFileNotOpened;
 
 {
     gSharedLibraryResource = kResFileNotOpened;
 

-#ifdef WXMAKINGDLL
+#ifdef WXMAKINGDLL_CORE

     if ( initBlock != NULL ) {
         const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
         FSSpec *fileSpec = NULL;
     if ( initBlock != NULL ) {
         const CFragInitBlock *theInitBlock = (const CFragInitBlock *)initBlock;
         FSSpec *fileSpec = NULL;


@@ -742,9 +845,8 @@ void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
         else {
             // wxWindows is a simple dynamic shared library
             //   load the resources from the data fork of a separate resource file
         else {
             // wxWindows is a simple dynamic shared library
             //   load the resources from the data fork of a separate resource file

-            char  *theResPath;
-            char  *theName;
-            char  *theExt;
+            wxString theResPath;
+            wxString theName;

             FSRef  theResRef;
             OSErr  theErr = noErr;
 
             FSRef  theResRef;
             OSErr  theErr = noErr;
 


@@ -764,27 +866,28 @@ void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
 #endif
 
             // allocate copy to replace .dylib.* extension with .rsrc
 #endif
 
             // allocate copy to replace .dylib.* extension with .rsrc

-            theResPath = strdup(theLibPath);
-            if (theResPath != NULL) {
-                theName = strrchr(theResPath, '/');
-                if (theName == NULL) {
-                    // no directory elements in path
-                    theName = theResPath;
-                }
-                // find ".dylib" shared library extension
-                theExt = strstr(theName, ".dylib");
-                // overwrite extension with ".rsrc"
-                strcpy(theExt, ".rsrc");
+            if (theLibPath != NULL) {
+#if wxUSE_UNICODE
+                theResPath = wxString(theLibPath, wxConvLocal);
+#else
+                theResPath = wxString(theLibPath);
+#endif
+                // replace '_core' with '' in case of multi-lib build
+                theResPath.Replace(wxT("_core"), wxEmptyString);
+                // replace ".dylib" shared library extension with ".rsrc"
+                theResPath.Replace(wxT(".dylib"), wxT(".rsrc"));
+                // Find the begining of the filename
+                theName = theResPath.AfterLast('/');

 
 #if 0
                 wxLogDebug( wxT("wxMac resources file name is '%s'"),
 
 #if 0
                 wxLogDebug( wxT("wxMac resources file name is '%s'"),

-                            theResPath );
+                            theResPath.mb_str() );

 #endif
 
 #endif
 

-                theErr = FSPathMakeRef((UInt8 *) theResPath, &theResRef, false);
+                theErr = FSPathMakeRef((UInt8 *) theResPath.mb_str(), &theResRef, false);

                 if (theErr != noErr) {
                     // try in current directory (using name only)
                 if (theErr != noErr) {
                     // try in current directory (using name only)

-                    theErr = FSPathMakeRef((UInt8 *) theName, &theResRef, false);
+                    theErr = FSPathMakeRef((UInt8 *) theName.mb_str(), &theResRef, false);

                 }
 
                 // open the resource file
                 }
 
                 // open the resource file


@@ -794,24 +897,21 @@ void wxStAppResource::OpenSharedLibraryResource(const void *initBlock)
                 }
                 if (theErr != noErr) {
 #ifdef __WXDEBUG__
                 }
                 if (theErr != noErr) {
 #ifdef __WXDEBUG__

-                    fprintf(stderr,
-                            wxT("unable to open wxMac resource file '%s'\n"),
-                            theResPath );
+                    wxLogDebug( wxT("unable to open wxMac resource file '%s'\n"),
+                                theResPath.mb_str() );

 #endif // __WXDEBUG__
                 }
 
 #endif // __WXDEBUG__
                 }
 

-                // free duplicated resource file path
-                free(theResPath);

             }
         }
 #endif /* __DARWIN__ */
     }
             }
         }
 #endif /* __DARWIN__ */
     }

-#endif /* WXMAKINGDLL */
+#endif /* WXMAKINGDLL_CORE */

 }
 
 void wxStAppResource::CloseSharedLibraryResource()
 {
 }
 
 void wxStAppResource::CloseSharedLibraryResource()
 {

-#ifdef WXMAKINGDLL
+#ifdef WXMAKINGDLL_CORE

     // Close the shared library resource file
     if (gSharedLibraryResource != kResFileNotOpened) {
 #ifdef __DARWIN__
     // Close the shared library resource file
     if (gSharedLibraryResource != kResFileNotOpened) {
 #ifdef __DARWIN__


@@ -827,10 +927,10 @@ void wxStAppResource::CloseSharedLibraryResource()
         }
         gSharedLibraryResource = kResFileNotOpened;
     }
         }
         gSharedLibraryResource = kResFileNotOpened;
     }

-#endif /* WXMAKINGDLL */
+#endif /* WXMAKINGDLL_CORE */

 }
 
 }
 

-#if defined(WXMAKINGDLL) && !defined(__DARWIN__)
+#if defined(WXMAKINGDLL_CORE) && !defined(__DARWIN__)

 
 // for shared libraries we have to manually get the correct resource
 // ref num upon initializing and releasing when terminating, therefore
 
 // for shared libraries we have to manually get the correct resource
 // ref num upon initializing and releasing when terminating, therefore


@@ -854,7 +954,7 @@ pascal void __wxterminate(void)
     __terminate() ;
 }
 
     __terminate() ;
 }
 

-#endif /* WXMAKINGDLL && !__DARWIN__ */
+#endif /* WXMAKINGDLL_CORE && !__DARWIN__ */

 
 #if TARGET_CARBON
 
 
 #if TARGET_CARBON
 


@@ -970,22 +1070,13 @@ pascal OSStatus wxMacApplicationEventHandler( EventHandlerCallRef handler , Even
 
 wxApp::wxApp()
 {
 
 wxApp::wxApp()
 {

-  m_topWindow = NULL;
-  wxTheApp = this;
-
-  argc = 0;
-  argv = NULL;
-

   m_printMode = wxPRINT_WINDOWS;
   m_auto3D = TRUE;
   m_printMode = wxPRINT_WINDOWS;
   m_auto3D = TRUE;

-}

 
 

-bool wxApp::Initialized()
-{
-  if (GetTopWindow())
-    return TRUE;
-  else
-    return FALSE;
+  m_macCurrentEvent = NULL ;
+#if TARGET_CARBON
+  m_macCurrentEventHandlerCallRef = NULL ;
+#endif

 }
 
 int wxApp::MainLoop()
 }
 
 int wxApp::MainLoop()


@@ -1018,15 +1109,17 @@ bool wxApp::Pending()
 }
 
 // Dispatch a message.
 }
 
 // Dispatch a message.

-void wxApp::Dispatch()
+bool wxApp::Dispatch()

 {
     MacDoOneEvent() ;
 {
     MacDoOneEvent() ;

+
+    return true;

 }
 
 void wxApp::OnIdle(wxIdleEvent& event)
 {
     wxAppBase::OnIdle(event);
 }
 
 void wxApp::OnIdle(wxIdleEvent& event)
 {
     wxAppBase::OnIdle(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
     // 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


@@ -1154,7 +1247,7 @@ void wxApp::MacSuspend( bool convertClipboard )
 #if TARGET_CARBON
 #if 0 //  having problems right now with that
         if (!win->HasFlag(wxSTAY_ON_TOP))
 #if TARGET_CARBON
 #if 0 //  having problems right now with that
         if (!win->HasFlag(wxSTAY_ON_TOP))

-#endif  
+#endif

 #endif
             win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
 
 #endif
             win->MacActivate( ((EventRecord*) MacGetCurrentEvent())->when , false ) ;
 


@@ -1217,7 +1310,18 @@ void wxApp::MacDoOneEvent()
         if ( wxTheApp->ProcessIdle() )
             sleepTime = kEventDurationNoWait ;
         else
         if ( wxTheApp->ProcessIdle() )
             sleepTime = kEventDurationNoWait ;
         else

-            sleepTime = kEventDurationForever ;
+        {
+#if wxUSE_THREADS
+            if (g_numberOfThreads)
+            {
+                sleepTime = kEventDurationNoWait;
+            }
+            else
+#endif // wxUSE_THREADS
+            {
+                sleepTime = kEventDurationSecond;
+            }
+        }

     }
     else if ( status == eventLoopQuitErr )
     {
     }
     else if ( status == eventLoopQuitErr )
     {


@@ -1249,9 +1353,20 @@ void wxApp::MacDoOneEvent()
             ::IdleControls( window ) ;
 
         if ( wxTheApp->ProcessIdle() )
             ::IdleControls( window ) ;
 
         if ( wxTheApp->ProcessIdle() )

-            sleepTime = 0 ;
+            sleepTime = kEventDurationNoWait;

         else
         else

-            sleepTime = GetCaretTime() / 2 ;
+        {
+#if wxUSE_THREADS
+            if (g_numberOfThreads)
+            {
+                sleepTime = kEventDurationNoWait;
+            }
+            else
+#endif // wxUSE_THREADS
+            {
+                sleepTime = kEventDurationSecond;
+            }
+        }

     }
     if ( event.what != kHighLevelEvent )
         SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;
     }
     if ( event.what != kHighLevelEvent )
         SetRectRgn( (RgnHandle) s_macCursorRgn , event.where.h , event.where.v ,  event.where.h + 1 , event.where.v + 1 ) ;


@@ -1262,13 +1377,22 @@ void wxApp::MacDoOneEvent()
     wxMacProcessNotifierAndPendingEvents() ;
 }
 
     wxMacProcessNotifierAndPendingEvents() ;
 }
 

+/*virtual*/ void wxApp::MacHandleUnhandledEvent( WXEVENTREF evr )
+{
+    // Override to process unhandled events as you please    
+}
+

 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
 {
 #if TARGET_CARBON
     EventTargetRef theTarget;
     theTarget = GetEventDispatcherTarget();
     m_macCurrentEvent = evr ;
 void wxApp::MacHandleOneEvent( WXEVENTREF evr )
 {
 #if TARGET_CARBON
     EventTargetRef theTarget;
     theTarget = GetEventDispatcherTarget();
     m_macCurrentEvent = evr ;

-    SendEventToEventTarget ((EventRef) evr , theTarget);
+    OSStatus status = SendEventToEventTarget ((EventRef) evr , theTarget);
+    if(status == eventNotHandledErr)
+    {
+        MacHandleUnhandledEvent(evr);
+    }

 #else
     EventRecord* ev = (EventRecord*) evr ;
     m_macCurrentEvent = ev ;
 #else
     EventRecord* ev = (EventRecord*) evr ;
     m_macCurrentEvent = ev ;


@@ -1300,6 +1424,10 @@ void wxApp::MacHandleOneEvent( WXEVENTREF evr )
             MacHandleActivateEvent( ev ) ;
             break;
         case updateEvt:
             MacHandleActivateEvent( ev ) ;
             break;
         case updateEvt:

+            // In embedded mode we first let the UnhandledEvent function
+            // try to handle the update event. If we handle it ourselves
+            // first and then pass it on, the host's windows won't update.
+            MacHandleUnhandledEvent(ev);

             MacHandleUpdateEvent( ev ) ;
             break;
         case keyDown:
             MacHandleUpdateEvent( ev ) ;
             break;
         case keyDown:


@@ -1364,6 +1492,12 @@ void wxApp::MacHandleModifierEvents( WXEVENTREF evr )
             event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
             focus->GetEventHandler()->ProcessEvent( event ) ;
         }
             event.SetEventType( ( ev->modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
             focus->GetEventHandler()->ProcessEvent( event ) ;
         }

+        if ( ( ev->modifiers ^ s_lastModifiers ) & cmdKey )
+        {
+            event.m_keyCode = WXK_COMMAND ;
+            event.SetEventType( ( ev->modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
+            focus->GetEventHandler()->ProcessEvent( event ) ;
+        }

         s_lastModifiers = ev->modifiers ;
     }
 }
         s_lastModifiers = ev->modifiers ;
     }
 }


@@ -1521,9 +1655,12 @@ void wxApp::MacHandleMouseDownEvent( WXEVENTREF evr )
                     }
                     else
                     {
                     }
                     else
                     {

+                        // Activate window first
+                        ::SelectWindow( window ) ;
+
+                        // Send event later

                         if ( win )
                             win->MacMouseDown( ev , windowPart ) ;
                         if ( win )
                             win->MacMouseDown( ev , windowPart ) ;

-                        ::SelectWindow( window ) ;

                     }
                 }
                 else
                     }
                 }
                 else


@@ -1680,6 +1817,49 @@ long wxMacTranslateKey(unsigned char key, unsigned char code)
     return retval;
 }
 
     return retval;
 }
 

+int wxKeyCodeToMacModifier(wxKeyCode key)
+{
+    switch (key)
+    {
+    case WXK_START:
+    case WXK_MENU:
+        return cmdKey;
+
+    case WXK_SHIFT:
+        return shiftKey;
+
+    case WXK_CAPITAL:
+        return alphaLock;
+
+    case WXK_ALT:
+        return optionKey;
+
+    case WXK_CONTROL:
+        return controlKey;
+
+    default:
+        return 0;
+    }
+}
+
+bool wxGetKeyState(wxKeyCode key) //virtual key code if < 10.2.x, else see below
+{
+//#ifdef __DARWIN__
+//     wxHIDKeyboard keyboard;
+//     return keyboard.IsActive(key);
+//#else
+// TODO:  Have it use HID Manager on OSX...
+//if OS X > 10.2 (i.e. 10.2.x)
+//a known apple bug prevents the system from determining led
+//states with GetKeys... can only determine caps lock led
+   return !!(GetCurrentKeyModifiers() & wxKeyCodeToMacModifier(key)); 
+//else
+//  KeyMapByteArray keymap; 
+//  GetKeys((BigEndianLong*)keymap);
+//  return !!(BitTst(keymap, (sizeof(KeyMapByteArray)*8) - iKey));
+//#endif
+}
+

 #if !TARGET_CARBON
 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
 {
 #if !TARGET_CARBON
 void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
 {


@@ -1698,6 +1878,8 @@ void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
 
         if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
         {
 
         if ( MacSendKeyDownEvent( focus , ev->message , ev->modifiers , ev->when , ev->where.h , ev->where.v ) == false )
         {

+#if 0
+            // we must handle control keys the other way round, otherwise text content is updated too late

             // has not been handled -> perform default
             wxControl* control = wxDynamicCast( focus , wxControl ) ;
             if ( control &&  control->GetMacControl() != NULL )
             // has not been handled -> perform default
             wxControl* control = wxDynamicCast( focus , wxControl ) ;
             if ( control &&  control->GetMacControl() != NULL )


@@ -1708,6 +1890,7 @@ void wxApp::MacHandleKeyDownEvent( WXEVENTREF evr )
                 keycode = short(ev->message & keyCodeMask) >> 8 ;
                 ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
             }
                 keycode = short(ev->message & keyCodeMask) >> 8 ;
                 ::HandleControlKey( (ControlHandle) control->GetMacControl() , keycode , keychar , ev->modifiers ) ;
             }

+#endif

         }
     }
 }
         }
     }
 }


@@ -2100,6 +2283,111 @@ void wxApp::MacHandleOSEvent( WXEVENTREF evr )
 
     }
 }
 
     }
 }

+#else
+
+void wxApp::MacHandleMouseMovedEvent(wxInt32 x , wxInt32 y ,wxUint32 modifiers , long timestamp)
+{
+    WindowRef window;
+
+    wxWindow* currentMouseWindow = NULL ;
+
+    if (s_captureWindow )
+    {
+        currentMouseWindow = s_captureWindow ;
+    }
+    else
+    {
+        wxWindow::MacGetWindowFromPoint( wxPoint( x, y ) , &currentMouseWindow ) ;
+    }
+
+    if ( currentMouseWindow != wxWindow::s_lastMouseWindow )
+    {
+        wxMouseEvent event ;
+
+        bool isDown = !(modifiers & btnState) ; // 1 is for up
+        bool controlDown = modifiers & controlKey ; // for simulating right mouse
+
+        event.m_leftDown = isDown && !controlDown;
+
+        event.m_middleDown = FALSE;
+        event.m_rightDown = isDown && controlDown;
+
+        event.m_shiftDown = modifiers & shiftKey;
+        event.m_controlDown = modifiers & controlKey;
+        event.m_altDown = modifiers & optionKey;
+        event.m_metaDown = modifiers & cmdKey;
+
+        event.m_x = x;
+        event.m_y = y;
+        event.m_timeStamp = timestamp;
+
+        if ( wxWindow::s_lastMouseWindow )
+        {
+            wxMouseEvent eventleave(event);
+            eventleave.SetEventType( wxEVT_LEAVE_WINDOW );
+            wxWindow::s_lastMouseWindow->ScreenToClient( &eventleave.m_x, &eventleave.m_y );
+            eventleave.SetEventObject( wxWindow::s_lastMouseWindow ) ;
+
+#if wxUSE_TOOLTIPS
+            wxToolTip::RelayEvent( wxWindow::s_lastMouseWindow , eventleave);
+#endif // wxUSE_TOOLTIPS
+            wxWindow::s_lastMouseWindow->GetEventHandler()->ProcessEvent(eventleave);
+        }
+        if ( currentMouseWindow )
+        {
+            wxMouseEvent evententer(event);
+            evententer.SetEventType( wxEVT_ENTER_WINDOW );
+            currentMouseWindow->ScreenToClient( &evententer.m_x, &evententer.m_y );
+            evententer.SetEventObject( currentMouseWindow ) ;
+#if wxUSE_TOOLTIPS
+            wxToolTip::RelayEvent( currentMouseWindow , evententer);
+#endif // wxUSE_TOOLTIPS
+            currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
+        }
+        wxWindow::s_lastMouseWindow = currentMouseWindow ;
+    }
+
+    short windowPart = inNoWindow ;
+
+    if ( s_captureWindow )
+    {
+        window = (WindowRef) s_captureWindow->MacGetRootWindow() ;
+        windowPart = inContent ;
+    }
+    else
+    {
+        Point pt= { y , x } ;
+        windowPart = ::FindWindow(pt , &window);
+    }
+
+    switch (windowPart)
+    {
+        case inContent :
+            {
+                wxTopLevelWindowMac* win = wxFindWinFromMacWindow( window ) ;
+                if ( win )
+                    win->MacFireMouseEvent( nullEvent , x , y , modifiers , timestamp ) ;
+                else
+                {
+                    if ( wxIsBusy() )
+                    {
+                    }
+                    else
+                        UMAShowArrowCursor();
+                 }
+            }
+            break;
+        default :
+            {
+                if ( wxIsBusy() )
+                {
+                }
+                else
+                    UMAShowArrowCursor();
+            }
+            break ;
+    }
+}

 #endif
 
 void wxApp::MacHandleMenuCommand( wxUint32 id )
 #endif
 
 void wxApp::MacHandleMenuCommand( wxUint32 id )