// Created: 19.06.2003 (extracted from common/appcmn.cpp)
// RCS-ID: $Id$
// Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
-// License: wxWindows license
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
#endif
#ifndef WX_PRECOMP
- #ifdef __WXMSW__
+ #ifdef __WINDOWS__
#include "wx/msw/wrapwin.h" // includes windows.h for MessageBox()
#endif
#include "wx/list.h"
#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 <exception>
- #include <typeinfo>
-#endif
+#if wxUSE_STL
+ #if wxUSE_EXCEPTIONS
+ #include <exception>
+ #include <typeinfo>
+ #endif
+ #if wxUSE_INTL
+ #include <locale>
+ #endif
+#endif // wxUSE_STL
-#ifndef __WXPALMOS5__
-#if !defined(__WXMSW__) || defined(__WXMICROWIN__)
+#if !defined(__WINDOWS__) || 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 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__
+ #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
// 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__
wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
+wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
+
+WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
+
// ----------------------------------------------------------------------------
// wxEventLoopPtr
// ----------------------------------------------------------------------------
{
m_traits = NULL;
m_mainLoop = NULL;
+ m_bDoPendingEventProcessing = true;
- ms_appInstance = wx_static_cast(wxAppConsole *, this);
+ ms_appInstance = static_cast<wxAppConsole *>(this);
#ifdef __WXDEBUG__
SetTraceMasks();
// 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
- wxPendingEventsLocker = 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()
void wxAppConsoleBase::CleanUp()
{
- if ( m_mainLoop )
- {
- delete m_mainLoop;
- m_mainLoop = NULL;
- }
-
- delete wxPendingEvents;
- wxPendingEvents = NULL;
-
-#if wxUSE_THREADS
- delete wxPendingEventsLocker;
- wxPendingEventsLocker = NULL;
-#endif // wxUSE_THREADS
+ wxDELETE(m_mainLoop);
}
// ----------------------------------------------------------------------------
#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;
{
m_traits = CreateTraits();
- wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") );
+ wxASSERT_MSG( m_traits, wxT("wxApp::CreateTraits() failed?") );
}
return m_traits;
}
+/* static */
+wxAppTraits *wxAppConsoleBase::GetTraitsIfExists()
+{
+ wxAppConsole * const app = GetInstance();
+ 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()
return loop && loop->Dispatch();
}
-bool wxAppConsoleBase::HasPendingEvents() const
+bool wxAppConsoleBase::Yield(bool onlyIfNeeded)
{
- wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+ if ( loop )
+ return loop->Yield(onlyIfNeeded);
+
+ wxScopedPtr<wxEventLoopBase> tmpLoop(CreateMainLoop());
+ return tmpLoop->Yield(onlyIfNeeded);
+}
- bool has = wxPendingEvents && !wxPendingEvents->IsEmpty();
+void wxAppConsoleBase::WakeUpIdle()
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+ if ( loop )
+ loop->WakeUp();
+}
- return has;
+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()
{
return app && app->m_mainLoop != NULL;
}
-void wxAppConsoleBase::ProcessPendingEvents()
+int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))
{
-#if wxUSE_THREADS
- if ( !wxPendingEventsLocker )
- return;
-#endif
+ // process the events normally by default
+ return Event_Skip;
+}
- wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+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 (wxPendingEvents)
+ 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<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 )
+ {
+ 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 = wxPendingEvents->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( *wxPendingEventsLocker );
+ 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( *wxPendingEventsLocker );
+ wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+ }
- // restart as the iterators could have been invalidated
- node = wxPendingEvents->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(m_handlersWithPendingEventsLocker);
}
+}
+
+void wxAppConsoleBase::DeletePendingEvents()
+{
+ wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
+
+ wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
+ "this helper list should be empty" );
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+ for (unsigned int i=0; i<m_handlersWithPendingEvents.GetCount(); i++)
+ m_handlersWithPendingEvents[i]->DeletePendingEvents();
+
+ m_handlersWithPendingEvents.Clear();
+
+ wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
}
-void wxAppConsoleBase::WakeUpIdle()
+// ----------------------------------------------------------------------------
+// delayed objects destruction
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const
{
- if ( m_mainLoop )
- m_mainLoop->WakeUp();
+ return wxPendingDelete.Member(object);
}
-bool wxAppConsoleBase::ProcessIdle()
+void wxAppConsoleBase::ScheduleForDestruction(wxObject *object)
{
- wxIdleEvent event;
+ 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();
+ }
}
// ----------------------------------------------------------------------------
(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__
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());
// 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,
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
return NULL;
}
-#ifdef __WXDEBUG__
bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
{
return wxAppTraitsBase::ShowAssertDialog(msg);
}
-#endif
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();
void WXDLLIMPEXP_BASE wxMutexGuiEnter()
{
- wxAppConsoleBase::GetInstance()->GetTraits()->MutexGuiEnter();
+ wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+ if ( traits )
+ traits->MutexGuiEnter();
}
void WXDLLIMPEXP_BASE wxMutexGuiLeave()
{
- wxAppConsoleBase::GetInstance()->GetTraits()->MutexGuiLeave();
+ wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+ if ( traits )
+ traits->MutexGuiLeave();
}
#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
{
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:
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'));
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
// ============================================================================
//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();
#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;
{
// 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()
{
- wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+ wxTheAssertHandler = wxDefaultAssertHandler;
}
-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,
+ const wxString& msg)
{
- wxDoOnAssert(szFile, nLine, szFunc, szCond);
+ wxTheAssertHandler(file, line, func, cond, msg);
}
-void wxOnAssert(const wxChar *szFile,
- int nLine,
- const char *szFunc,
- const wxChar *szCond,
- const wxChar *szMsg)
+void wxOnAssert(const wxString& file,
+ int line,
+ const wxString& func,
+ const wxString& cond)
{
- wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+ wxTheAssertHandler(file, line, func, cond, wxString());
}
-void wxOnAssert(const char *szFile,
- int nLine,
- const char *szFunc,
- const char *szCond,
- const wxString& 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,
+void wxOnAssert(const char *file,
+ int line,
+ const char *func,
+ const char *cond,
+ const wxString& msg)
+{
+ wxTheAssertHandler(file, line, func, cond, msg);
+}
+
+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
#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:
//case IDNO: nothing to do
}
-#else // !__WXMSW__
- wxFprintf(stderr, wxT("%s\n"), msg.c_str());
- fflush(stderr);
-
- // TODO: ask the user to enter "Y" or "N" on the console?
- wxTrap();
-#endif // __WXMSW__/!__WXMSW__
+#else // !__WINDOWS__
+ wxUnusedVar(msg);
+#endif // __WINDOWS__/!__WINDOWS__
- // 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
// 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
// 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
}
}
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
projects / wxWidgets.git / blobdiff