X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/14eb37a05eb3741f4c8d9e64b7af45480706cb15..cc4d5638c66a409e421420ed7110917755a66788:/src/common/appbase.cpp diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp index b2a0fd718f..da6f2948ef 100644 --- a/src/common/appbase.cpp +++ b/src/common/appbase.cpp @@ -4,9 +4,8 @@ // Author: Vadim Zeitlin // Modified by: // Created: 19.06.2003 (extracted from common/appcmn.cpp) -// RCS-ID: $Id$ // Copyright: (c) 2003 Vadim Zeitlin -// License: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -25,7 +24,7 @@ #endif #ifndef WX_PRECOMP - #ifdef __WXMSW__ + #ifdef __WINDOWS__ #include "wx/msw/wrapwin.h" // includes windows.h for MessageBox() #endif #include "wx/list.h" @@ -42,37 +41,41 @@ #include "wx/evtloop.h" #include "wx/filename.h" #include "wx/msgout.h" -#include "wx/ptr_scpd.h" +#include "wx/scopedptr.h" +#include "wx/sysopt.h" #include "wx/tokenzr.h" #include "wx/thread.h" -#if wxUSE_EXCEPTIONS && wxUSE_STL - #include - #include -#endif +#if wxUSE_STL + #if wxUSE_EXCEPTIONS + #include + #include + #endif + #if wxUSE_INTL + #include + #endif +#endif // wxUSE_STL -#ifndef __WXPALMOS5__ -#if !defined(__WXMSW__) || defined(__WXMICROWIN__) +#if !defined(__WINDOWS__) || defined(__WXMICROWIN__) #include // for SIGTRAP used by wxTrap() #endif //Win/Unix #include -#endif // ! __WXPALMOS5__ #if wxUSE_FONTMAP #include "wx/fontmap.h" #endif // wxUSE_FONTMAP -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL #if wxUSE_STACKWALKER #include "wx/stackwalk.h" - #ifdef __WXMSW__ + #ifdef __WINDOWS__ #include "wx/msw/debughlp.h" #endif #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 +88,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 +118,8 @@ wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL; wxSocketManager *wxAppTraitsBase::ms_manager = NULL; +WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete; + // ---------------------------------------------------------------------------- // wxEventLoopPtr // ---------------------------------------------------------------------------- @@ -132,6 +139,7 @@ wxAppConsoleBase::wxAppConsoleBase() { m_traits = NULL; m_mainLoop = NULL; + m_bDoPendingEventProcessing = true; ms_appInstance = static_cast(this); @@ -141,40 +149,61 @@ wxAppConsoleBase::wxAppConsoleBase() // In unicode mode the SetTraceMasks call can cause an apptraits to be // created, but since we are still in the constructor the wrong kind will // be created for GUI apps. Destroy it so it can be created again later. - delete m_traits; - m_traits = NULL; + wxDELETE(m_traits); #endif #endif + + wxEvtHandler::AddFilter(this); } wxAppConsoleBase::~wxAppConsoleBase() { + wxEvtHandler::RemoveFilter(this); + + // 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; } // ---------------------------------------------------------------------------- -// initilization/cleanup +// initialization/cleanup // ---------------------------------------------------------------------------- -bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **argv) +bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **WXUNUSED(argv)) { -#if wxUSE_INTL - GetTraits()->SetLocale(); -#endif // wxUSE_INTL - -#if wxUSE_THREADS - wxHandlersWithPendingEventsLocker = new wxCriticalSection; -#endif + return true; +} -#ifndef __WXPALMOS__ - if ( m_appName.empty() && argv && argv[0] ) +wxString wxAppConsoleBase::GetAppName() const +{ + wxString name = m_appName; + 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__ + 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(); } wxEventLoopBase *wxAppConsoleBase::CreateMainLoop() @@ -184,19 +213,7 @@ wxEventLoopBase *wxAppConsoleBase::CreateMainLoop() 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 + wxDELETE(m_mainLoop); } // ---------------------------------------------------------------------------- @@ -238,12 +255,16 @@ int wxAppConsoleBase::OnRun() return MainLoop(); } +void wxAppConsoleBase::OnLaunched() +{ +} + 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) - delete wxConfigBase::Set((wxConfigBase *) NULL); + delete wxConfigBase::Set(NULL); #endif // wxUSE_CONFIG return 0; @@ -273,7 +294,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; @@ -286,14 +307,26 @@ wxAppTraits *wxAppConsoleBase::GetTraitsIfExists() return app ? app->GetTraits() : NULL; } +/* static */ +wxAppTraits& wxAppConsoleBase::GetValidTraits() +{ + static wxConsoleAppTraits s_traitsConsole; + wxAppTraits* const traits = wxTheApp ? wxTheApp->GetTraits() : NULL; + + return traits ? *traits : s_traitsConsole; +} + // ---------------------------------------------------------------------------- -// event processing +// wxEventLoop redirection // ---------------------------------------------------------------------------- int wxAppConsoleBase::MainLoop() { wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop()); + if (wxTheApp) + wxTheApp->OnLaunched(); + return m_mainLoop ? m_mainLoop->Run() : -1; } @@ -325,17 +358,54 @@ bool wxAppConsoleBase::Dispatch() return loop && loop->Dispatch(); } -bool wxAppConsoleBase::HasPendingEvents() const +bool wxAppConsoleBase::Yield(bool onlyIfNeeded) { - wxENTER_CRIT_SECT( *wxHandlersWithPendingEventsLocker ); + wxEventLoopBase * const loop = wxEventLoopBase::GetActive(); + if ( loop ) + return loop->Yield(onlyIfNeeded); - bool has = wxHandlersWithPendingEvents && !wxHandlersWithPendingEvents->IsEmpty(); + wxScopedPtr tmpLoop(CreateMainLoop()); + return tmpLoop->Yield(onlyIfNeeded); +} - wxLEAVE_CRIT_SECT( *wxHandlersWithPendingEventsLocker ); +void wxAppConsoleBase::WakeUpIdle() +{ + wxEventLoopBase * const loop = wxEventLoopBase::GetActive(); - return has; + 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 + + // Garbage collect all objects previously scheduled for destruction. + DeletePendingObjects(); + + 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() { @@ -344,61 +414,182 @@ bool wxAppConsoleBase::IsMainLoopRunning() return app && app->m_mainLoop != NULL; } -void wxAppConsoleBase::ProcessPendingEvents() +int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event)) { -#if wxUSE_THREADS - if ( !wxHandlersWithPendingEventsLocker ) - return; -#endif + // process the events normally by default + return Event_Skip; +} + +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); +} - wxENTER_CRIT_SECT( *wxHandlersWithPendingEventsLocker ); +void wxAppConsoleBase::RemovePendingEventHandler(wxEvtHandler* toRemove) +{ + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); - if (wxHandlersWithPendingEvents) + if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND) { + 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!" ); + } + //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 wxAppConsoleBase::AppendPendingEventHandler(wxEvtHandler* toAppend) +{ + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); + + if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND ) + m_handlersWithPendingEvents.Add(toAppend); + + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); +} + +bool wxAppConsoleBase::HasPendingEvents() const +{ + wxENTER_CRIT_SECT(const_cast(this)->m_handlersWithPendingEventsLocker); + + bool has = !m_handlersWithPendingEvents.IsEmpty(); + + wxLEAVE_CRIT_SECT(const_cast(this)->m_handlersWithPendingEventsLocker); + + return has; +} + +void wxAppConsoleBase::SuspendProcessingOfPendingEvents() +{ + m_bDoPendingEventProcessing = false; +} + +void wxAppConsoleBase::ResumeProcessingOfPendingEvents() +{ + m_bDoPendingEventProcessing = true; +} + +void wxAppConsoleBase::ProcessPendingEvents() +{ + if ( m_bDoPendingEventProcessing ) + { + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); + + 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 - wxList::compatibility_iterator node = wxHandlersWithPendingEvents->GetFirst(); - while (node) + while (!m_handlersWithPendingEvents.IsEmpty()) { - // In ProcessPendingEvents(), new handlers might be add + // In ProcessPendingEvents(), new handlers might be added // and we can safely leave the critical section here. - wxLEAVE_CRIT_SECT( *wxHandlersWithPendingEventsLocker ); + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); - wxEvtHandler *handler = (wxEvtHandler *)node->GetData(); - handler->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( *wxHandlersWithPendingEventsLocker ); + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); + } - // restart as the iterators could have been invalidated - node = wxHandlersWithPendingEvents->GetFirst(); + // 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( *wxHandlersWithPendingEventsLocker ); + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); + } } -void wxAppConsoleBase::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; iDeletePendingEvents(); + + m_handlersWithPendingEvents.Clear(); + + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); } -bool wxAppConsoleBase::ProcessIdle() +// ---------------------------------------------------------------------------- +// delayed objects destruction +// ---------------------------------------------------------------------------- + +bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const { - // process pending wx events before sending idle events - ProcessPendingEvents(); + return wxPendingDelete.Member(object); +} - wxIdleEvent event; +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 - event.SetEventObject(this); - ProcessEvent(event); - return event.MoreRequested(); + if ( !wxPendingDelete.Member(object) ) + wxPendingDelete.Append(object); } -int wxAppConsoleBase::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(); + } } // ---------------------------------------------------------------------------- @@ -416,6 +607,20 @@ wxAppConsoleBase::HandleEvent(wxEvtHandler *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__ @@ -550,7 +755,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()); @@ -558,20 +763,28 @@ bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature, // normally wxLogFatalError doesn't return return false; } -#undef wxCMP 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, @@ -582,7 +795,17 @@ void wxAppConsoleBase::OnAssert(const wxChar *file, OnAssertFailure(file, line, NULL, cond, msg); } -#endif // __WXDEBUG__ +// ---------------------------------------------------------------------------- +// Miscellaneous other methods +// ---------------------------------------------------------------------------- + +void wxAppConsoleBase::SetCLocale() +{ + // We want to use the user locale by default in GUI applications in order + // to show the numbers, dates &c in the familiar format -- and also accept + // this format on input (especially important for decimal comma/dot). + wxSetlocale(LC_ALL, ""); +} // ============================================================================ // other classes implementations @@ -621,12 +844,10 @@ wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer() return NULL; } -#ifdef __WXDEBUG__ bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg) { return wxAppTraitsBase::ShowAssertDialog(msg); } -#endif bool wxConsoleAppTraitsBase::HasStderr() { @@ -634,28 +855,10 @@ bool wxConsoleAppTraitsBase::HasStderr() return true; } -void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object) -{ - delete object; -} - -void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object)) -{ - // nothing to do -} - // ---------------------------------------------------------------------------- // wxAppTraits // ---------------------------------------------------------------------------- -#if wxUSE_INTL -void wxAppTraitsBase::SetLocale() -{ - wxSetlocale(LC_ALL, ""); - wxUpdateLocaleIsUtf8(); -} -#endif - #if wxUSE_THREADS void wxMutexGuiEnterImpl(); void wxMutexGuiLeaveImpl(); @@ -685,31 +888,42 @@ void WXDLLIMPEXP_BASE wxMutexGuiLeave() } #endif // wxUSE_THREADS -#ifdef __WXDEBUG__ - bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal) { - wxString msg = msgOriginal; +#if wxDEBUG_LEVEL + wxString msg; #if wxUSE_STACKWALKER -#if !defined(__WXMSW__) - // on Unix stack frame generation may take some time, depending on the - // size of the executable mainly... warn the user that we are working - wxFprintf(stderr, wxT("[Debug] Generating a stack trace... please wait")); - fflush(stderr); -#endif - const wxString stackTrace = GetAssertStackTrace(); if ( !stackTrace.empty() ) - msg << _T("\n\nCall stack:\n") << stackTrace; + { + msg << wxT("\n\nCall stack:\n") << stackTrace; + + wxMessageOutputDebug().Output(msg); + } #endif // wxUSE_STACKWALKER - return DoShowAssertDialog(msg); + return DoShowAssertDialog(msgOriginal + msg); +#else // !wxDEBUG_LEVEL + wxUnusedVar(msgOriginal); + + return false; +#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL } #if wxUSE_STACKWALKER wxString wxAppTraitsBase::GetAssertStackTrace() { +#if wxDEBUG_LEVEL + +#if !defined(__WINDOWS__) + // on Unix stack frame generation may take some time, depending on the + // size of the executable mainly... warn the user that we are working + wxFprintf(stderr, "Collecting stack trace information, please wait..."); + fflush(stderr); +#endif // !__WINDOWS__ + + wxString stackTrace; class StackDump : public wxStackWalker @@ -724,29 +938,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: @@ -759,7 +973,7 @@ wxString wxAppTraitsBase::GetAssertStackTrace() static const int maxLines = 20; StackDump dump; - dump.Walk(2, maxLines); // don't show OnAssert() call itself + dump.Walk(8, maxLines); // 8 is chosen to hide all OnAssert() calls stackTrace = dump.GetStackTrace(); const int count = stackTrace.Freq(wxT('\n')); @@ -767,12 +981,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 // ============================================================================ @@ -799,18 +1016,29 @@ void wxWakeUpIdle() //else: do nothing, what can we do? } -#ifdef __WXDEBUG__ - // wxASSERT() helper bool wxAssertIsEqual(int x, int y) { return x == y; } +void wxAbort() +{ +#ifdef __WXWINCE__ + ExitThread(3); +#else + abort(); +#endif +} + +#if wxDEBUG_LEVEL + // break into the debugger +#ifndef wxTrap + void wxTrap() { -#if defined(__WXMSW__) && !defined(__WXMICROWIN__) +#if defined(__WINDOWS__) && !defined(__WXMICROWIN__) DebugBreak(); #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS Debugger(); @@ -821,13 +1049,20 @@ 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) +#endif // wxTrap already defined as a macro + +// default assert handler +static void +wxDefaultAssertHandler(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msg) { + // If this option is set, we should abort immediately when assert happens. + if ( wxSystemOptions::GetOptionInt("exit-on-assert") ) + wxAbort(); + // FIXME MT-unsafe static int s_bInAssert = 0; @@ -844,90 +1079,103 @@ 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 wxSetDefaultAssertHandler() +{ + 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 @@ -948,24 +1196,38 @@ static void LINKAGEMODE SetTraceMasks() #endif // wxUSE_LOG } +#endif // __WXDEBUG__ + +#if wxDEBUG_LEVEL + +bool wxTrapInAssert = false; + static bool DoShowAssertDialog(const wxString& msg) { - // under MSW we can show the dialog even in the console mode -#if defined(__WXMSW__) && !defined(__WXMICROWIN__) + // under Windows we can show the dialog even in the console mode +#if defined(__WINDOWS__) && !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.t_str(), wxT("wxWidgets Debug Alert"), MB_YESNOCANCEL | MB_ICONSTOP ) ) { case IDYES: - wxTrap(); + // If we called wxTrap() directly from here, the programmer would + // see this function and a few more calls between his own code and + // it in the stack trace which would be perfectly useless and often + // confusing. So instead just set the flag here and let the macros + // defined in wx/debug.h call wxTrap() themselves, this ensures + // that the debugger will show the line in the user code containing + // the failing assert. + wxTrapInAssert = true; break; case IDCANCEL: @@ -974,25 +1236,21 @@ bool DoShowAssertDialog(const wxString& msg) //case IDNO: nothing to do } -#else // !__WXMSW__ - wxFprintf(stderr, wxT("%s\n"), msg.c_str()); - fflush(stderr); +#else // !__WINDOWS__ + wxUnusedVar(msg); +#endif // __WINDOWS__/!__WINDOWS__ - // TODO: ask the user to enter "Y" or "N" on the console? - wxTrap(); -#endif // __WXMSW__/!__WXMSW__ - - // continue with the asserts + // continue with the asserts by default 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 @@ -1004,20 +1262,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 @@ -1025,27 +1283,15 @@ void ShowAssertDialog(const wxString& szFile, // since dialogs cannot be displayed if ( !wxThread::IsMain() ) { - msg += wxT(" [in child thread]"); - -#if defined(__WXMSW__) && !defined(__WXMICROWIN__) - msg << wxT("\r\n"); - OutputDebugString(msg.wx_str()); -#else - // send to stderr - wxFprintf(stderr, wxT("%s\n"), msg.c_str()); - fflush(stderr); -#endif - // He-e-e-e-elp!! we're asserting in a child thread - wxTrap(); + msg += wxString::Format(" [in thread %lx]", wxThread::GetCurrentId()); } - else #endif // wxUSE_THREADS + // log the assert in any case + wxMessageOutputDebug().Output(msg); + if ( !s_bNoAsserts ) { - // send it to the normal log destination - wxLogDebug(_T("%s"), msg.c_str()); - if ( traits ) { // delegate showing assert dialog (if possible) to that class @@ -1059,4 +1305,4 @@ void ShowAssertDialog(const wxString& szFile, } } -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL