]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/appbase.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Make wxPORTRAIT and wxLANDSCAPE elements of wxPrintOrientation enum.
[wxWidgets.git] / src / common / appbase.cpp
diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp
index aeeb572a1bc87f41ee2a50007f279103ed691a02..f2bed9aca81dc2336602f5fe32fed92659826434 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)
@@ -42,40 +42,37 @@
 #include "wx/evtloop.h"
 #include "wx/filename.h"
 #include "wx/msgout.h"
 #include "wx/evtloop.h"
 #include "wx/filename.h"
 #include "wx/msgout.h"
-#include "wx/ptr_scpd.h"
+#include "wx/scopedptr.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 wxDEBUG_LEVEL
     #if wxUSE_STACKWALKER
         #include "wx/stackwalk.h"
         #ifdef __WXMSW__
             #include "wx/msw/debughlp.h"
         #endif
     #endif // wxUSE_STACKWALKER
     #if wxUSE_STACKWALKER
         #include "wx/stackwalk.h"
         #ifdef __WXMSW__
             #include "wx/msw/debughlp.h"
         #endif
     #endif // wxUSE_STACKWALKER
-#endif // __WXDEBUG__
+
+    #include "wx/recguard.h"
+#endif // wxDEBUG_LEVEL
 
 // wxABI_VERSION can be defined when compiling applications but it should be
 // left undefined when compiling the library itself, it is then set to its
 
 // wxABI_VERSION can be defined when compiling applications but it should be
 // left undefined when compiling the library itself, it is then set to its
@@ -88,20 +85,22 @@
 // private functions prototypes
 // ----------------------------------------------------------------------------
 
 // private functions prototypes
 // ----------------------------------------------------------------------------
 
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL
     // really just show the assert dialog
     static bool DoShowAssertDialog(const wxString& msg);
 
     // prepare for showing the assert dialog, use the given traits or
     // DoShowAssertDialog() as last fallback to really show it
     static
     // really just show the assert dialog
     static bool DoShowAssertDialog(const wxString& msg);
 
     // prepare for showing the assert dialog, use the given traits or
     // DoShowAssertDialog() as last fallback to really show it
     static
-    void ShowAssertDialog(const wxString& szFile,
-                          int nLine,
-                          const wxString& szFunc,
-                          const wxString& szCond,
-                          const wxString& szMsg,
+    void ShowAssertDialog(const wxString& file,
+                          int line,
+                          const wxString& func,
+                          const wxString& cond,
+                          const wxString& msg,
                           wxAppTraits *traits = NULL);
                           wxAppTraits *traits = NULL);
+#endif // wxDEBUG_LEVEL
 
 
+#ifdef __WXDEBUG__
     // turn on the trace masks specified in the env variable WXTRACE
     static void LINKAGEMODE SetTraceMasks();
 #endif // __WXDEBUG__
     // turn on the trace masks specified in the env variable WXTRACE
     static void LINKAGEMODE SetTraceMasks();
 #endif // __WXDEBUG__
@@ -110,31 +109,36 @@
 // global vars
 // ----------------------------------------------------------------------------
 
 // global vars
 // ----------------------------------------------------------------------------
 
-wxAppConsole *wxAppConsole::ms_appInstance = NULL;
+wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
 
 
-wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
+wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
+
+wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
+
+WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
 
 // ----------------------------------------------------------------------------
 // wxEventLoopPtr
 // ----------------------------------------------------------------------------
 
 // this defines wxEventLoopPtr
 
 // ----------------------------------------------------------------------------
 // wxEventLoopPtr
 // ----------------------------------------------------------------------------
 
 // this defines wxEventLoopPtr
-wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoop)
+wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)
 
 // ============================================================================
 
 // ============================================================================
-// wxAppConsole implementation
+// wxAppConsoleBase implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------
 
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------
 
-wxAppConsole::wxAppConsole()
+wxAppConsoleBase::wxAppConsoleBase()
 {
     m_traits = NULL;
     m_mainLoop = NULL;
 {
     m_traits = NULL;
     m_mainLoop = NULL;
+    m_bDoPendingEventProcessing = true;
 
 
-    ms_appInstance = this;
+    ms_appInstance = static_cast<wxAppConsole *>(this);
 
 #ifdef __WXDEBUG__
     SetTraceMasks();
 
 #ifdef __WXDEBUG__
     SetTraceMasks();
@@ -148,67 +152,79 @@ wxAppConsole::wxAppConsole()
 #endif
 }
 
 #endif
 }
 
-wxAppConsole::~wxAppConsole()
+wxAppConsoleBase::~wxAppConsoleBase()
 {
 {
+    // we're being destroyed and using this object from now on may not work or
+    // even crash so don't leave dangling pointers to it
+    ms_appInstance = NULL;
+
     delete m_traits;
 }
 
 // ----------------------------------------------------------------------------
     delete m_traits;
 }
 
 // ----------------------------------------------------------------------------
-// initilization/cleanup
+// initialization/cleanup
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-bool wxAppConsole::Initialize(int& argcOrig, wxChar **argvOrig)
+bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **WXUNUSED(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
-    wxPendingEventsLocker = new wxCriticalSection;
-#endif
-
-    // create port-specific main loop
-    m_mainLoop = CreateMainLoop();
+    return true;
+}
 
 
+wxString wxAppConsoleBase::GetAppName() const
+{
+    wxString name = m_appName;
 #ifndef __WXPALMOS__
 #ifndef __WXPALMOS__
-    if ( m_appName.empty() && argv )
+    if ( name.empty() )
     {
     {
-        // the application name is, by default, the name of its executable file
-        wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
+        if ( argv )
+        {
+            // the application name is, by default, the name of its executable file
+            wxFileName::SplitPath(argv[0], NULL, &name, NULL);
+        }
     }
 #endif // !__WXPALMOS__
     }
 #endif // !__WXPALMOS__
+    return name;
+}
 
 
-    return true;
+wxString wxAppConsoleBase::GetAppDisplayName() const
+{
+    // use the explicitly provided display name, if any
+    if ( !m_appDisplayName.empty() )
+        return m_appDisplayName;
+
+    // if the application name was explicitly set, use it as is as capitalizing
+    // it won't always produce good results
+    if ( !m_appName.empty() )
+        return m_appName;
+
+    // if neither is set, use the capitalized version of the program file as
+    // it's the most reasonable default
+    return GetAppName().Capitalize();
 }
 
 }
 
-wxEventLoop *wxAppConsole::CreateMainLoop()
+wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
 {
     return GetTraits()->CreateEventLoop();
 }
 
 {
     return GetTraits()->CreateEventLoop();
 }
 
-void wxAppConsole::CleanUp()
+void wxAppConsoleBase::CleanUp()
 {
 {
-    delete m_mainLoop;
-    m_mainLoop = NULL;
-
-    delete wxPendingEvents;
-    wxPendingEvents = NULL;
-
-#if wxUSE_THREADS
-    delete wxPendingEventsLocker;
-    wxPendingEventsLocker = NULL;
-#endif // wxUSE_THREADS
+    if ( m_mainLoop )
+    {
+        delete m_mainLoop;
+        m_mainLoop = NULL;
+    }
 }
 
 // ----------------------------------------------------------------------------
 // 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);
@@ -238,23 +254,23 @@ bool wxAppConsole::OnInit()
     return true;
 }
 
     return true;
 }
 
-int wxAppConsole::OnRun()
+int wxAppConsoleBase::OnRun()
 {
     return MainLoop();
 }
 
 {
     return MainLoop();
 }
 
-int wxAppConsole::OnExit()
+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()
 {
     if (m_mainLoop != NULL)
         ExitMainLoop();
 {
     if (m_mainLoop != NULL)
         ExitMainLoop();
@@ -266,36 +282,43 @@ void wxAppConsole::Exit()
 // 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 )
     {
         m_traits = CreateTraits();
 
 {
     // FIXME-MT: protect this with a CS?
     if ( !m_traits )
     {
         m_traits = CreateTraits();
 
-        wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") );
+        wxASSERT_MSG( m_traits, wxT("wxApp::CreateTraits() failed?") );
     }
 
     return m_traits;
 }
 
     }
 
     return m_traits;
 }
 
+/* static */
+wxAppTraits *wxAppConsoleBase::GetTraitsIfExists()
+{
+    wxAppConsole * const app = GetInstance();
+    return app ? app->GetTraits() : NULL;
+}
+
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// event processing
+// wxEventLoop redirection
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-int wxAppConsole::MainLoop()
+int wxAppConsoleBase::MainLoop()
 {
 {
-    wxEventLoopTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
+    wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
 
     return m_mainLoop ? m_mainLoop->Run() : -1;
 }
 
 
     return m_mainLoop ? m_mainLoop->Run() : -1;
 }
 
-void wxAppConsole::ExitMainLoop()
+void wxAppConsoleBase::ExitMainLoop()
 {
     // we should exit from the main event loop, not just any currently active
     // (e.g. modal dialog) event loop
 {
     // we should exit from the main event loop, not just any currently active
     // (e.g. modal dialog) event loop
@@ -305,90 +328,253 @@ void wxAppConsole::ExitMainLoop()
     }
 }
 
     }
 }
 
-bool wxAppConsole::Pending()
+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
 {
     // 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
-    wxEventLoop * const loop = wxEventLoopBase::GetActive();
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 
     return loop && loop->Pending();
 }
 
 
     return loop && loop->Pending();
 }
 
-bool wxAppConsole::Dispatch()
+bool wxAppConsoleBase::Dispatch()
 {
     // see comment in Pending()
 {
     // see comment in Pending()
-    wxEventLoop * const loop = wxEventLoopBase::GetActive();
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 
     return loop && loop->Dispatch();
 }
 
 
     return loop && loop->Dispatch();
 }
 
-bool wxAppConsole::HasPendingEvents() const
+bool wxAppConsoleBase::Yield(bool onlyIfNeeded)
+{
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    return loop && loop->Yield(onlyIfNeeded);
+}
+
+void wxAppConsoleBase::WakeUpIdle()
+{
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    if ( loop )
+        loop->WakeUp();
+}
+
+bool wxAppConsoleBase::ProcessIdle()
+{
+    // synthesize an idle event and check if more of them are needed
+    wxIdleEvent event;
+    event.SetEventObject(this);
+    ProcessEvent(event);
+
+#if wxUSE_LOG
+    // flush the logged messages if any (do this after processing the events
+    // which could have logged new messages)
+    wxLog::FlushActive();
+#endif
+
+    return event.MoreRequested();
+}
+
+bool wxAppConsoleBase::UsesEventLoop() const
+{
+    // in console applications we don't know whether we're going to have an
+    // event loop so assume we won't -- unless we already have one running
+    return wxEventLoopBase::GetActive() != NULL;
+}
+
+// ----------------------------------------------------------------------------
+// events
+// ----------------------------------------------------------------------------
+
+/* static */
+bool wxAppConsoleBase::IsMainLoopRunning()
 {
 {
-    // ensure that we're the only thread to modify the pending events list
-    wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+    const wxAppConsole * const app = GetInstance();
 
 
-    if ( !wxPendingEvents )
+    return app && app->m_mainLoop != NULL;
+}
+
+int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))
+{
+    // process the events normally by default
+    return -1;
+}
+
+void wxAppConsoleBase::DelayPendingEventHandler(wxEvtHandler* toDelay)
+{
+    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+
+    // move the handler from the list of handlers with processable pending events
+    // to the list of handlers with pending events which needs to be processed later
+    m_handlersWithPendingEvents.Remove(toDelay);
+
+    if (m_handlersWithPendingDelayedEvents.Index(toDelay) == wxNOT_FOUND)
+        m_handlersWithPendingDelayedEvents.Add(toDelay);
+
+    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+}
+
+void wxAppConsoleBase::RemovePendingEventHandler(wxEvtHandler* toRemove)
+{
+    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+
+    if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND)
     {
     {
-        wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
-        return false;
+        m_handlersWithPendingEvents.Remove(toRemove);
+
+        // check that the handler was present only once in the list
+        wxASSERT_MSG( m_handlersWithPendingEvents.Index(toRemove) == wxNOT_FOUND,
+                        "Handler occurs twice in the m_handlersWithPendingEvents list!" );
     }
     }
-    wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
-    return true;
+    //else: it wasn't in this list at all, it's ok
+
+    if (m_handlersWithPendingDelayedEvents.Index(toRemove) != wxNOT_FOUND)
+    {
+        m_handlersWithPendingDelayedEvents.Remove(toRemove);
+
+        // check that the handler was present only once in the list
+        wxASSERT_MSG( m_handlersWithPendingDelayedEvents.Index(toRemove) == wxNOT_FOUND,
+                        "Handler occurs twice in m_handlersWithPendingDelayedEvents list!" );
+    }
+    //else: it wasn't in this list at all, it's ok
+
+    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 }
 
 }
 
-void wxAppConsole::ProcessPendingEvents()
+void wxAppConsoleBase::AppendPendingEventHandler(wxEvtHandler* toAppend)
 {
 {
-#if wxUSE_THREADS
-    if ( !wxPendingEventsLocker )
-        return;
-#endif
+    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 
 
-    if ( !HasPendingEvents() )
-        return;
+    if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND )
+        m_handlersWithPendingEvents.Add(toAppend);
 
 
-    wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
+}
 
 
-    // iterate until the list becomes empty
-    wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
-    while (node)
+bool wxAppConsoleBase::HasPendingEvents() const
+{
+    wxENTER_CRIT_SECT(const_cast<wxAppConsoleBase*>(this)->m_handlersWithPendingEventsLocker);
+
+    bool has = !m_handlersWithPendingEvents.IsEmpty();
+
+    wxLEAVE_CRIT_SECT(const_cast<wxAppConsoleBase*>(this)->m_handlersWithPendingEventsLocker);
+
+    return has;
+}
+
+void wxAppConsoleBase::SuspendProcessingOfPendingEvents()
+{
+    m_bDoPendingEventProcessing = false;
+}
+
+void wxAppConsoleBase::ResumeProcessingOfPendingEvents()
+{
+    m_bDoPendingEventProcessing = true;
+}
+
+void wxAppConsoleBase::ProcessPendingEvents()
+{
+    if ( m_bDoPendingEventProcessing )
     {
     {
-        wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
-        wxPendingEvents->Erase(node);
+        wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 
 
-        // In ProcessPendingEvents(), new handlers might be add
-        // and we can safely leave the critical section here.
-        wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+        wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
+                     "this helper list should be empty" );
 
 
-        handler->ProcessPendingEvents();
+        // iterate until the list becomes empty: the handlers remove themselves
+        // from it when they don't have any more pending events
+        while (!m_handlersWithPendingEvents.IsEmpty())
+        {
+            // In ProcessPendingEvents(), new handlers might be added
+            // and we can safely leave the critical section here.
+            wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 
 
-        wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+            // NOTE: we always call ProcessPendingEvents() on the first event handler
+            //       with pending events because handlers auto-remove themselves
+            //       from this list (see RemovePendingEventHandler) if they have no
+            //       more pending events.
+            m_handlersWithPendingEvents[0]->ProcessPendingEvents();
 
 
-        node = wxPendingEvents->GetFirst();
+            wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+        }
+
+        // now the wxHandlersWithPendingEvents is surely empty; however some event
+        // handlers may have moved themselves into wxHandlersWithPendingDelayedEvents
+        // because of a selective wxYield call in progress.
+        // Now we need to move them back to wxHandlersWithPendingEvents so the next
+        // call to this function has the chance of processing them:
+        if (!m_handlersWithPendingDelayedEvents.IsEmpty())
+        {
+            WX_APPEND_ARRAY(m_handlersWithPendingEvents, m_handlersWithPendingDelayedEvents);
+            m_handlersWithPendingDelayedEvents.Clear();
+        }
+
+        wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
     }
 
     }
 
-    wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+    // Garbage collect all objects previously scheduled for destruction.
+    DeletePendingObjects();
 }
 
 }
 
-void wxAppConsole::WakeUpIdle()
+void wxAppConsoleBase::DeletePendingEvents()
 {
 {
-    if ( m_mainLoop )
-        m_mainLoop->WakeUp();
+    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+
+    wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
+                 "this helper list should be empty" );
+
+    for (unsigned int i=0; i<m_handlersWithPendingEvents.GetCount(); i++)
+        m_handlersWithPendingEvents[i]->DeletePendingEvents();
+
+    m_handlersWithPendingEvents.Clear();
+
+    wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 }
 
 }
 
-bool wxAppConsole::ProcessIdle()
+// ----------------------------------------------------------------------------
+// delayed objects destruction
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const
 {
 {
-    wxIdleEvent event;
+    return wxPendingDelete.Member(object);
+}
 
 
-    event.SetEventObject(this);
-    ProcessEvent(event);
-    return event.MoreRequested();
+void wxAppConsoleBase::ScheduleForDestruction(wxObject *object)
+{
+    if ( !UsesEventLoop() )
+    {
+        // we won't be able to delete it later so do it right now
+        delete object;
+        return;
+    }
+    //else: we either already have or will soon start an event loop
+
+    if ( !wxPendingDelete.Member(object) )
+        wxPendingDelete.Append(object);
 }
 
 }
 
-int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
+void wxAppConsoleBase::DeletePendingObjects()
 {
 {
-    // process the events normally by default
-    return -1;
+    wxList::compatibility_iterator node = wxPendingDelete.GetFirst();
+    while (node)
+    {
+        wxObject *obj = node->GetData();
+
+        // remove it from the list first so that if we get back here somehow
+        // during the object deletion (e.g. wxYield called from its dtor) we
+        // wouldn't try to delete it the second time
+        if ( wxPendingDelete.Member(obj) )
+            wxPendingDelete.Erase(node);
+
+        delete obj;
+
+        // Deleting one object may have deleted other pending
+        // objects, so start from beginning of list again.
+        node = wxPendingDelete.GetFirst();
+    }
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -398,21 +584,61 @@ 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.GetEvtMethod();
+
+    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
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // exceptions support
 // ----------------------------------------------------------------------------
 
-#if wxUSE_EXCEPTIONS
-
-bool wxAppConsole::OnExceptionInMainLoop()
+bool wxAppConsoleBase::OnExceptionInMainLoop()
 {
     throw;
 
 {
     throw;
 
@@ -422,9 +648,6 @@ bool wxAppConsole::OnExceptionInMainLoop()
 #endif
 }
 
 #endif
 }
 
-#endif // wxUSE_EXCEPTIONS
-
-
 #endif // wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_EXCEPTIONS
 
 // ----------------------------------------------------------------------------
@@ -433,17 +656,17 @@ bool wxAppConsole::OnExceptionInMainLoop()
 
 #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
@@ -452,7 +675,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,
@@ -461,20 +684,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) )
@@ -488,14 +704,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();
 
@@ -509,8 +725,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",
@@ -524,7 +740,7 @@ bool wxAppConsole::CheckBuildOptions(const char *optionsSignature,
         wxString progName = wxString::FromAscii(componentName);
         wxString msg;
 
         wxString progName = wxString::FromAscii(componentName);
         wxString msg;
 
-        msg.Printf(_T("Mismatch between the program and library build versions detected.\nThe library used %s,\nand %s used %s."),
+        msg.Printf(wxT("Mismatch between the program and library build versions detected.\nThe library used %s,\nand %s used %s."),
                    lib.c_str(), progName.c_str(), prog.c_str());
 
         wxLogFatalError(msg.c_str());
                    lib.c_str(), progName.c_str(), prog.c_str());
 
         wxLogFatalError(msg.c_str());
@@ -532,32 +748,38 @@ bool wxAppConsole::CheckBuildOptions(const char *optionsSignature,
         // normally wxLogFatalError doesn't return
         return false;
     }
         // normally wxLogFatalError doesn't return
         return false;
     }
-#undef wxCMP
 
     return true;
 }
 
 
     return true;
 }
 
-#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)
 {
 {
+#if wxDEBUG_LEVEL
     ShowAssertDialog(file, line, func, cond, msg, GetTraits());
     ShowAssertDialog(file, line, func, cond, msg, GetTraits());
+#else
+    // this function is still present even in debug level 0 build for ABI
+    // compatibility reasons but is never called there and so can simply do
+    // nothing in it
+    wxUnusedVar(file);
+    wxUnusedVar(line);
+    wxUnusedVar(func);
+    wxUnusedVar(cond);
+    wxUnusedVar(msg);
+#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 }
 
 }
 
-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);
 }
 
-#endif // __WXDEBUG__
-
 // ============================================================================
 // other classes implementations
 // ============================================================================
 // ============================================================================
 // other classes implementations
 // ============================================================================
@@ -595,12 +817,10 @@ wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
     return NULL;
 }
 
     return NULL;
 }
 
-#ifdef __WXDEBUG__
 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
 {
     return wxAppTraitsBase::ShowAssertDialog(msg);
 }
 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
 {
     return wxAppTraitsBase::ShowAssertDialog(msg);
 }
-#endif
 
 bool wxConsoleAppTraitsBase::HasStderr()
 {
 
 bool wxConsoleAppTraitsBase::HasStderr()
 {
@@ -608,39 +828,50 @@ bool wxConsoleAppTraitsBase::HasStderr()
     return true;
 }
 
     return true;
 }
 
-void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object)
+// ----------------------------------------------------------------------------
+// wxAppTraits
+// ----------------------------------------------------------------------------
+
+#if wxUSE_INTL
+void wxAppTraitsBase::SetLocale()
 {
 {
-    delete object;
+    wxSetlocale(LC_ALL, "");
+    wxUpdateLocaleIsUtf8();
 }
 }
+#endif
 
 
-void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object))
+#if wxUSE_THREADS
+void wxMutexGuiEnterImpl();
+void wxMutexGuiLeaveImpl();
+
+void wxAppTraitsBase::MutexGuiEnter()
 {
 {
-    // nothing to do
+    wxMutexGuiEnterImpl();
 }
 
 }
 
-#if wxUSE_SOCKETS
-GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
+void wxAppTraitsBase::MutexGuiLeave()
 {
 {
-    return NULL;
+    wxMutexGuiLeaveImpl();
 }
 }
-#endif
 
 
-// ----------------------------------------------------------------------------
-// wxAppTraits
-// ----------------------------------------------------------------------------
-
-#if wxUSE_INTL
-void wxAppTraitsBase::SetLocale()
+void WXDLLIMPEXP_BASE wxMutexGuiEnter()
 {
 {
-    setlocale(LC_ALL, "");
-    wxUpdateLocaleIsUtf8();
+    wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+    if ( traits )
+        traits->MutexGuiEnter();
 }
 }
-#endif
 
 
-#ifdef __WXDEBUG__
+void WXDLLIMPEXP_BASE wxMutexGuiLeave()
+{
+    wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+    if ( traits )
+        traits->MutexGuiLeave();
+}
+#endif // wxUSE_THREADS
 
 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 {
 
 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 {
+#if wxDEBUG_LEVEL
     wxString msg = msgOriginal;
 
 #if wxUSE_STACKWALKER
     wxString msg = msgOriginal;
 
 #if wxUSE_STACKWALKER
@@ -653,15 +884,21 @@ bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 
     const wxString stackTrace = GetAssertStackTrace();
     if ( !stackTrace.empty() )
 
     const wxString stackTrace = GetAssertStackTrace();
     if ( !stackTrace.empty() )
-        msg << _T("\n\nCall stack:\n") << stackTrace;
+        msg << wxT("\n\nCall stack:\n") << stackTrace;
 #endif // wxUSE_STACKWALKER
 
     return DoShowAssertDialog(msg);
 #endif // wxUSE_STACKWALKER
 
     return DoShowAssertDialog(msg);
+#else // !wxDEBUG_LEVEL
+    wxUnusedVar(msgOriginal);
+
+    return false;
+#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 }
 
 #if wxUSE_STACKWALKER
 wxString wxAppTraitsBase::GetAssertStackTrace()
 {
 }
 
 #if wxUSE_STACKWALKER
 wxString wxAppTraitsBase::GetAssertStackTrace()
 {
+#if wxDEBUG_LEVEL
     wxString stackTrace;
 
     class StackDump : public wxStackWalker
     wxString stackTrace;
 
     class StackDump : public wxStackWalker
@@ -676,29 +913,29 @@ wxString wxAppTraitsBase::GetAssertStackTrace()
         {
             m_stackTrace << wxString::Format
                             (
         {
             m_stackTrace << wxString::Format
                             (
-                              _T("[%02d] "),
+                              wxT("[%02d] "),
                               wx_truncate_cast(int, frame.GetLevel())
                             );
 
             wxString name = frame.GetName();
             if ( !name.empty() )
             {
                               wx_truncate_cast(int, frame.GetLevel())
                             );
 
             wxString name = frame.GetName();
             if ( !name.empty() )
             {
-                m_stackTrace << wxString::Format(_T("%-40s"), name.c_str());
+                m_stackTrace << wxString::Format(wxT("%-40s"), name.c_str());
             }
             else
             {
             }
             else
             {
-                m_stackTrace << wxString::Format(_T("%p"), frame.GetAddress());
+                m_stackTrace << wxString::Format(wxT("%p"), frame.GetAddress());
             }
 
             if ( frame.HasSourceLocation() )
             {
             }
 
             if ( frame.HasSourceLocation() )
             {
-                m_stackTrace << _T('\t')
+                m_stackTrace << wxT('\t')
                              << frame.GetFileName()
                              << frame.GetFileName()
-                             << _T(':')
+                             << wxT(':')
                              << frame.GetLine();
             }
 
                              << frame.GetLine();
             }
 
-            m_stackTrace << _T('\n');
+            m_stackTrace << wxT('\n');
         }
 
     private:
         }
 
     private:
@@ -719,12 +956,15 @@ wxString wxAppTraitsBase::GetAssertStackTrace()
         stackTrace = stackTrace.BeforeLast(wxT('\n'));
 
     return stackTrace;
         stackTrace = stackTrace.BeforeLast(wxT('\n'));
 
     return stackTrace;
+#else // !wxDEBUG_LEVEL
+    // this function is still present for ABI-compatibility even in debug level
+    // 0 build but is not used there and so can simply do nothing
+    return wxString();
+#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 }
 #endif // wxUSE_STACKWALKER
 
 
 }
 #endif // wxUSE_STACKWALKER
 
 
-#endif // __WXDEBUG__
-
 // ============================================================================
 // global functions implementation
 // ============================================================================
 // ============================================================================
 // global functions implementation
 // ============================================================================
@@ -751,25 +991,19 @@ void wxWakeUpIdle()
     //else: do nothing, what can we do?
 }
 
     //else: do nothing, what can we do?
 }
 
-#ifdef  __WXDEBUG__
-
 // wxASSERT() helper
 bool wxAssertIsEqual(int x, int y)
 {
     return x == y;
 }
 
 // wxASSERT() helper
 bool wxAssertIsEqual(int x, int y)
 {
     return x == y;
 }
 
+#if wxDEBUG_LEVEL
+
 // break into the debugger
 void wxTrap()
 {
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
     DebugBreak();
 // break into the debugger
 void wxTrap()
 {
 #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__)
@@ -779,118 +1013,127 @@ void wxTrap()
 #endif // Win/Unix
 }
 
 #endif // Win/Unix
 }
 
-// this function is called when an assert fails
-static void wxDoOnAssert(const wxString& szFile,
-                         int nLine,
-                         const wxString& szFunc,
-                         const wxString& szCond,
-                         const wxString& szMsg = wxEmptyString)
+// default assert handler
+static void
+wxDefaultAssertHandler(const wxString& file,
+                       int line,
+                       const wxString& func,
+                       const wxString& cond,
+                       const wxString& msg)
 {
     // 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;
-
     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, szFunc, szCond, szMsg);
+        ShowAssertDialog(file, line, func, cond, msg);
     }
     else
     {
         // let the app process it as it wants
         // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
     }
     else
     {
         // let the app process it as it wants
         // 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());
+        wxTheApp->OnAssertFailure(file.c_str(), line, func.c_str(),
+                                  cond.c_str(), msg.c_str());
     }
     }
+}
+
+wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler;
 
 
-    s_bInAssert = false;
+void wxSetDefaultAssertHandler()
+{
+    wxTheAssertHandler = wxDefaultAssertHandler;
 }
 
 }
 
-void wxOnAssert(const wxString& szFile,
-                int nLine,
-                const wxString& szFunc,
-                const wxString& szCond,
-                const wxString& szMsg)
+void wxOnAssert(const wxString& file,
+                int line,
+                const wxString& func,
+                const wxString& cond,
+                const wxString& msg)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 }
 
-void wxOnAssert(const wxString& szFile,
-                int nLine,
-                const wxString& szFunc,
-                const wxString& szCond)
+void wxOnAssert(const wxString& file,
+                int line,
+                const wxString& func,
+                const wxString& cond)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond);
+    wxTheAssertHandler(file, line, func, cond, wxString());
 }
 
 }
 
-void wxOnAssert(const wxChar *szFile,
-                int nLine,
-                const char *szFunc,
-                const wxChar *szCond,
-                const wxChar *szMsg)
+void wxOnAssert(const wxChar *file,
+                int line,
+                const char *func,
+                const wxChar *cond,
+                const wxChar *msg)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+    // this is the backwards-compatible version (unless we don't use Unicode)
+    // so it could be called directly from the user code and this might happen
+    // even when wxTheAssertHandler is NULL
+#if wxUSE_UNICODE
+    if ( wxTheAssertHandler )
+#endif // wxUSE_UNICODE
+        wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 }
 
-void wxOnAssert(const char *szFile,
-                int nLine,
-                const char *szFunc,
-                const char *szCond,
-                const wxString& szMsg)
+void wxOnAssert(const char *file,
+                int line,
+                const char *func,
+                const char *cond,
+                const wxString& msg)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 }
 
-void wxOnAssert(const char *szFile,
-                int nLine,
-                const char *szFunc,
-                const char *szCond,
+void wxOnAssert(const char *file,
+                int line,
+                const char *func,
+                const char *cond,
                 const wxCStrData& msg)
 {
                 const wxCStrData& msg)
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, msg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 #if wxUSE_UNICODE
 }
 
 #if wxUSE_UNICODE
-void wxOnAssert(const char *szFile,
-                int nLine,
-                const char *szFunc,
-                const char *szCond)
+void wxOnAssert(const char *file,
+                int line,
+                const char *func,
+                const char *cond)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond);
+    wxTheAssertHandler(file, line, func, cond, wxString());
 }
 
 }
 
