X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cae9e7b169b5507dc6dced7fc0e0c3b3d9575f3a..01b5ad3b500627ae3ebadc755f47c816a859e6bb:/src/common/appbase.cpp

diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp
index 111ff3c7af..db26530d66 100644
--- a/src/common/appbase.cpp
+++ b/src/common/appbase.cpp
@@ -63,7 +63,7 @@
     #include "wx/fontmap.h"
 #endif // wxUSE_FONTMAP
 
-#ifdef __WXDEBUG__
+#if wxDEBUG_LEVEL
     #if wxUSE_STACKWALKER
         #include "wx/stackwalk.h"
         #ifdef __WXMSW__
@@ -72,7 +72,7 @@
     #endif // wxUSE_STACKWALKER
 
     #include "wx/recguard.h"
-#endif // __WXDEBUG__
+#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
@@ -85,20 +85,22 @@
 // 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
-    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);
+#endif // wxDEBUG_LEVEL
 
+#ifdef __WXDEBUG__
     // turn on the trace masks specified in the env variable WXTRACE
     static void LINKAGEMODE SetTraceMasks();
 #endif // __WXDEBUG__
@@ -113,6 +115,8 @@ wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
 
 wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
 
+WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
+
 // ----------------------------------------------------------------------------
 // wxEventLoopPtr
 // ----------------------------------------------------------------------------
@@ -262,7 +266,7 @@ wxAppTraits *wxAppConsoleBase::GetTraits()
     {
         m_traits = CreateTraits();
 
-        wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") );
+        wxASSERT_MSG( m_traits, wxT("wxApp::CreateTraits() failed?") );
     }
 
     return m_traits;
@@ -323,15 +327,27 @@ bool wxAppConsoleBase::Yield(bool onlyIfNeeded)
 
 void wxAppConsoleBase::WakeUpIdle()
 {
-    if ( m_mainLoop )
-        m_mainLoop->WakeUp();
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    if ( loop )
+        loop->WakeUp();
 }
 
 bool wxAppConsoleBase::ProcessIdle()
 {
-    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+    // synthesize an idle event and check if more of them are needed
+    wxIdleEvent event;
+    event.SetEventObject(this);
+    ProcessEvent(event);
+
+    return event.MoreRequested();
+}
 
-    return loop && loop->ProcessIdle();
+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;
 }
 
 // ----------------------------------------------------------------------------
@@ -426,43 +442,46 @@ void wxAppConsoleBase::ResumeProcessingOfPendingEvents()
 
 void wxAppConsoleBase::ProcessPendingEvents()
 {
-    if (!m_bDoPendingEventProcessing)
-        return;
+    if ( m_bDoPendingEventProcessing )
+    {
+        wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 
-    wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+        wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
+                     "this helper list should be empty" );
 
-    wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
-                 "this helper list should be empty" );
+        // 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);
 
-    // 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);
+            // 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();
 
-        // 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();
+            wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+        }
 
-        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();
+        }
 
-    // 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(m_handlersWithPendingEventsLocker);
+    // Garbage collect all objects previously scheduled for destruction.
+    DeletePendingObjects();
 }
 
 void wxAppConsoleBase::DeletePendingEvents()
@@ -480,6 +499,50 @@ void wxAppConsoleBase::DeletePendingEvents()
     wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 }
 
+// ----------------------------------------------------------------------------
+// delayed objects destruction
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const
+{
+    return wxPendingDelete.Member(object) != NULL;
+}
+
+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);
+}
+
+void wxAppConsoleBase::DeletePendingObjects()
+{
+    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();
+    }
+}
+
 // ----------------------------------------------------------------------------
 // exception handling
 // ----------------------------------------------------------------------------
@@ -501,7 +564,7 @@ void wxAppConsoleBase::CallEventHandler(wxEvtHandler *handler,
 {
     // If the functor holds a method then, for backward compatibility, call
     // HandleEvent():
-    wxEventFunction eventFunction = functor.GetMethod();
+    wxEventFunction eventFunction = functor.GetEvtMethod();
 
     if ( eventFunction )
         HandleEvent(handler, eventFunction, event);
@@ -643,7 +706,7 @@ bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
         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());
@@ -655,15 +718,24 @@ bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
     return true;
 }
 
-#ifdef __WXDEBUG__
-
 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());
+#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 wxAppConsoleBase::OnAssert(const wxChar *file,
@@ -674,8 +746,6 @@ void wxAppConsoleBase::OnAssert(const wxChar *file,
     OnAssertFailure(file, line, NULL, cond, msg);
 }
 
-#endif // __WXDEBUG__
-
 // ============================================================================
 // other classes implementations
 // ============================================================================
@@ -713,12 +783,10 @@ wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
     return NULL;
 }
 
-#ifdef __WXDEBUG__
 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
 {
     return wxAppTraitsBase::ShowAssertDialog(msg);
 }
-#endif
 
 bool wxConsoleAppTraitsBase::HasStderr()
 {
@@ -726,16 +794,6 @@ bool wxConsoleAppTraitsBase::HasStderr()
     return true;
 }
 
-void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object)
-{
-    delete object;
-}
-
-void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object))
-{
-    // nothing to do
-}
-
 // ----------------------------------------------------------------------------
 // wxAppTraits
 // ----------------------------------------------------------------------------
@@ -777,10 +835,9 @@ void WXDLLIMPEXP_BASE wxMutexGuiLeave()
 }
 #endif // wxUSE_THREADS
 
-#ifdef __WXDEBUG__
-
 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 {
+#if wxDEBUG_LEVEL
     wxString msg = msgOriginal;
 
 #if wxUSE_STACKWALKER
@@ -793,15 +850,21 @@ bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 
     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);
+#else // !wxDEBUG_LEVEL
+    wxUnusedVar(msgOriginal);
+
+    return false;
+#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 }
 
 #if wxUSE_STACKWALKER
 wxString wxAppTraitsBase::GetAssertStackTrace()
 {
+#if wxDEBUG_LEVEL
     wxString stackTrace;
 
     class StackDump : public wxStackWalker
@@ -816,29 +879,29 @@ wxString wxAppTraitsBase::GetAssertStackTrace()
         {
             m_stackTrace << wxString::Format
                             (
-                              _T("[%02d] "),
+                              wxT("[%02d] "),
                               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
             {
-                m_stackTrace << wxString::Format(_T("%p"), frame.GetAddress());
+                m_stackTrace << wxString::Format(wxT("%p"), frame.GetAddress());
             }
 
             if ( frame.HasSourceLocation() )
             {
-                m_stackTrace << _T('\t')
+                m_stackTrace << wxT('\t')
                              << frame.GetFileName()
-                             << _T(':')
+                             << wxT(':')
                              << frame.GetLine();
             }
 
-            m_stackTrace << _T('\n');
+            m_stackTrace << wxT('\n');
         }
 
     private:
@@ -859,12 +922,15 @@ wxString wxAppTraitsBase::GetAssertStackTrace()
         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 // __WXDEBUG__
-
 // ============================================================================
 // global functions implementation
 // ============================================================================
@@ -891,14 +957,14 @@ void wxWakeUpIdle()
     //else: do nothing, what can we do?
 }
 
-#ifdef  __WXDEBUG__
-
 // wxASSERT() helper
 bool wxAssertIsEqual(int x, int y)
 {
     return x == y;
 }
 
+#if wxDEBUG_LEVEL
+
 // break into the debugger
 void wxTrap()
 {
@@ -913,12 +979,13 @@ void wxTrap()
 #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
     static int s_bInAssert = 0;
@@ -936,90 +1003,98 @@ static void wxDoOnAssert(const wxString& szFile,
     {
         // 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
-        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());
     }
 }
 
-void wxOnAssert(const wxString& szFile,
-                int nLine,
-                const wxString& szFunc,
-                const wxString& szCond,
-                const wxString& szMsg)
+wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler;
+
+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)
 {
-    wxDoOnAssert(szFile, nLine, szFunc, szCond, msg);
+    wxTheAssertHandler(file, line, func, cond, msg);
 }
 
 #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 // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
 
 // ============================================================================
 // private functions implementation
@@ -1040,6 +1115,10 @@ static void LINKAGEMODE SetTraceMasks()
 #endif // wxUSE_LOG
 }
 
+#endif // __WXDEBUG__
+
+#if wxDEBUG_LEVEL
+
 static
 bool DoShowAssertDialog(const wxString& msg)
 {
@@ -1047,13 +1126,14 @@ bool DoShowAssertDialog(const wxString& msg)
 #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.");
 
-    switch ( ::MessageBox(NULL, msgDlg.wx_str(), _T("wxWidgets Debug Alert"),
+    switch ( ::MessageBox(NULL, msgDlg.wx_str(), wxT("wxWidgets Debug Alert"),
                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:
@@ -1078,13 +1158,13 @@ bool DoShowAssertDialog(const wxString& msg)
     return false;
 }
 
-// show the assert modal dialog
+// show the standard assert dialog
 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
@@ -1096,20 +1176,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
-    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
-    if ( !szFunc.empty() )
-        msg << _T(" in ") << szFunc << _T("()");
+    if ( !func.empty() )
+        msg << wxT(" in ") << func << wxT("()");
 
     // and the message itself
-    if ( !szMsg.empty() )
+    if ( !msgUser.empty() )
     {
-        msg << _T(": ") << szMsg;
+        msg << wxT(": ") << msgUser;
     }
     else // no message given
     {
-        msg << _T('.');
+        msg << wxT('.');
     }
 
 #if wxUSE_THREADS
@@ -1136,7 +1216,7 @@ void ShowAssertDialog(const wxString& szFile,
     if ( !s_bNoAsserts )
     {
         // send it to the normal log destination
-        wxLogDebug(_T("%s"), msg.c_str());
+        wxLogDebug(wxT("%s"), msg.c_str());
 
         if ( traits )
         {
@@ -1151,4 +1231,4 @@ void ShowAssertDialog(const wxString& szFile,
     }
 }
 
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL