X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/22f69dd493fffccc8ec916a9ba5d45c935359a1c..6c76d1ce5928c3f463368e04fd8435d783f7b86d:/src/common/appbase.cpp

diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp
index 271e3cd7e5..66297871a4 100644
--- a/src/common/appbase.cpp
+++ b/src/common/appbase.cpp
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
-// 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)
@@ -25,42 +25,70 @@
 #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"
-    #if wxUSE_LOG
-        #include "wx/log.h"
-    #endif // wxUSE_LOG
+    #include "wx/log.h"
+    #include "wx/utils.h"
+    #include "wx/wxcrtvararg.h"
 #endif //WX_PRECOMP
 
 #include "wx/apptrait.h"
 #include "wx/cmdline.h"
 #include "wx/confbase.h"
-#if wxUSE_FONTMAP
-    #include "wx/fontmap.h"
-#endif // wxUSE_FONTMAP
+#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/private.h"  // includes windows.h for MessageBox()
+#include <locale.h>
+
+#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__)
-    // 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__
+    #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
 // ----------------------------------------------------------------------------
@@ -72,10 +100,11 @@
     // 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
@@ -86,39 +115,105 @@
 // global vars
 // ----------------------------------------------------------------------------
 
-wxApp *wxTheApp = NULL;
+wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
+
+wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
+
+// ----------------------------------------------------------------------------
+// wxEventLoopPtr
+// ----------------------------------------------------------------------------
 
-wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
+// 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;
 
-    wxTheApp = (wxApp *)this;
+    ms_appInstance = wx_static_cast(wxAppConsole *, this);
 
 #ifdef __WXDEBUG__
     SetTraceMasks();
+#if wxUSE_UNICODE
+    // 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;
+#endif
 #endif
 }
 
-wxAppConsole::~wxAppConsole()
+wxAppConsoleBase::~wxAppConsoleBase()
 {
     delete m_traits;
 }
 
+// ----------------------------------------------------------------------------
+// initilization/cleanup
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::Initialize(int& argcOrig, wxChar **argvOrig)
+{
+#if wxUSE_INTL
+    GetTraits()->SetLocale();
+#endif // wxUSE_INTL
+
+    // remember the command line arguments
+    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 // !__WXPALMOS__
+
+    return true;
+}
+
+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);
@@ -126,7 +221,7 @@ bool wxAppConsole::OnInit()
     OnInitCmdLine(parser);
 
     bool cont;
-    switch ( parser.Parse(FALSE /* don't show usage */) )
+    switch ( parser.Parse(false /* don't show usage */) )
     {
         case -1:
             cont = OnCmdLineHelp(parser);
@@ -142,13 +237,18 @@ bool wxAppConsole::OnInit()
     }
 
     if ( !cont )
-        return FALSE;
+        return false;
 #endif // wxUSE_CMDLINE_PARSER
 
-    return TRUE;
+    return true;
+}
+
+int wxAppConsoleBase::OnRun()
+{
+    return MainLoop();
 }
 
-int wxAppConsole::OnExit()
+int wxAppConsoleBase::OnExit()
 {
 #if wxUSE_CONFIG
     // delete the config object if any (don't use Get() here, but Set()
@@ -156,32 +256,27 @@ int wxAppConsole::OnExit()
     delete wxConfigBase::Set((wxConfigBase *) NULL);
 #endif // wxUSE_CONFIG
 
-#ifdef __WXUNIVERSAL__
-    delete wxTheme::Set(NULL);
-#endif // __WXUNIVERSAL__
-
-    // 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 wxAppTraits::CreateConsole();
+    return new wxConsoleAppTraits;
 }
 
-wxAppTraits *wxAppConsole::GetTraits()
+wxAppTraits *wxAppConsoleBase::GetTraits()
 {
     // FIXME-MT: protect this with a CS?
     if ( !m_traits )
@@ -194,86 +289,194 @@ wxAppTraits *wxAppConsole::GetTraits()
     return m_traits;
 }
 
-// we must implement CreateXXX() in wxApp itself for backwards compatibility
-#if WXWIN_COMPATIBILITY_2_4
-
-#if wxUSE_LOG
+// ----------------------------------------------------------------------------
+// event processing
+// ----------------------------------------------------------------------------
 
-wxLog *wxAppConsole::CreateLogTarget()
+int wxAppConsoleBase::MainLoop()
 {
-    wxAppTraits *traits = GetTraits();
-    return traits ? traits->CreateLogTarget() : NULL;
+    wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
+
+    return m_mainLoop ? m_mainLoop->Run() : -1;
 }
 
-#endif // wxUSE_LOG
+void wxAppConsoleBase::ExitMainLoop()
+{
+    // 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);
+    }
+}
 
-wxMessageOutput *wxAppConsole::CreateMessageOutput()
+bool wxAppConsoleBase::Pending()
 {
-    wxAppTraits *traits = GetTraits();
-    return traits ? traits->CreateMessageOutput() : NULL;
+    // 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();
+
+    return loop && loop->Pending();
 }
 
-#endif // WXWIN_COMPATIBILITY_2_4
+bool wxAppConsoleBase::Dispatch()
+{
+    // see comment in Pending()
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 
-// ----------------------------------------------------------------------------
-// event processing
-// ----------------------------------------------------------------------------
+    return loop && loop->Dispatch();
+}
 
-void wxAppConsole::ProcessPendingEvents()
+bool wxAppConsoleBase::HasPendingEvents() const
 {
-    // ensure that we're the only thread to modify the pending events list
     wxENTER_CRIT_SECT( *wxPendingEventsLocker );
 
-    if ( !wxPendingEvents )
-    {
-        wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+    bool has = wxPendingEvents && !wxPendingEvents->IsEmpty();
+
+    wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+
+    return has;
+}
+
+/* static */
+bool wxAppConsoleBase::IsMainLoopRunning()
+{
+    const wxAppConsole * const app = GetInstance();
+
+    return app && app->m_mainLoop != NULL;
+}
+
+void wxAppConsoleBase::ProcessPendingEvents()
+{
+#if wxUSE_THREADS
+    if ( !wxPendingEventsLocker )
         return;
-    }
+#endif
+
+    wxENTER_CRIT_SECT( *wxPendingEventsLocker );
 
-    // iterate until the list becomes empty
-    wxNode *node = wxPendingEvents->GetFirst();
-    while (node)
+    if (wxPendingEvents)
     {
-        wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
-        delete 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();
-        wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+            // In ProcessPendingEvents(), new handlers might be add
+            // and we can safely leave the critical section here.
+            wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
 
-        node = wxPendingEvents->GetFirst();
+            handler->ProcessPendingEvents();
+
+            wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+
+            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;
 }
 
+// ----------------------------------------------------------------------------
+// exception handling
+// ----------------------------------------------------------------------------
+
+#if wxUSE_EXCEPTIONS
+
+void
+wxAppConsoleBase::HandleEvent(wxEvtHandler *handler,
+                              wxEventFunction func,
+                              wxEvent& event) const
+{
+    // by default, simply call the handler
+    (handler->*func)(event);
+}
+
+void wxAppConsoleBase::OnUnhandledException()
+{
+#ifdef __WXDEBUG__
+    // we're called from an exception handler so we can re-throw the exception
+    // to recover its type
+    wxString what;
+    try
+    {
+        throw;
+    }
+#if wxUSE_STL
+    catch ( std::exception& e )
+    {
+        what.Printf("std::exception of type \"%s\", what() = \"%s\"",
+                    typeid(e).name(), e.what());
+    }
+#endif // wxUSE_STL
+    catch ( ... )
+    {
+        what = "unknown exception";
+    }
+
+    wxMessageOutputBest().Printf(
+        "*** Caught unhandled %s; terminating\n", what
+    );
+#endif // __WXDEBUG__
+}
+
+// ----------------------------------------------------------------------------
+// exceptions support
+// ----------------------------------------------------------------------------
+
+bool wxAppConsoleBase::OnExceptionInMainLoop()
+{
+    throw;
+
+    // some compilers are too stupid to know that we never return after throw
+#if defined(__DMC__) || (defined(_MSC_VER) && _MSC_VER < 1200)
+    return false;
+#endif
+}
+
+#endif // wxUSE_EXCEPTIONS
+
 // ----------------------------------------------------------------------------
 // cmd line parsing
 // ----------------------------------------------------------------------------
 
 #if wxUSE_CMDLINE_PARSER
 
-#define OPTION_VERBOSE _T("verbose")
-#define OPTION_THEME   _T("theme")
-#define OPTION_MODE    _T("mode")
+#define OPTION_VERBOSE "verbose"
 
-void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
+void wxAppConsoleBase::OnInitCmdLine(wxCmdLineParser& parser)
 {
     // the standard command line options
     static const wxCmdLineEntryDesc cmdLineDesc[] =
     {
         {
             wxCMD_LINE_SWITCH,
-            _T("h"),
-            _T("help"),
+            "h",
+            "help",
             gettext_noop("show this help message"),
             wxCMD_LINE_VAL_NONE,
             wxCMD_LINE_OPTION_HELP
@@ -282,7 +485,7 @@ void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
 #if wxUSE_LOG
         {
             wxCMD_LINE_SWITCH,
-            _T(""),
+            NULL,
             OPTION_VERBOSE,
             gettext_noop("generate verbose log messages"),
             wxCMD_LINE_VAL_NONE,
@@ -290,102 +493,39 @@ void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
         },
 #endif // wxUSE_LOG
 
-#ifdef __WXUNIVERSAL__
-        {
-            wxCMD_LINE_OPTION,
-            _T(""),
-            OPTION_THEME,
-            gettext_noop("specify the theme to use"),
-            wxCMD_LINE_VAL_STRING,
-            0x0
-        },
-#endif // __WXUNIVERSAL__
-
-#if defined(__WXMGL__)
-        // VS: this is not specific to wxMGL, all fullscreen (framebuffer) ports
-        //     should provide this option. That's why it is in common/appcmn.cpp
-        //     and not mgl/app.cpp
-        {
-            wxCMD_LINE_OPTION,
-            _T(""),
-            OPTION_MODE,
-            gettext_noop("specify display mode to use (e.g. 640x480-16)"),
-            wxCMD_LINE_VAL_STRING,
-            0x0
-        },
-#endif // __WXMGL__
-
         // terminator
-        {
-            wxCMD_LINE_NONE,
-            _T(""),
-            _T(""),
-            _T(""),
-            wxCMD_LINE_VAL_NONE,
-            0x0
-        }
+        wxCMD_LINE_DESC_END
     };
 
     parser.SetDesc(cmdLineDesc);
 }
 
-bool wxAppConsole::OnCmdLineParsed(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineParsed(wxCmdLineParser& parser)
 {
 #if wxUSE_LOG
     if ( parser.Found(OPTION_VERBOSE) )
     {
-        wxLog::SetVerbose(TRUE);
+        wxLog::SetVerbose(true);
     }
+#else
+    wxUnusedVar(parser);
 #endif // wxUSE_LOG
 
-#ifdef __WXUNIVERSAL__
-    wxString themeName;
-    if ( parser.Found(OPTION_THEME, &themeName) )
-    {
-        wxTheme *theme = wxTheme::Create(themeName);
-        if ( !theme )
-        {
-            wxLogError(_("Unsupported theme '%s'."), themeName.c_str());
-            return FALSE;
-        }
-
-        // Delete the defaultly created theme and set the new theme.
-        delete wxTheme::Get();
-        wxTheme::Set(theme);
-    }
-#endif // __WXUNIVERSAL__
-
-#if defined(__WXMGL__)
-    wxString modeDesc;
-    if ( parser.Found(OPTION_MODE, &modeDesc) )
-    {
-        unsigned w, h, bpp;
-        if ( wxSscanf(modeDesc.c_str(), _T("%ux%u-%u"), &w, &h, &bpp) != 3 )
-        {
-            wxLogError(_("Invalid display mode specification '%s'."), modeDesc.c_str());
-            return FALSE;
-        }
-
-        if ( !SetDisplayMode(wxDisplayModeInfo(w, h, bpp)) )
-            return FALSE;
-    }
-#endif // __WXMGL__
-
-    return TRUE;
+    return true;
 }
 
-bool wxAppConsole::OnCmdLineHelp(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineHelp(wxCmdLineParser& parser)
 {
     parser.Usage();
 
-    return FALSE;
+    return false;
 }
 
-bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
+bool wxAppConsoleBase::OnCmdLineError(wxCmdLineParser& parser)
 {
     parser.Usage();
 
-    return FALSE;
+    return false;
 }
 
 #endif // wxUSE_CMDLINE_PARSER
@@ -395,56 +535,51 @@ bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
 // ----------------------------------------------------------------------------
 
 /* static */
-bool wxAppConsole::CheckBuildOptions(const wxBuildOptions& opts)
+bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
+                                         const char *componentName)
 {
-#define wxCMP(what)   (what == opts.m_ ## what)
-
-    bool
-#ifdef __WXDEBUG__
-    isDebug = TRUE;
-#else
-    isDebug = FALSE;
+#if 0 // can't use wxLogTrace, not up and running yet
+    printf("checking build options object '%s' (ptr %p) in '%s'\n",
+             optionsSignature, optionsSignature, componentName);
 #endif
 
-    int verMaj = wxMAJOR_VERSION,
-        verMin = wxMINOR_VERSION;
-
-    if ( !(wxCMP(isDebug) && wxCMP(verMaj) && wxCMP(verMin)) )
+    if ( strcmp(optionsSignature, WX_BUILD_OPTIONS_SIGNATURE) != 0 )
     {
+        wxString lib = wxString::FromAscii(WX_BUILD_OPTIONS_SIGNATURE);
+        wxString prog = wxString::FromAscii(optionsSignature);
+        wxString progName = wxString::FromAscii(componentName);
         wxString msg;
-        wxString libDebug, progDebug;
-
-        if (isDebug)
-            libDebug = wxT("debug");
-        else
-            libDebug = wxT("no debug");
-
-        if (opts.m_isDebug)
-            progDebug = wxT("debug");
-        else
-            progDebug = wxT("no debug");
-        
-        msg.Printf(_T("Mismatch between the program and library build versions detected.\nThe library used %d.%d (%s), and your program used %d.%d (%s)."),
-                   verMaj, verMin, libDebug.c_str(), opts.m_verMaj, opts.m_verMin, progDebug.c_str());
-        
-        wxLogFatalError(msg);
+
+        msg.Printf(_T("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;
+        return false;
     }
 #undef wxCMP
 
-    return TRUE;
+    return true;
 }
 
 #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, func, cond, msg, GetTraits());
+}
+
+void wxAppConsoleBase::OnAssert(const wxChar *file,
+                                int line,
+                                const wxChar *cond,
+                                const wxChar *msg)
 {
-    ShowAssertDialog(file, line, cond, msg, m_traits);
+    OnAssertFailure(file, line, NULL, cond, msg);
 }
 
 #endif // __WXDEBUG__
@@ -480,6 +615,12 @@ wxFontMapper *wxConsoleAppTraitsBase::CreateFontMapper()
 
 #endif // wxUSE_FONTMAP
 
+wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
+{
+    // console applications don't use renderers
+    return NULL;
+}
+
 #ifdef __WXDEBUG__
 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
 {
@@ -503,23 +644,112 @@ void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object)
     // nothing to do
 }
 
+#if wxUSE_SOCKETS
+GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
+{
+    return NULL;
+}
+#endif
+
 // ----------------------------------------------------------------------------
 // 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);
 }
 
-#endif // __WXDEBUG__
-
-wxAppTraits *wxAppTraitsBase::CreateConsole()
+#if wxUSE_STACKWALKER
+wxString wxAppTraitsBase::GetAssertStackTrace()
 {
-    return new wxConsoleAppTraits;
+    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__
 
 // ============================================================================
 // global functions implementation
@@ -566,6 +796,8 @@ void wxTrap()
     #else
         SysBreak();
     #endif
+#elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
+    Debugger();
 #elif defined(__UNIX__)
     raise(SIGTRAP);
 #else
@@ -573,52 +805,117 @@ void wxTrap()
 #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;
+    static bool s_bInAssert = false;
 
     if ( s_bInAssert )
     {
         // He-e-e-e-elp!! we're trapped in endless loop
         wxTrap();
 
-        s_bInAssert = FALSE;
+        s_bInAssert = false;
 
         return;
     }
 
-    s_bInAssert = TRUE;
+    s_bInAssert = true;
 
     if ( !wxTheApp )
     {
         // 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;
+    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__
 
 // ============================================================================
@@ -640,6 +937,7 @@ static void LINKAGEMODE SetTraceMasks()
 #endif // wxUSE_LOG
 }
 
+static
 bool DoShowAssertDialog(const wxString& msg)
 {
     // under MSW we can show the dialog even in the console mode
@@ -652,7 +950,7 @@ bool DoShowAssertDialog(const wxString& msg)
               wxT("You can also choose [Cancel] to suppress ")
               wxT("further warnings.");
 
-    switch ( ::MessageBox(NULL, msgDlg, _T("wxWindows Debug Alert"),
+    switch ( ::MessageBox(NULL, msgDlg.wx_str(), _T("wxWidgets Debug Alert"),
                           MB_YESNOCANCEL | MB_ICONSTOP ) )
     {
         case IDYES:
@@ -679,14 +977,15 @@ bool DoShowAssertDialog(const wxString& msg)
 
 // 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
-    static bool s_bNoAsserts = FALSE;
+    static bool s_bNoAsserts = false;
 
     wxString msg;
     msg.reserve(2048);
@@ -696,7 +995,12 @@ void ShowAssertDialog(const wxChar *szFile,
     // 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;
     }
@@ -714,7 +1018,7 @@ void ShowAssertDialog(const wxChar *szFile,
 
 #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());
@@ -723,12 +1027,13 @@ void ShowAssertDialog(const wxChar *szFile,
         // He-e-e-e-elp!! we're asserting in a child thread
         wxTrap();
     }
+    else
 #endif // wxUSE_THREADS
 
     if ( !s_bNoAsserts )
     {
         // send it to the normal log destination
-        wxLogDebug(_T("%s"), msg);
+        wxLogDebug(_T("%s"), msg.c_str());
 
         if ( traits )
         {
@@ -744,4 +1049,3 @@ void ShowAssertDialog(const wxChar *szFile,
 }
 
 #endif // __WXDEBUG__
-