Reorganize wxCollapsiblePane event and layout code under GTK+

[wxWidgets.git] / src / common / appbase.cpp

diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp
index 79cfe27e25e76892d352ae00a74083dea5a59f73..740deebb2b4b221369d1e0e38b48c13061ae7fd6 100644 (file)
--- a/src/common/appbase.cpp
+++ b/src/common/appbase.cpp
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/appbase.cpp
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/appbase.cpp

-// Purpose:     implements wxAppConsole class
+// Purpose:     implements wxAppConsoleBase class

 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     19.06.2003 (extracted from common/appcmn.cpp)
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     19.06.2003 (extracted from common/appcmn.cpp)


@@ -33,38 +33,36 @@
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/utils.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/utils.h"

+    #include "wx/wxcrtvararg.h"

 #endif //WX_PRECOMP
 
 #include "wx/apptrait.h"
 #include "wx/cmdline.h"
 #include "wx/confbase.h"
 #endif //WX_PRECOMP
 
 #include "wx/apptrait.h"
 #include "wx/cmdline.h"
 #include "wx/confbase.h"

+#include "wx/evtloop.h"

 #include "wx/filename.h"
 #include "wx/msgout.h"
 #include "wx/filename.h"
 #include "wx/msgout.h"

+#include "wx/ptr_scpd.h"

 #include "wx/tokenzr.h"
 #include "wx/tokenzr.h"

+#include "wx/thread.h"

 
 

+#if wxUSE_EXCEPTIONS && wxUSE_STL
+    #include <exception>
+    #include <typeinfo>
+#endif
+
+#ifndef __WXPALMOS5__

 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
   #include  <signal.h>      // for SIGTRAP used by wxTrap()
 #endif  //Win/Unix
 
 #include <locale.h>
 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
   #include  <signal.h>      // for SIGTRAP used by wxTrap()
 #endif  //Win/Unix
 
 #include <locale.h>

+#endif // ! __WXPALMOS5__

 
 #if wxUSE_FONTMAP
     #include "wx/fontmap.h"
 #endif // wxUSE_FONTMAP
 
 
 #if wxUSE_FONTMAP
     #include "wx/fontmap.h"
 #endif // wxUSE_FONTMAP
 

-#if defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
-    // For MacTypes.h for Debugger function
-    #include <CoreFoundation/CFBase.h>
-#endif
-
-#if defined(__WXMAC__)
-    #ifdef __DARWIN__
-        #include  <CoreServices/CoreServices.h>
-    #else
-        #include  "wx/mac/private.h"  // includes mac headers
-    #endif
-#endif // __WXMAC__
-

 #ifdef __WXDEBUG__
     #if wxUSE_STACKWALKER
         #include "wx/stackwalk.h"
 #ifdef __WXDEBUG__
     #if wxUSE_STACKWALKER
         #include "wx/stackwalk.h"


@@ -72,6 +70,8 @@
             #include "wx/msw/debughlp.h"
         #endif
     #endif // wxUSE_STACKWALKER
             #include "wx/msw/debughlp.h"
         #endif
     #endif // wxUSE_STACKWALKER

+
+    #include "wx/recguard.h"

 #endif // __WXDEBUG__
 
 // wxABI_VERSION can be defined when compiling applications but it should be
 #endif // __WXDEBUG__
 
 // wxABI_VERSION can be defined when compiling applications but it should be


@@ -92,11 +92,11 @@
     // prepare for showing the assert dialog, use the given traits or
     // DoShowAssertDialog() as last fallback to really show it
     static
     // prepare for showing the assert dialog, use the given traits or
     // DoShowAssertDialog() as last fallback to really show it
     static

-    void ShowAssertDialog(const wxChar *szFile,
+    void ShowAssertDialog(const wxString& szFile,

                           int nLine,
                           int nLine,

-                          const wxChar *szFunc,
-                          const wxChar *szCond,
-                          const wxChar *szMsg,
+                          const wxString& szFunc,
+                          const wxString& szCond,
+                          const wxString& szMsg,

                           wxAppTraits *traits = NULL);
 
     // turn on the trace masks specified in the env variable WXTRACE
                           wxAppTraits *traits = NULL);
 
     // turn on the trace masks specified in the env variable WXTRACE


@@ -107,23 +107,33 @@
 // global vars
 // ----------------------------------------------------------------------------
 
 // global vars
 // ----------------------------------------------------------------------------
 

-wxAppConsole *wxAppConsole::ms_appInstance = NULL;
+wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
+
+wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
+
+wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
+
+// ----------------------------------------------------------------------------
+// wxEventLoopPtr
+// ----------------------------------------------------------------------------

 
 

-wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
+// this defines wxEventLoopPtr
+wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)

 
 // ============================================================================
 
 // ============================================================================

-// wxAppConsole implementation
+// wxAppConsoleBase implementation

 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------
 
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------
 

-wxAppConsole::wxAppConsole()
+wxAppConsoleBase::wxAppConsoleBase()

 {
     m_traits = NULL;
 {
     m_traits = NULL;

+    m_mainLoop = NULL;

 
 

-    ms_appInstance = this;
+    ms_appInstance = static_cast<wxAppConsole *>(this);

 
 #ifdef __WXDEBUG__
     SetTraceMasks();
 
 #ifdef __WXDEBUG__
     SetTraceMasks();


@@ -137,7 +147,7 @@ wxAppConsole::wxAppConsole()
 #endif
 }
 
 #endif
 }
 

-wxAppConsole::~wxAppConsole()
+wxAppConsoleBase::~wxAppConsoleBase()

 {
     delete m_traits;
 }
 {
     delete m_traits;
 }


@@ -146,18 +156,18 @@ wxAppConsole::~wxAppConsole()
 // initilization/cleanup
 // ----------------------------------------------------------------------------
 
 // initilization/cleanup
 // ----------------------------------------------------------------------------
 

-bool wxAppConsole::Initialize(int& argcOrig, wxChar **argvOrig)
+bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **argv)

 {
 #if wxUSE_INTL
     GetTraits()->SetLocale();
 #endif // wxUSE_INTL
 
 {
 #if wxUSE_INTL
     GetTraits()->SetLocale();
 #endif // wxUSE_INTL
 

-    // remember the command line arguments
-    argc = argcOrig;
-    argv = argvOrig;
+#if wxUSE_THREADS
+    wxHandlersWithPendingEventsLocker = new wxCriticalSection;
+#endif

 
 #ifndef __WXPALMOS__
 
 #ifndef __WXPALMOS__

-    if ( m_appName.empty() && argv )
+    if ( m_appName.empty() && argv && argv[0] )

     {
         // the application name is, by default, the name of its executable file
         wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
     {
         // the application name is, by default, the name of its executable file
         wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);


@@ -167,15 +177,33 @@ bool wxAppConsole::Initialize(int& argcOrig, wxChar **argvOrig)
     return true;
 }
 
     return true;
 }
 

-void wxAppConsole::CleanUp()
+wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
+{
+    return GetTraits()->CreateEventLoop();
+}
+
+void wxAppConsoleBase::CleanUp()

 {
 {

+    if ( m_mainLoop )
+    {
+        delete m_mainLoop;
+        m_mainLoop = NULL;
+    }
+
+    delete wxHandlersWithPendingEvents;
+    wxHandlersWithPendingEvents = NULL;
+
+#if wxUSE_THREADS
+    delete wxHandlersWithPendingEventsLocker;
+    wxHandlersWithPendingEventsLocker = NULL;
+#endif // wxUSE_THREADS

 }
 
 // ----------------------------------------------------------------------------
 // OnXXX() callbacks
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // OnXXX() callbacks
 // ----------------------------------------------------------------------------
 

-bool wxAppConsole::OnInit()
+bool wxAppConsoleBase::OnInit()

 {
 #if wxUSE_CMDLINE_PARSER
     wxCmdLineParser parser(argc, argv);
 {
 #if wxUSE_CMDLINE_PARSER
     wxCmdLineParser parser(argc, argv);


@@ -205,32 +233,40 @@ bool wxAppConsole::OnInit()
     return true;
 }
 
     return true;
 }
 

-int wxAppConsole::OnExit()
+int wxAppConsoleBase::OnRun()
+{
+    return MainLoop();
+}
+
+int wxAppConsoleBase::OnExit()

 {
 #if wxUSE_CONFIG
     // delete the config object if any (don't use Get() here, but Set()
     // because Get() could create a new config object)
 {
 #if wxUSE_CONFIG
     // delete the config object if any (don't use Get() here, but Set()
     // because Get() could create a new config object)

-    delete wxConfigBase::Set((wxConfigBase *) NULL);
+    delete wxConfigBase::Set(NULL);

 #endif // wxUSE_CONFIG
 
     return 0;
 }
 
 #endif // wxUSE_CONFIG
 
     return 0;
 }
 

-void wxAppConsole::Exit()
+void wxAppConsoleBase::Exit()

 {
 {

-    exit(-1);
+    if (m_mainLoop != NULL)
+        ExitMainLoop();
+    else
+        exit(-1);

 }
 
 // ----------------------------------------------------------------------------
 // traits stuff
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // traits stuff
 // ----------------------------------------------------------------------------
 

-wxAppTraits *wxAppConsole::CreateTraits()
+wxAppTraits *wxAppConsoleBase::CreateTraits()

 {
     return new wxConsoleAppTraits;
 }
 
 {
     return new wxConsoleAppTraits;
 }
 

-wxAppTraits *wxAppConsole::GetTraits()
+wxAppTraits *wxAppConsoleBase::GetTraits()

 {
     // FIXME-MT: protect this with a CS?
     if ( !m_traits )
 {
     // FIXME-MT: protect this with a CS?
     if ( !m_traits )


@@ -243,48 +279,123 @@ wxAppTraits *wxAppConsole::GetTraits()
     return m_traits;
 }
 
     return m_traits;
 }
 

+/* static */
+wxAppTraits *wxAppConsoleBase::GetTraitsIfExists()
+{
+    wxAppConsole * const app = GetInstance();
+    return app ? app->GetTraits() : NULL;
+}
+

 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------
 

-void wxAppConsole::ProcessPendingEvents()
+int wxAppConsoleBase::MainLoop()
+{
+    wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
+
+    return m_mainLoop ? m_mainLoop->Run() : -1;
+}
+
+void wxAppConsoleBase::ExitMainLoop()
+{
+    // we should exit from the main event loop, not just any currently active
+    // (e.g. modal dialog) event loop
+    if ( m_mainLoop && m_mainLoop->IsRunning() )
+    {
+        m_mainLoop->Exit(0);
+    }
+}
+
+bool wxAppConsoleBase::Pending()
+{
+    // use the currently active message loop here, not m_mainLoop, because if
+    // we're showing a modal dialog (with its own event loop) currently the
+    // main event loop is not running anyhow
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    return loop && loop->Pending();
+}
+
+bool wxAppConsoleBase::Dispatch()
+{
+    // see comment in Pending()
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    return loop && loop->Dispatch();
+}
+
+bool wxAppConsoleBase::HasPendingEvents() const
+{
+    wxENTER_CRIT_SECT( *wxHandlersWithPendingEventsLocker );
+
+    bool has = wxHandlersWithPendingEvents && !wxHandlersWithPendingEvents->IsEmpty();
+
+    wxLEAVE_CRIT_SECT( *wxHandlersWithPendingEventsLocker );
+
+    return has;
+}
+
+/* static */
+bool wxAppConsoleBase::IsMainLoopRunning()
+{
+    const wxAppConsole * const app = GetInstance();
+
+    return app && app->m_mainLoop != NULL;
+}
+
+void wxAppConsoleBase::ProcessPendingEvents()

 {
 #if wxUSE_THREADS
 {
 #if wxUSE_THREADS

-    if ( !wxPendingEventsLocker )
+    if ( !wxHandlersWithPendingEventsLocker )

         return;
 #endif
 
         return;
 #endif
 

-    // ensure that we're the only thread to modify the pending events list
-    wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+    wxENTER_CRIT_SECT( *wxHandlersWithPendingEventsLocker );

 
 

-    if ( !wxPendingEvents )
+    if (wxHandlersWithPendingEvents)

     {
     {

-        wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
-        return;
-    }
+        // iterate until the list becomes empty: the handlers remove themselves
+        // from it when they don't have any more pending events
+        wxList::compatibility_iterator node = wxHandlersWithPendingEvents->GetFirst();
+        while (node)
+        {
+            // In ProcessPendingEvents(), new handlers might be add
+            // and we can safely leave the critical section here.
+            wxLEAVE_CRIT_SECT( *wxHandlersWithPendingEventsLocker );

 
 

-    // iterate until the list becomes empty
-    wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
-    while (node)
-    {
-        wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
-        wxPendingEvents->Erase(node);
+            wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
+            handler->ProcessPendingEvents();
+
+            wxENTER_CRIT_SECT( *wxHandlersWithPendingEventsLocker );
+
+            // restart as the iterators could have been invalidated
+            node = wxHandlersWithPendingEvents->GetFirst();
+        }
+    }

 
 

-        // In ProcessPendingEvents(), new handlers might be add
-        // and we can safely leave the critical section here.
-        wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+    wxLEAVE_CRIT_SECT( *wxHandlersWithPendingEventsLocker );
+}

 
 

-        handler->ProcessPendingEvents();
+void wxAppConsoleBase::WakeUpIdle()
+{
+    if ( m_mainLoop )
+        m_mainLoop->WakeUp();
+}

 
 

-        wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+bool wxAppConsoleBase::ProcessIdle()
+{
+    // process pending wx events before sending idle events
+    ProcessPendingEvents();

 
 

-        node = wxPendingEvents->GetFirst();
-    }
+    wxIdleEvent event;

 
 

-    wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+    event.SetEventObject(this);
+    ProcessEvent(event);
+    return event.MoreRequested();

 }
 
 }
 

-int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
+int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))

 {
     // process the events normally by default
     return -1;
 {
     // process the events normally by default
     return -1;


@@ -297,14 +408,70 @@ int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
 #if wxUSE_EXCEPTIONS
 
 void
 #if wxUSE_EXCEPTIONS
 
 void

-wxAppConsole::HandleEvent(wxEvtHandler *handler,
-                          wxEventFunction func,
-                          wxEvent& event) const
+wxAppConsoleBase::HandleEvent(wxEvtHandler *handler,
+                              wxEventFunction func,
+                              wxEvent& event) const

 {
     // by default, simply call the handler
     (handler->*func)(event);
 }
 
 {
     // by default, simply call the handler
     (handler->*func)(event);
 }
 

+void wxAppConsoleBase::CallEventHandler(wxEvtHandler *handler,
+                                        wxEventFunctor& functor,
+                                        wxEvent& event) const
+{
+    // If the functor holds a method then, for backward compatibility, call
+    // HandleEvent():
+    wxEventFunction eventFunction = functor.GetMethod();
+
+    if ( eventFunction )
+        HandleEvent(handler, eventFunction, event);
+    else
+        functor(handler, event);
+}
+
+void wxAppConsoleBase::OnUnhandledException()
+{
+#ifdef __WXDEBUG__
+    // we're called from an exception handler so we can re-throw the exception
+    // to recover its type
+    wxString what;
+    try
+    {
+        throw;
+    }
+#if wxUSE_STL
+    catch ( std::exception& e )
+    {
+        what.Printf("std::exception of type \"%s\", what() = \"%s\"",
+                    typeid(e).name(), e.what());
+    }
+#endif // wxUSE_STL
+    catch ( ... )
+    {
+        what = "unknown exception";
+    }
+
+    wxMessageOutputBest().Printf(
+        "*** Caught unhandled %s; terminating\n", what
+    );
+#endif // __WXDEBUG__
+}
+
+// ----------------------------------------------------------------------------
+// exceptions support
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::OnExceptionInMainLoop()
+{
+    throw;
+
+    // some compilers are too stupid to know that we never return after throw
+#if defined(__DMC__) || (defined(_MSC_VER) && _MSC_VER < 1200)
+    return false;
+#endif
+}
+

 #endif // wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------


@@ -313,17 +480,17 @@ wxAppConsole::HandleEvent(wxEvtHandler *handler,
 
 #if wxUSE_CMDLINE_PARSER
 
 
 #if wxUSE_CMDLINE_PARSER
 

-#define OPTION_VERBOSE _T("verbose")
+#define OPTION_VERBOSE "verbose"

 
 

-void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
+void wxAppConsoleBase::OnInitCmdLine(wxCmdLineParser& parser)

 {
     // the standard command line options
     static const wxCmdLineEntryDesc cmdLineDesc[] =
     {
         {
             wxCMD_LINE_SWITCH,
 {
     // the standard command line options
     static const wxCmdLineEntryDesc cmdLineDesc[] =
     {
         {
             wxCMD_LINE_SWITCH,

-            _T("h"),
-            _T("help"),
+            "h",
+            "help",

             gettext_noop("show this help message"),
             wxCMD_LINE_VAL_NONE,
             wxCMD_LINE_OPTION_HELP
             gettext_noop("show this help message"),
             wxCMD_LINE_VAL_NONE,
             wxCMD_LINE_OPTION_HELP


@@ -332,7 +499,7 @@ void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
 #if wxUSE_LOG
         {
             wxCMD_LINE_SWITCH,
 #if wxUSE_LOG
         {
             wxCMD_LINE_SWITCH,

-            wxEmptyString,
+            NULL,

             OPTION_VERBOSE,
             gettext_noop("generate verbose log messages"),
             wxCMD_LINE_VAL_NONE,
             OPTION_VERBOSE,
             gettext_noop("generate verbose log messages"),
             wxCMD_LINE_VAL_NONE,


@@ -341,20 +508,13 @@ void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
 #endif // wxUSE_LOG
 
         // terminator
 #endif // wxUSE_LOG
 
         // terminator

-        {
-            wxCMD_LINE_NONE,
-            wxEmptyString,
-            wxEmptyString,
-            wxEmptyString,
-            wxCMD_LINE_VAL_NONE,
-            0x0
-        }
+        wxCMD_LINE_DESC_END

     };
 
     parser.SetDesc(cmdLineDesc);
 }
 
     };
 
     parser.SetDesc(cmdLineDesc);
 }
 

-bool wxAppConsole::OnCmdLineParsed(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineParsed(wxCmdLineParser& parser)

 {
 #if wxUSE_LOG
     if ( parser.Found(OPTION_VERBOSE) )
 {
 #if wxUSE_LOG
     if ( parser.Found(OPTION_VERBOSE) )


@@ -368,14 +528,14 @@ bool wxAppConsole::OnCmdLineParsed(wxCmdLineParser& parser)
     return true;
 }
 
     return true;
 }
 

-bool wxAppConsole::OnCmdLineHelp(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineHelp(wxCmdLineParser& parser)

 {
     parser.Usage();
 
     return false;
 }
 
 {
     parser.Usage();
 
     return false;
 }
 

-bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineError(wxCmdLineParser& parser)

 {
     parser.Usage();
 
 {
     parser.Usage();
 


@@ -389,8 +549,8 @@ bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
 // ----------------------------------------------------------------------------
 
 /* static */
 // ----------------------------------------------------------------------------
 
 /* static */

-bool wxAppConsole::CheckBuildOptions(const char *optionsSignature,
-                                     const char *componentName)
+bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
+                                         const char *componentName)

 {
 #if 0 // can't use wxLogTrace, not up and running yet
     printf("checking build options object '%s' (ptr %p) in '%s'\n",
 {
 #if 0 // can't use wxLogTrace, not up and running yet
     printf("checking build options object '%s' (ptr %p) in '%s'\n",


@@ -419,19 +579,19 @@ bool wxAppConsole::CheckBuildOptions(const char *optionsSignature,
 
 #ifdef __WXDEBUG__
 
 
 #ifdef __WXDEBUG__
 

-void wxAppConsole::OnAssertFailure(const wxChar *file,
-                                   int line,
-                                   const wxChar *func,
-                                   const wxChar *cond,
-                                   const wxChar *msg)
+void wxAppConsoleBase::OnAssertFailure(const wxChar *file,
+                                       int line,
+                                       const wxChar *func,
+                                       const wxChar *cond,
+                                       const wxChar *msg)

 {
     ShowAssertDialog(file, line, func, cond, msg, GetTraits());
 }
 
 {
     ShowAssertDialog(file, line, func, cond, msg, GetTraits());
 }
 

-void wxAppConsole::OnAssert(const wxChar *file,
-                            int line,
-                            const wxChar *cond,
-                            const wxChar *msg)
+void wxAppConsoleBase::OnAssert(const wxChar *file,
+                                int line,
+                                const wxChar *cond,
+                                const wxChar *msg)

 {
     OnAssertFailure(file, line, NULL, cond, msg);
 }
 {
     OnAssertFailure(file, line, NULL, cond, msg);
 }


@@ -498,13 +658,6 @@ void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object)
     // nothing to do
 }
 
     // nothing to do
 }
 

-#if wxUSE_SOCKETS
-GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
-{
-    return NULL;
-}
-#endif
-

 // ----------------------------------------------------------------------------
 // wxAppTraits
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxAppTraits
 // ----------------------------------------------------------------------------


@@ -512,11 +665,40 @@ GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
 #if wxUSE_INTL
 void wxAppTraitsBase::SetLocale()
 {
 #if wxUSE_INTL
 void wxAppTraitsBase::SetLocale()
 {

-    setlocale(LC_ALL, "");
+    wxSetlocale(LC_ALL, "");

     wxUpdateLocaleIsUtf8();
 }
 #endif
 
     wxUpdateLocaleIsUtf8();
 }
 #endif
 

+#if wxUSE_THREADS
+void wxMutexGuiEnterImpl();
+void wxMutexGuiLeaveImpl();
+
+void wxAppTraitsBase::MutexGuiEnter()
+{
+    wxMutexGuiEnterImpl();
+}
+
+void wxAppTraitsBase::MutexGuiLeave()
+{
+    wxMutexGuiLeaveImpl();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiEnter()
+{
+    wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+    if ( traits )
+        traits->MutexGuiEnter();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiLeave()
+{
+    wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+    if ( traits )
+        traits->MutexGuiLeave();
+}
+#endif // wxUSE_THREADS
+

 #ifdef __WXDEBUG__
 
 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 #ifdef __WXDEBUG__
 
 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)


@@ -644,12 +826,6 @@ void wxTrap()
 {
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
     DebugBreak();
 {
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
     DebugBreak();

-#elif defined(__WXMAC__) && !defined(__DARWIN__)
-    #if __powerc
-        Debugger();
-    #else
-        SysBreak();
-    #endif

 #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
     Debugger();
 #elif defined(__UNIX__)
 #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
     Debugger();
 #elif defined(__UNIX__)


@@ -660,45 +836,111 @@ void wxTrap()
 }
 
 // this function is called when an assert fails
 }
 
 // this function is called when an assert fails

-void wxOnAssert(const wxChar *szFile,
-                int nLine,
-                const char *szFunc,
-                const wxChar *szCond,
-                const wxChar *szMsg)
+static void wxDoOnAssert(const wxString& szFile,
+                         int nLine,
+                         const wxString& szFunc,
+                         const wxString& szCond,
+                         const wxString& szMsg = wxEmptyString)

 {
     // FIXME MT-unsafe
 {
     // FIXME MT-unsafe

-    static bool s_bInAssert = false;
+    static int s_bInAssert = 0;

 
 

-    if ( s_bInAssert )
+    wxRecursionGuard guard(s_bInAssert);
+    if ( guard.IsInside() )

     {
     {

-        // He-e-e-e-elp!! we're trapped in endless loop
+        // can't use assert here to avoid infinite loops, so just trap

         wxTrap();
 
         wxTrap();
 

-        s_bInAssert = false;
-

         return;
     }
 
         return;
     }
 

-    s_bInAssert = true;
-
-    // __FUNCTION__ is always in ASCII, convert it to wide char if needed
-    const wxString strFunc = wxString::FromAscii(szFunc);
-

     if ( !wxTheApp )
     {
         // by default, show the assert dialog box -- we can't customize this
         // behaviour
     if ( !wxTheApp )
     {
         // by default, show the assert dialog box -- we can't customize this
         // behaviour

-        ShowAssertDialog(szFile, nLine, strFunc, szCond, szMsg);
+        ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg);

     }
     else
     {
         // let the app process it as it wants
     }
     else
     {
         // let the app process it as it wants

-        wxTheApp->OnAssertFailure(szFile, nLine, strFunc, szCond, szMsg);
+        // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
+        wxTheApp->OnAssertFailure(szFile.c_str(), nLine, szFunc.c_str(),
+                                  szCond.c_str(), szMsg.c_str());

     }
     }

+}
+
+void wxOnAssert(const wxString& szFile,
+                int nLine,
+                const wxString& szFunc,
+                const wxString& szCond,
+                const wxString& szMsg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const wxString& szFile,
+                int nLine,
+                const wxString& szFunc,
+                const wxString& szCond)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond);
+}
+
+void wxOnAssert(const wxChar *szFile,
+                int nLine,
+                const char *szFunc,
+                const wxChar *szCond,
+                const wxChar *szMsg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}

 
 

-    s_bInAssert = false;
+void wxOnAssert(const char *szFile,
+                int nLine,
+                const char *szFunc,
+                const char *szCond,
+                const wxString& szMsg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);

 }
 
 }
 

+void wxOnAssert(const char *szFile,
+                int nLine,
+                const char *szFunc,
+                const char *szCond,
+                const wxCStrData& msg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, msg);
+}
+
+#if wxUSE_UNICODE
+void wxOnAssert(const char *szFile,
+                int nLine,
+                const char *szFunc,
+                const char *szCond)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond);
+}
+
+void wxOnAssert(const char *szFile,
+                int nLine,
+                const char *szFunc,
+                const char *szCond,
+                const char *szMsg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const char *szFile,
+                int nLine,
+                const char *szFunc,
+                const char *szCond,
+                const wxChar *szMsg)
+{
+    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+#endif // wxUSE_UNICODE
+

 #endif // __WXDEBUG__
 
 // ============================================================================
 #endif // __WXDEBUG__
 
 // ============================================================================


@@ -720,6 +962,7 @@ static void LINKAGEMODE SetTraceMasks()
 #endif // wxUSE_LOG
 }
 
 #endif // wxUSE_LOG
 }
 

+static

 bool DoShowAssertDialog(const wxString& msg)
 {
     // under MSW we can show the dialog even in the console mode
 bool DoShowAssertDialog(const wxString& msg)
 {
     // under MSW we can show the dialog even in the console mode


@@ -732,7 +975,7 @@ bool DoShowAssertDialog(const wxString& msg)
               wxT("You can also choose [Cancel] to suppress ")
               wxT("further warnings.");
 
               wxT("You can also choose [Cancel] to suppress ")
               wxT("further warnings.");
 

-    switch ( ::MessageBox(NULL, msgDlg, _T("wxWidgets Debug Alert"),
+    switch ( ::MessageBox(NULL, msgDlg.wx_str(), _T("wxWidgets Debug Alert"),

                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:
                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:


@@ -759,11 +1002,11 @@ bool DoShowAssertDialog(const wxString& msg)
 
 // show the assert modal dialog
 static
 
 // show the assert modal dialog
 static

-void ShowAssertDialog(const wxChar *szFile,
+void ShowAssertDialog(const wxString& szFile,

                       int nLine,
                       int nLine,

-                      const wxChar *szFunc,
-                      const wxChar *szCond,
-                      const wxChar *szMsg,
+                      const wxString& szFunc,
+                      const wxString& szCond,
+                      const wxString& szMsg,

                       wxAppTraits *traits)
 {
     // this variable can be set to true to suppress "assert failure" messages
                       wxAppTraits *traits)
 {
     // this variable can be set to true to suppress "assert failure" messages


@@ -778,11 +1021,11 @@ void ShowAssertDialog(const wxChar *szFile,
     msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
 
     // add the function name, if any
     msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
 
     // add the function name, if any

-    if ( szFunc && *szFunc )
+    if ( !szFunc.empty() )

         msg << _T(" in ") << szFunc << _T("()");
 
     // and the message itself
         msg << _T(" in ") << szFunc << _T("()");
 
     // and the message itself

-    if ( szMsg )
+    if ( !szMsg.empty() )

     {
         msg << _T(": ") << szMsg;
     }
     {
         msg << _T(": ") << szMsg;
     }


@@ -800,7 +1043,7 @@ void ShowAssertDialog(const wxChar *szFile,
 
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
         msg << wxT("\r\n");
 
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
         msg << wxT("\r\n");

-        OutputDebugString(msg );
+        OutputDebugString(msg.wx_str());

 #else
         // send to stderr
         wxFprintf(stderr, wxT("%s\n"), msg.c_str());
 #else
         // send to stderr
         wxFprintf(stderr, wxT("%s\n"), msg.c_str());