///////////////////////////////////////////////////////////////////////////////
-// Name: common/base/appbase.cpp
-// Purpose: implements wxAppConsole class
+// Name: src/common/appbase.cpp
+// Purpose: implements wxAppConsoleBase class
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.06.2003 (extracted from common/appcmn.cpp)
#endif
#ifndef WX_PRECOMP
+ #ifdef __WXMSW__
+ #include "wx/msw/wrapwin.h" // includes windows.h for MessageBox()
+ #endif
+ #include "wx/list.h"
#include "wx/app.h"
#include "wx/intl.h"
- #include "wx/list.h"
#include "wx/log.h"
+ #include "wx/utils.h"
+ #include "wx/wxcrtvararg.h"
#endif //WX_PRECOMP
-#include "wx/utils.h"
#include "wx/apptrait.h"
#include "wx/cmdline.h"
#include "wx/confbase.h"
+#include "wx/evtloop.h"
#include "wx/filename.h"
#include "wx/msgout.h"
+#include "wx/ptr_scpd.h"
#include "wx/tokenzr.h"
+#if wxUSE_EXCEPTIONS && wxUSE_STL
+ #include <exception>
+ #include <typeinfo>
+#endif
+
#if !defined(__WXMSW__) || defined(__WXMICROWIN__)
#include <signal.h> // for SIGTRAP used by wxTrap()
#endif //Win/Unix
-#if defined(__WXMSW__)
- #include "wx/msw/wrapwin.h" // includes windows.h for MessageBox()
-#endif
+#include <locale.h>
#if wxUSE_FONTMAP
#include "wx/fontmap.h"
#endif
#if defined(__WXMAC__)
- // VZ: MacTypes.h is enough under Mac OS X (where I could test it) but
- // I don't know which headers are needed under earlier systems so
- // include everything when in doubt
#ifdef __DARWIN__
- #include "MacTypes.h"
+ #include <CoreServices/CoreServices.h>
#else
#include "wx/mac/private.h" // includes mac headers
#endif
#endif // __WXMAC__
#ifdef __WXDEBUG__
- #ifdef wxUSE_STACKWALKER
+ #if wxUSE_STACKWALKER
#include "wx/stackwalk.h"
+ #ifdef __WXMSW__
+ #include "wx/msw/debughlp.h"
+ #endif
#endif // wxUSE_STACKWALKER
#endif // __WXDEBUG__
+// 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
+// default value in version.h
+#if wxABI_VERSION != wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + 99
+#error "wxABI_VERSION should not be defined when compiling the library"
+#endif
+
// ----------------------------------------------------------------------------
// private functions prototypes
// ----------------------------------------------------------------------------
// prepare for showing the assert dialog, use the given traits or
// DoShowAssertDialog() as last fallback to really show it
static
- void ShowAssertDialog(const wxChar *szFile,
+ void ShowAssertDialog(const wxString& szFile,
int nLine,
- const wxChar *szCond,
- const wxChar *szMsg,
+ const wxString& szFunc,
+ const wxString& szCond,
+ const wxString& szMsg,
wxAppTraits *traits = NULL);
// turn on the trace masks specified in the env variable WXTRACE
// global vars
// ----------------------------------------------------------------------------
-wxAppConsole *wxAppConsole::ms_appInstance = NULL;
+wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
-wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
+wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
+
+// ----------------------------------------------------------------------------
+// wxEventLoopPtr
+// ----------------------------------------------------------------------------
+
+// this defines wxEventLoopPtr
+wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)
// ============================================================================
-// wxAppConsole implementation
+// wxAppConsoleBase implementation
// ============================================================================
// ----------------------------------------------------------------------------
// ctor/dtor
// ----------------------------------------------------------------------------
-wxAppConsole::wxAppConsole()
+wxAppConsoleBase::wxAppConsoleBase()
{
m_traits = NULL;
+ m_mainLoop = NULL;
- ms_appInstance = this;
+ ms_appInstance = wx_static_cast(wxAppConsole *, this);
#ifdef __WXDEBUG__
SetTraceMasks();
#endif
}
-wxAppConsole::~wxAppConsole()
+wxAppConsoleBase::~wxAppConsoleBase()
{
delete m_traits;
}
// initilization/cleanup
// ----------------------------------------------------------------------------
-bool wxAppConsole::Initialize(int& argc, wxChar **argv)
+bool wxAppConsoleBase::Initialize(int& argcOrig, wxChar **argvOrig)
{
-#if wxUSE_LOG
- // If some code logged something before wxApp instance was created,
- // wxLogStderr was set as the target. Undo it here by destroying the
- // current target. It will be re-created next time logging is needed, but
- // this time wxAppTraits will be used:
- delete wxLog::SetActiveTarget(NULL);
-#endif // wxUSE_LOG
+#if wxUSE_INTL
+ GetTraits()->SetLocale();
+#endif // wxUSE_INTL
// remember the command line arguments
- this->argc = argc;
- this->argv = argv;
+ argc = argcOrig;
+ argv = argvOrig;
+
+#if wxUSE_THREADS
+ wxPendingEventsLocker = new wxCriticalSection;
+#endif
#ifndef __WXPALMOS__
if ( m_appName.empty() && argv )
// the application name is, by default, the name of its executable file
wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
}
-#endif
+#endif // !__WXPALMOS__
return true;
}
-void wxAppConsole::CleanUp()
+wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
+{
+ return GetTraits()->CreateEventLoop();
+}
+
+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
}
// ----------------------------------------------------------------------------
// OnXXX() callbacks
// ----------------------------------------------------------------------------
-bool wxAppConsole::OnInit()
+bool wxAppConsoleBase::OnInit()
{
#if wxUSE_CMDLINE_PARSER
wxCmdLineParser parser(argc, argv);
return true;
}
-int wxAppConsole::OnExit()
+int wxAppConsoleBase::OnRun()
+{
+ return MainLoop();
+}
+
+int wxAppConsoleBase::OnExit()
{
#if wxUSE_CONFIG
// delete the config object if any (don't use Get() here, but Set()
delete wxConfigBase::Set((wxConfigBase *) NULL);
#endif // wxUSE_CONFIG
- // use Set(NULL) and not Get() to avoid creating a message output object on
- // demand when we just want to delete it
- delete wxMessageOutput::Set(NULL);
-
return 0;
}
-void wxAppConsole::Exit()
+void wxAppConsoleBase::Exit()
{
- exit(-1);
+ if (m_mainLoop != NULL)
+ ExitMainLoop();
+ else
+ exit(-1);
}
// ----------------------------------------------------------------------------
// traits stuff
// ----------------------------------------------------------------------------
-wxAppTraits *wxAppConsole::CreateTraits()
+wxAppTraits *wxAppConsoleBase::CreateTraits()
{
return new wxConsoleAppTraits;
}
-wxAppTraits *wxAppConsole::GetTraits()
+wxAppTraits *wxAppConsoleBase::GetTraits()
{
// FIXME-MT: protect this with a CS?
if ( !m_traits )
return m_traits;
}
-// we must implement CreateXXX() in wxApp itself for backwards compatibility
-#if WXWIN_COMPATIBILITY_2_4
+// ----------------------------------------------------------------------------
+// event processing
+// ----------------------------------------------------------------------------
+
+int wxAppConsoleBase::MainLoop()
+{
+ wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
-#if wxUSE_LOG
+ return m_mainLoop ? m_mainLoop->Run() : -1;
+}
-wxLog *wxAppConsole::CreateLogTarget()
+void wxAppConsoleBase::ExitMainLoop()
{
- wxAppTraits *traits = GetTraits();
- return traits ? traits->CreateLogTarget() : NULL;
+ // we should exit from the main event loop, not just any currently active
+ // (e.g. modal dialog) event loop
+ if ( m_mainLoop && m_mainLoop->IsRunning() )
+ {
+ m_mainLoop->Exit(0);
+ }
}
-#endif // wxUSE_LOG
+bool wxAppConsoleBase::Pending()
+{
+ // use the currently active message loop here, not m_mainLoop, because if
+ // we're showing a modal dialog (with its own event loop) currently the
+ // main event loop is not running anyhow
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
-wxMessageOutput *wxAppConsole::CreateMessageOutput()
+ return loop && loop->Pending();
+}
+
+bool wxAppConsoleBase::Dispatch()
{
- wxAppTraits *traits = GetTraits();
- return traits ? traits->CreateMessageOutput() : NULL;
+ // see comment in Pending()
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+ return loop && loop->Dispatch();
}
-#endif // WXWIN_COMPATIBILITY_2_4
+bool wxAppConsoleBase::HasPendingEvents() const
+{
+ wxENTER_CRIT_SECT( *wxPendingEventsLocker );
-// ----------------------------------------------------------------------------
-// event processing
-// ----------------------------------------------------------------------------
+ bool has = wxPendingEvents && !wxPendingEvents->IsEmpty();
+
+ wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+
+ return has;
+}
-void wxAppConsole::ProcessPendingEvents()
+/* static */
+bool wxAppConsoleBase::IsMainLoopRunning()
{
+ const wxAppConsole * const app = GetInstance();
+
+ return app && app->m_mainLoop != NULL;
+}
+
+void wxAppConsoleBase::ProcessPendingEvents()
+{
+#if wxUSE_THREADS
if ( !wxPendingEventsLocker )
return;
-
- // ensure that we're the only thread to modify the pending events list
+#endif
+
wxENTER_CRIT_SECT( *wxPendingEventsLocker );
- if ( !wxPendingEvents )
+ if (wxPendingEvents)
{
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
- return;
- }
+ // iterate until the list becomes empty
+ wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
+ while (node)
+ {
+ wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
+ wxPendingEvents->Erase(node);
- // iterate until the list becomes empty
- wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
- while (node)
- {
- wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
- wxPendingEvents->Erase(node);
+ // In ProcessPendingEvents(), new handlers might be add
+ // and we can safely leave the critical section here.
+ wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+
+ handler->ProcessPendingEvents();
- // In ProcessPendingEvents(), new handlers might be add
- // and we can safely leave the critical section here.
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
- handler->ProcessPendingEvents();
- wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+ wxENTER_CRIT_SECT( *wxPendingEventsLocker );
- node = wxPendingEvents->GetFirst();
+ node = wxPendingEvents->GetFirst();
+ }
}
wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
}
-int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
+void wxAppConsoleBase::WakeUpIdle()
+{
+ if ( m_mainLoop )
+ m_mainLoop->WakeUp();
+}
+
+bool wxAppConsoleBase::ProcessIdle()
+{
+ wxIdleEvent event;
+
+ event.SetEventObject(this);
+ ProcessEvent(event);
+ return event.MoreRequested();
+}
+
+int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))
{
// process the events normally by default
return -1;
#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);
}
-bool
-wxAppConsole::OnExceptionInMainLoop()
+void wxAppConsoleBase::OnUnhandledException()
+{
+#ifdef __WXDEBUG__
+ // we're called from an exception handler so we can re-throw the exception
+ // to recover its type
+ wxString what;
+ try
+ {
+ throw;
+ }
+#if wxUSE_STL
+ catch ( std::exception& e )
+ {
+ what.Printf("std::exception of type \"%s\", what() = \"%s\"",
+ typeid(e).name(), e.what());
+ }
+#endif // wxUSE_STL
+ catch ( ... )
+ {
+ what = "unknown exception";
+ }
+
+ wxMessageOutputBest().Printf(
+ "*** Caught unhandled %s; terminating\n", what
+ );
+#endif // __WXDEBUG__
+}
+
+// ----------------------------------------------------------------------------
+// exceptions support
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::OnExceptionInMainLoop()
{
throw;
#define OPTION_VERBOSE _T("verbose")
-void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
+void wxAppConsoleBase::OnInitCmdLine(wxCmdLineParser& parser)
{
// the standard command line options
static const wxCmdLineEntryDesc cmdLineDesc[] =
parser.SetDesc(cmdLineDesc);
}
-bool wxAppConsole::OnCmdLineParsed(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineParsed(wxCmdLineParser& parser)
{
#if wxUSE_LOG
if ( parser.Found(OPTION_VERBOSE) )
return true;
}
-bool wxAppConsole::OnCmdLineHelp(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineHelp(wxCmdLineParser& parser)
{
parser.Usage();
return false;
}
-bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineError(wxCmdLineParser& parser)
{
parser.Usage();
// ----------------------------------------------------------------------------
/* 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",
#ifdef __WXDEBUG__
-void wxAppConsole::OnAssert(const wxChar *file,
- int line,
- const wxChar *cond,
- const wxChar *msg)
+void wxAppConsoleBase::OnAssertFailure(const wxChar *file,
+ int line,
+ const wxChar *func,
+ const wxChar *cond,
+ const wxChar *msg)
{
- ShowAssertDialog(file, line, cond, msg, GetTraits());
+ ShowAssertDialog(file, line, func, cond, msg, GetTraits());
}
-#endif // __WXDEBUG__
-
-#if WXWIN_COMPATIBILITY_2_4
-
-bool wxAppConsole::CheckBuildOptions(const wxBuildOptions& buildOptions)
+void wxAppConsoleBase::OnAssert(const wxChar *file,
+ int line,
+ const wxChar *cond,
+ const wxChar *msg)
{
- return CheckBuildOptions(buildOptions.m_signature, "your program");
+ OnAssertFailure(file, line, NULL, cond, msg);
}
-#endif
+#endif // __WXDEBUG__
// ============================================================================
// other classes implementations
// wxAppTraits
// ----------------------------------------------------------------------------
+#if wxUSE_INTL
+void wxAppTraitsBase::SetLocale()
+{
+ wxSetlocale(LC_ALL, "");
+ wxUpdateLocaleIsUtf8();
+}
+#endif
+
#ifdef __WXDEBUG__
-bool wxAppTraitsBase::ShowAssertDialog(const wxString& msg)
+bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
{
+ wxString msg = msgOriginal;
+
+#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;
+#endif // wxUSE_STACKWALKER
+
return DoShowAssertDialog(msg);
}
+#if wxUSE_STACKWALKER
+wxString wxAppTraitsBase::GetAssertStackTrace()
+{
+ wxString stackTrace;
+
+ class StackDump : public wxStackWalker
+ {
+ public:
+ StackDump() { }
+
+ const wxString& GetStackTrace() const { return m_stackTrace; }
+
+ protected:
+ virtual void OnStackFrame(const wxStackFrame& frame)
+ {
+ m_stackTrace << wxString::Format
+ (
+ _T("[%02d] "),
+ wx_truncate_cast(int, frame.GetLevel())
+ );
+
+ wxString name = frame.GetName();
+ if ( !name.empty() )
+ {
+ m_stackTrace << wxString::Format(_T("%-40s"), name.c_str());
+ }
+ else
+ {
+ m_stackTrace << wxString::Format(_T("%p"), frame.GetAddress());
+ }
+
+ if ( frame.HasSourceLocation() )
+ {
+ m_stackTrace << _T('\t')
+ << frame.GetFileName()
+ << _T(':')
+ << frame.GetLine();
+ }
+
+ m_stackTrace << _T('\n');
+ }
+
+ private:
+ wxString m_stackTrace;
+ };
+
+ // don't show more than maxLines or we could get a dialog too tall to be
+ // shown on screen: 20 should be ok everywhere as even with 15 pixel high
+ // characters it is still only 300 pixels...
+ static const int maxLines = 20;
+
+ StackDump dump;
+ dump.Walk(2, maxLines); // don't show OnAssert() call itself
+ stackTrace = dump.GetStackTrace();
+
+ const int count = stackTrace.Freq(wxT('\n'));
+ for ( int i = 0; i < count - maxLines; i++ )
+ stackTrace = stackTrace.BeforeLast(wxT('\n'));
+
+ return stackTrace;
+}
+#endif // wxUSE_STACKWALKER
+
+
#endif // __WXDEBUG__
// ============================================================================
#endif // Win/Unix
}
-void wxAssert(int cond,
- const wxChar *szFile,
- int nLine,
- const wxChar *szCond,
- const wxChar *szMsg)
-{
- if ( !cond )
- wxOnAssert(szFile, nLine, szCond, szMsg);
-}
-
// this function is called when an assert fails
-void wxOnAssert(const wxChar *szFile,
- int nLine,
- const wxChar *szCond,
- const wxChar *szMsg)
+static void wxDoOnAssert(const wxString& szFile,
+ int nLine,
+ const wxString& szFunc,
+ const wxString& szCond,
+ const wxString& szMsg = wxEmptyString)
{
// FIXME MT-unsafe
static bool s_bInAssert = false;
{
// by default, show the assert dialog box -- we can't customize this
// behaviour
- ShowAssertDialog(szFile, nLine, szCond, szMsg);
+ ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg);
}
else
{
// let the app process it as it wants
- wxTheApp->OnAssert(szFile, nLine, szCond, szMsg);
+ // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
+ wxTheApp->OnAssertFailure(szFile.c_str(), nLine, szFunc.c_str(),
+ szCond.c_str(), szMsg.c_str());
}
s_bInAssert = false;
}
+void wxOnAssert(const wxString& szFile,
+ int nLine,
+ const wxString& szFunc,
+ const wxString& szCond,
+ const wxString& szMsg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const wxString& szFile,
+ int nLine,
+ const wxString& szFunc,
+ const wxString& szCond)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond);
+}
+
+void wxOnAssert(const wxChar *szFile,
+ int nLine,
+ const char *szFunc,
+ const wxChar *szCond,
+ const wxChar *szMsg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const char *szFile,
+ int nLine,
+ const char *szFunc,
+ const char *szCond,
+ const wxString& szMsg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const char *szFile,
+ int nLine,
+ const char *szFunc,
+ const char *szCond,
+ const wxCStrData& msg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, msg);
+}
+
+#if wxUSE_UNICODE
+void wxOnAssert(const char *szFile,
+ int nLine,
+ const char *szFunc,
+ const char *szCond)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond);
+}
+
+void wxOnAssert(const char *szFile,
+ int nLine,
+ const char *szFunc,
+ const char *szCond,
+ const char *szMsg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+
+void wxOnAssert(const char *szFile,
+ int nLine,
+ const char *szFunc,
+ const char *szCond,
+ const wxChar *szMsg)
+{
+ wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
+}
+#endif // wxUSE_UNICODE
+
#endif // __WXDEBUG__
// ============================================================================
wxT("You can also choose [Cancel] to suppress ")
wxT("further warnings.");
- switch ( ::MessageBox(NULL, msgDlg, _T("wxWidgets Debug Alert"),
+ switch ( ::MessageBox(NULL, msgDlg.wx_str(), _T("wxWidgets Debug Alert"),
MB_YESNOCANCEL | MB_ICONSTOP ) )
{
case IDYES:
// show the assert modal dialog
static
-void ShowAssertDialog(const wxChar *szFile,
+void ShowAssertDialog(const wxString& szFile,
int nLine,
- const wxChar *szCond,
- const wxChar *szMsg,
+ const wxString& szFunc,
+ const wxString& szCond,
+ const wxString& szMsg,
wxAppTraits *traits)
{
// this variable can be set to true to suppress "assert failure" messages
// the failed assert
msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
- if ( szMsg )
+ // add the function name, if any
+ if ( !szFunc.empty() )
+ msg << _T(" in ") << szFunc << _T("()");
+
+ // and the message itself
+ if ( !szMsg.empty() )
{
msg << _T(": ") << szMsg;
}
msg << _T('.');
}
-#if wxUSE_STACKWALKER
- class StackDump : public wxStackWalker
- {
- public:
- StackDump() { }
-
- const wxString& GetStackTrace() const { return m_stackTrace; }
-
- protected:
- virtual void OnStackFrame(const wxStackFrame& frame)
- {
- m_stackTrace << wxString::Format(_T("[%02d] "), frame.GetLevel());
-
- wxString name = frame.GetName();
- if ( !name.empty() )
- {
- m_stackTrace << wxString::Format(_T("%-40s"), name.c_str());
- }
- else
- {
- m_stackTrace << wxString::Format
- (
- _T("0x%08lx"),
- (unsigned long)frame.GetAddress()
- );
- }
-
- if ( frame.HasSourceLocation() )
- {
- m_stackTrace << _T('\t')
- << frame.GetFileName()
- << _T(':')
- << frame.GetLine();
- }
-
- m_stackTrace << _T('\n');
- }
-
- private:
- wxString m_stackTrace;
- };
-
- StackDump dump;
- dump.Walk(5); // don't show OnAssert() call itself
- wxString stackTrace = dump.GetStackTrace();
-
- // don't show more than maxLines or we could get a dialog too tall to be
- // shown on screen: 20 should be ok everywhere as even with 15 pixel high
- // characters it is still only 300 pixels...
- const int maxLines = 20;
- int count = stackTrace.Freq(wxT('\n'));
- if (count > maxLines)
- {
- int i;
- for (i = 0; i < count - maxLines; i++)
- stackTrace = stackTrace.BeforeLast(wxT('\n'));
- }
- if ( !stackTrace.empty() )
- {
- msg << _T("\n\nCall stack:\n")
- << stackTrace;
- }
-#endif // wxUSE_STACKWALKER
-
#if wxUSE_THREADS
// if we are not in the main thread, output the assert directly and trap
// since dialogs cannot be displayed
#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());
}
#endif // __WXDEBUG__
-
projects / wxWidgets.git / blobdiff