-void wxOnAssert(const char *szFile,
-                int nLine,
-                const char *szFunc,
-                const char *szCond,
-                const char *szMsg)
+void wxOnAssert(const char *file,
+                int line,
+                const char *func,
+                const char *cond,
+                const char *msg)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 }
 
-void wxOnAssert(const char *szFile,
-                int nLine,
-                const char *szFunc,
-                const char *szCond,
-                const wxChar *szMsg)
+void wxOnAssert(const char *file,
+                int line,
+                const char *func,
+                const char *cond,
+                const wxChar *msg)
 {
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 #endif // wxUSE_UNICODE
 
 }
 #endif // wxUSE_UNICODE
 
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
 
 // ============================================================================
 // private functions implementation
 
 // ============================================================================
 // private functions implementation
@@ -911,19 +1154,25 @@ static void LINKAGEMODE SetTraceMasks()
 #endif // wxUSE_LOG
 }
 
 #endif // wxUSE_LOG
 }
 
+#endif // __WXDEBUG__
+
+#if wxDEBUG_LEVEL
+
+static
 bool DoShowAssertDialog(const wxString& msg)
 {
     // under MSW we can show the dialog even in the console mode
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
     wxString msgDlg(msg);
 
 bool DoShowAssertDialog(const wxString& msg)
 {
     // under MSW we can show the dialog even in the console mode
 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
     wxString msgDlg(msg);
 
-    // this message is intentionally not translated -- it is for
-    // developpers only
+    // this message is intentionally not translated -- it is for developers
+    // only -- and the less code we use here, less is the danger of recursively
+    // asserting and dying
     msgDlg += wxT("\nDo you want to stop the program?\n")
               wxT("You can also choose [Cancel] to suppress ")
               wxT("further warnings.");
 
     msgDlg += wxT("\nDo you want to stop the program?\n")
               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(), wxT("wxWidgets Debug Alert"),
                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:
                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:
@@ -948,13 +1197,13 @@ bool DoShowAssertDialog(const wxString& msg)
     return false;
 }
 
     return false;
 }
 
-// show the assert modal dialog
+// show the standard assert dialog
 static
 static
-void ShowAssertDialog(const wxString& szFile,
-                      int nLine,
-                      const wxString& szFunc,
-                      const wxString& szCond,
-                      const wxString& szMsg,
+void ShowAssertDialog(const wxString& file,
+                      int line,
+                      const wxString& func,
+                      const wxString& cond,
+                      const wxString& msgUser,
                       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
@@ -966,20 +1215,20 @@ void ShowAssertDialog(const wxString& szFile,
     // make life easier for people using VC++ IDE by using this format: like
     // this, clicking on the message will take us immediately to the place of
     // the failed assert
     // make life easier for people using VC++ IDE by using this format: like
     // this, clicking on the message will take us immediately to the place of
     // the failed assert
-    msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
+    msg.Printf(wxT("%s(%d): assert \"%s\" failed"), file, line, cond);
 
     // add the function name, if any
 
     // add the function name, if any
-    if ( !szFunc.empty() )
-        msg << _T(" in ") << szFunc << _T("()");
+    if ( !func.empty() )
+        msg << wxT(" in ") << func << wxT("()");
 
     // and the message itself
 
     // and the message itself
-    if ( !szMsg.empty() )
+    if ( !msgUser.empty() )
     {
     {
-        msg << _T(": ") << szMsg;
+        msg << wxT(": ") << msgUser;
     }
     else // no message given
     {
     }
     else // no message given
     {
-        msg << _T('.');
+        msg << wxT('.');
     }
 
 #if wxUSE_THREADS
     }
 
 #if wxUSE_THREADS
@@ -991,7 +1240,7 @@ void ShowAssertDialog(const wxString& 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());
@@ -1006,7 +1255,7 @@ void ShowAssertDialog(const wxString& szFile,
     if ( !s_bNoAsserts )
     {
         // send it to the normal log destination
     if ( !s_bNoAsserts )
     {
         // send it to the normal log destination
-        wxLogDebug(_T("%s"), msg.c_str());
+        wxLogDebug(wxT("%s"), msg.c_str());
 
         if ( traits )
         {
 
         if ( traits )
         {
@@ -1021,4 +1270,4 @@ void ShowAssertDialog(const wxString& szFile,
     }
 }
 
     }
 }
 
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
wxWidgets (Impactor)