X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1c193821a999730fbf6a9bea83763f37daae68f1..a4ea083bbdf710d3234dcbd2eafb5d0e078f8348:/src/common/appbase.cpp diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp index 216d9b8647..dba66974cb 100644 --- a/src/common/appbase.cpp +++ b/src/common/appbase.cpp @@ -1,12 +1,11 @@ /////////////////////////////////////////////////////////////////////////////// -// 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) -// RCS-ID: $Id$ // Copyright: (c) 2003 Vadim Zeitlin -// License: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -25,64 +24,86 @@ #endif #ifndef WX_PRECOMP + #ifdef __WINDOWS__ + #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/utils.h" #include "wx/apptrait.h" #include "wx/cmdline.h" #include "wx/confbase.h" -#if wxUSE_FILENAME - #include "wx/filename.h" -#endif // wxUSE_FILENAME +#include "wx/evtloop.h" +#include "wx/filename.h" #include "wx/msgout.h" +#include "wx/scopedptr.h" +#include "wx/sysopt.h" #include "wx/tokenzr.h" +#include "wx/thread.h" + +#if wxUSE_STL + #if wxUSE_EXCEPTIONS + #include + #include + #endif + #if wxUSE_INTL + #include + #endif +#endif // wxUSE_STL -#if !defined(__WXMSW__) || defined(__WXMICROWIN__) +#if !defined(__WINDOWS__) || defined(__WXMICROWIN__) #include // for SIGTRAP used by wxTrap() #endif //Win/Unix -#if defined(__WXMSW__) - #include "wx/msw/private.h" // includes windows.h for MessageBox() -#endif +#include #if wxUSE_FONTMAP #include "wx/fontmap.h" #endif // wxUSE_FONTMAP -#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" - #else - #include "wx/mac/private.h" // includes mac headers - #endif -#endif // __WXMAC__ +#if wxDEBUG_LEVEL + #if wxUSE_STACKWALKER + #include "wx/stackwalk.h" + #ifdef __WINDOWS__ + #include "wx/msw/debughlp.h" + #endif + #endif // wxUSE_STACKWALKER + + #include "wx/recguard.h" +#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 +// 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 // ---------------------------------------------------------------------------- -#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 wxChar *szFile, - int nLine, - const wxChar *szCond, - const wxChar *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__ @@ -91,66 +112,115 @@ // global vars // ---------------------------------------------------------------------------- -wxApp *wxTheApp = NULL; +wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL; -wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL; +wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL; + +wxSocketManager *wxAppTraitsBase::ms_manager = NULL; + +WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete; + +// ---------------------------------------------------------------------------- +// 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; + m_bDoPendingEventProcessing = true; - wxTheApp = (wxApp *)this; + ms_appInstance = static_cast(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. + wxDELETE(m_traits); +#endif #endif + + wxEvtHandler::AddFilter(this); } -wxAppConsole::~wxAppConsole() +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 wxAppConsole::Initialize(int& argc, wxChar **argv) +bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **WXUNUSED(argv)) { - // remember the command line arguments - this->argc = argc; - this->argv = argv; + return true; +} - if ( m_appName.empty() && argv ) +wxString wxAppConsoleBase::GetAppName() const +{ + wxString name = m_appName; + if ( name.empty() ) { - // the application name is, by default, the name of its executable file -#if wxUSE_FILENAME - wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL); -#else // !wxUSE_FILENAME - m_appName = argv[0]; -#endif // wxUSE_FILENAME/!wxUSE_FILENAME + if ( argv ) + { + // the application name is, by default, the name of its executable file + wxFileName::SplitPath(argv[0], NULL, &name, NULL); + } } + 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() +{ + return GetTraits()->CreateEventLoop(); } -void wxAppConsole::CleanUp() +void wxAppConsoleBase::CleanUp() { + wxDELETE(m_mainLoop); } // ---------------------------------------------------------------------------- // OnXXX() callbacks // ---------------------------------------------------------------------------- -bool wxAppConsole::OnInit() +bool wxAppConsoleBase::OnInit() { #if wxUSE_CMDLINE_PARSER wxCmdLineParser parser(argc, argv); @@ -158,7 +228,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); @@ -174,138 +244,448 @@ bool wxAppConsole::OnInit() } if ( !cont ) - return FALSE; + return false; #endif // wxUSE_CMDLINE_PARSER - return TRUE; + return true; +} + +int wxAppConsoleBase::OnRun() +{ + return MainLoop(); +} + +void wxAppConsoleBase::OnLaunched() +{ } -int wxAppConsole::OnExit() +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 -#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 new wxConsoleAppTraits; } -wxAppTraits *wxAppConsole::GetTraits() +wxAppTraits *wxAppConsoleBase::GetTraits() { // FIXME-MT: protect this with a CS? if ( !m_traits ) { m_traits = CreateTraits(); - wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") ); + wxASSERT_MSG( m_traits, wxT("wxApp::CreateTraits() failed?") ); } return m_traits; } -// we must implement CreateXXX() in wxApp itself for backwards compatibility -#if WXWIN_COMPATIBILITY_2_4 +/* 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; +} + +// ---------------------------------------------------------------------------- +// wxEventLoop redirection +// ---------------------------------------------------------------------------- + +int wxAppConsoleBase::MainLoop() +{ + wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop()); + +#if defined(__WXOSX__) && wxOSX_USE_COCOA_OR_IPHONE + // OnLaunched called from native app controller +#else + if (wxTheApp) + wxTheApp->OnLaunched(); +#endif + + return m_mainLoop ? m_mainLoop->Run() : -1; +} + +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); + } +} + +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(); + + return loop && loop->Pending(); +} + +bool wxAppConsoleBase::Dispatch() +{ + // see comment in Pending() + wxEventLoopBase * const loop = wxEventLoopBase::GetActive(); + + return loop && loop->Dispatch(); +} + +bool wxAppConsoleBase::Yield(bool onlyIfNeeded) +{ + wxEventLoopBase * const loop = wxEventLoopBase::GetActive(); + if ( loop ) + return loop->Yield(onlyIfNeeded); + + wxScopedPtr tmpLoop(CreateMainLoop()); + return tmpLoop->Yield(onlyIfNeeded); +} + +void wxAppConsoleBase::WakeUpIdle() +{ + wxEventLoopBase * const loop = wxEventLoopBase::GetActive(); + + 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(); -wxLog *wxAppConsole::CreateLogTarget() + return event.MoreRequested(); +} + +bool wxAppConsoleBase::UsesEventLoop() const { - wxAppTraits *traits = GetTraits(); - return traits ? traits->CreateLogTarget() : NULL; + // 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; } -#endif // wxUSE_LOG +// ---------------------------------------------------------------------------- +// events +// ---------------------------------------------------------------------------- + +/* static */ +bool wxAppConsoleBase::IsMainLoopRunning() +{ + const wxAppConsole * const app = GetInstance(); + + return app && app->m_mainLoop != NULL; +} + +int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event)) +{ + // 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); +} + +void wxAppConsoleBase::RemovePendingEventHandler(wxEvtHandler* toRemove) +{ + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); + + 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; +} -wxMessageOutput *wxAppConsole::CreateMessageOutput() +void wxAppConsoleBase::ResumeProcessingOfPendingEvents() { - wxAppTraits *traits = GetTraits(); - return traits ? traits->CreateMessageOutput() : NULL; + m_bDoPendingEventProcessing = true; } -#endif // WXWIN_COMPATIBILITY_2_4 +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 + while (!m_handlersWithPendingEvents.IsEmpty()) + { + // In ProcessPendingEvents(), new handlers might be added + // and we can safely leave the critical section here. + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); + + // NOTE: we always call ProcessPendingEvents() on the first event handler + // with pending events because handlers auto-remove themselves + // from this list (see RemovePendingEventHandler) if they have no + // more pending events. + m_handlersWithPendingEvents[0]->ProcessPendingEvents(); + + wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker); + } + + // now the wxHandlersWithPendingEvents is surely empty; however some event + // handlers may have moved themselves into wxHandlersWithPendingDelayedEvents + // because of a selective wxYield call in progress. + // Now we need to move them back to wxHandlersWithPendingEvents so the next + // call to this function has the chance of processing them: + if (!m_handlersWithPendingDelayedEvents.IsEmpty()) + { + WX_APPEND_ARRAY(m_handlersWithPendingEvents, m_handlersWithPendingDelayedEvents); + m_handlersWithPendingDelayedEvents.Clear(); + } + + wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker); + } +} + +void wxAppConsoleBase::DeletePendingEvents() +{ + 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); +} // ---------------------------------------------------------------------------- -// event processing +// delayed objects destruction // ---------------------------------------------------------------------------- -void wxAppConsole::ProcessPendingEvents() +bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const { - // ensure that we're the only thread to modify the pending events list - wxENTER_CRIT_SECT( *wxPendingEventsLocker ); + return wxPendingDelete.Member(object); +} - if ( !wxPendingEvents ) +void wxAppConsoleBase::ScheduleForDestruction(wxObject *object) +{ + if ( !UsesEventLoop() ) { - wxLEAVE_CRIT_SECT( *wxPendingEventsLocker ); + // 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 - // iterate until the list becomes empty - wxList::compatibility_iterator node = wxPendingEvents->GetFirst(); + if ( !wxPendingDelete.Member(object) ) + wxPendingDelete.Append(object); +} + +void wxAppConsoleBase::DeletePendingObjects() +{ + wxList::compatibility_iterator node = wxPendingDelete.GetFirst(); while (node) { - wxEvtHandler *handler = (wxEvtHandler *)node->GetData(); - wxPendingEvents->Erase(node); + wxObject *obj = node->GetData(); - // 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 ); + // 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); - node = wxPendingEvents->GetFirst(); + delete obj; + + // Deleting one object may have deleted other pending + // objects, so start from beginning of list again. + node = wxPendingDelete.GetFirst(); } +} - wxLEAVE_CRIT_SECT( *wxPendingEventsLocker ); +// ---------------------------------------------------------------------------- +// exception handling +// ---------------------------------------------------------------------------- + +#if wxUSE_EXCEPTIONS + +void +wxAppConsoleBase::HandleEvent(wxEvtHandler *handler, + wxEventFunction func, + wxEvent& event) const +{ + // by default, simply call the handler + (handler->*func)(event); } -int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event)) +void wxAppConsoleBase::CallEventHandler(wxEvtHandler *handler, + wxEventFunctor& functor, + wxEvent& event) const { - // process the events normally by default - return -1; + // 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__ + // 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 @@ -314,7 +694,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, @@ -322,102 +702,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 @@ -427,59 +744,72 @@ 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(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; + return false; } -#undef wxCMP - return TRUE; + 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 wxAppConsole::OnAssert(const wxChar *file, - int line, - const wxChar *cond, - const wxChar *msg) +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__ +// ---------------------------------------------------------------------------- +// 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 @@ -512,12 +842,16 @@ wxFontMapper *wxConsoleAppTraitsBase::CreateFontMapper() #endif // wxUSE_FONTMAP -#ifdef __WXDEBUG__ +wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer() +{ + // console applications don't use renderers + return NULL; +} + bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg) { return wxAppTraitsBase::ShowAssertDialog(msg); } -#endif bool wxConsoleAppTraitsBase::HasStderr() { @@ -525,28 +859,140 @@ bool wxConsoleAppTraitsBase::HasStderr() return true; } -void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object) +// ---------------------------------------------------------------------------- +// wxAppTraits +// ---------------------------------------------------------------------------- + +#if wxUSE_THREADS +void wxMutexGuiEnterImpl(); +void wxMutexGuiLeaveImpl(); + +void wxAppTraitsBase::MutexGuiEnter() { - delete object; + wxMutexGuiEnterImpl(); } -void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object)) +void wxAppTraitsBase::MutexGuiLeave() { - // nothing to do + wxMutexGuiLeaveImpl(); } -// ---------------------------------------------------------------------------- -// wxAppTraits -// ---------------------------------------------------------------------------- +void WXDLLIMPEXP_BASE wxMutexGuiEnter() +{ + wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists(); + if ( traits ) + traits->MutexGuiEnter(); +} -#ifdef __WXDEBUG__ +void WXDLLIMPEXP_BASE wxMutexGuiLeave() +{ + wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists(); + if ( traits ) + traits->MutexGuiLeave(); +} +#endif // wxUSE_THREADS -bool wxAppTraitsBase::ShowAssertDialog(const wxString& msg) +bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal) { - return DoShowAssertDialog(msg); +#if wxDEBUG_LEVEL + wxString msg; + +#if wxUSE_STACKWALKER + const wxString stackTrace = GetAssertStackTrace(); + if ( !stackTrace.empty() ) + { + msg << wxT("\n\nCall stack:\n") << stackTrace; + + wxMessageOutputDebug().Output(msg); + } +#endif // wxUSE_STACKWALKER + + return DoShowAssertDialog(msgOriginal + msg); +#else // !wxDEBUG_LEVEL + wxUnusedVar(msgOriginal); + + return false; +#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL } -#endif // __WXDEBUG__ +#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 + { + public: + StackDump() { } + + const wxString& GetStackTrace() const { return m_stackTrace; } + + protected: + virtual void OnStackFrame(const wxStackFrame& frame) + { + m_stackTrace << wxString::Format + ( + wxT("[%02d] "), + wx_truncate_cast(int, frame.GetLevel()) + ); + + wxString name = frame.GetName(); + if ( !name.empty() ) + { + m_stackTrace << wxString::Format(wxT("%-40s"), name.c_str()); + } + else + { + m_stackTrace << wxString::Format(wxT("%p"), frame.GetAddress()); + } + + if ( frame.HasSourceLocation() ) + { + m_stackTrace << wxT('\t') + << frame.GetFileName() + << wxT(':') + << frame.GetLine(); + } + + m_stackTrace << wxT('\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(8, maxLines); // 8 is chosen to hide all OnAssert() calls + 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; +#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 + // ============================================================================ // global functions implementation @@ -574,25 +1020,32 @@ 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(__WXMAC__) && !defined(__DARWIN__) - #if __powerc - Debugger(); - #else - SysBreak(); - #endif +#elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS + Debugger(); #elif defined(__UNIX__) raise(SIGTRAP); #else @@ -600,53 +1053,133 @@ 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); -} +#endif // wxTrap already defined as a macro -// this function is called when an assert fails -void wxOnAssert(const wxChar *szFile, - int nLine, - const wxChar *szCond, - const wxChar *szMsg) +// 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 bool s_bInAssert = FALSE; + static int s_bInAssert = 0; - if ( s_bInAssert ) + wxRecursionGuard guard(s_bInAssert); + if ( guard.IsInside() ) { - // He-e-e-e-elp!! we're trapped in endless loop + // can't use assert here to avoid infinite loops, so just trap wxTrap(); - s_bInAssert = FALSE; - return; } - s_bInAssert = TRUE; - if ( !wxTheApp ) { // by default, show the assert dialog box -- we can't customize this // behaviour - ShowAssertDialog(szFile, nLine, szCond, szMsg); + ShowAssertDialog(file, line, func, cond, msg); } 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(file.c_str(), line, func.c_str(), + cond.c_str(), msg.c_str()); } +} + +wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler; - s_bInAssert = FALSE; +void wxSetDefaultAssertHandler() +{ + wxTheAssertHandler = wxDefaultAssertHandler; } -#endif // __WXDEBUG__ +void wxOnAssert(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msg) +{ + wxTheAssertHandler(file, line, func, cond, msg); +} + +void wxOnAssert(const wxString& file, + int line, + const wxString& func, + const wxString& cond) +{ + wxTheAssertHandler(file, line, func, cond, wxString()); +} + +void wxOnAssert(const wxChar *file, + int line, + const char *func, + const wxChar *cond, + const wxChar *msg) +{ + // 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 *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) +{ + wxTheAssertHandler(file, line, func, cond, msg); +} + +#if wxUSE_UNICODE +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond) +{ + wxTheAssertHandler(file, line, func, cond, wxString()); +} + +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const char *msg) +{ + wxTheAssertHandler(file, line, func, cond, msg); +} + +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const wxChar *msg) +{ + wxTheAssertHandler(file, line, func, cond, msg); +} +#endif // wxUSE_UNICODE + +#endif // wxDEBUG_LEVEL // ============================================================================ // private functions implementation @@ -667,23 +1200,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, _T("wxWindows 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: @@ -692,28 +1240,25 @@ 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 wxChar *szFile, - int nLine, - const wxChar *szCond, - const wxChar *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 - static bool s_bNoAsserts = FALSE; + static bool s_bNoAsserts = false; wxString msg; msg.reserve(2048); @@ -721,15 +1266,20 @@ void ShowAssertDialog(const wxChar *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 ( !func.empty() ) + msg << wxT(" in ") << func << wxT("()"); - if ( szMsg ) + // and the message itself + if ( !msgUser.empty() ) { - msg << _T(": ") << szMsg; + msg << wxT(": ") << msgUser; } else // no message given { - msg << _T('.'); + msg << wxT('.'); } #if wxUSE_THREADS @@ -737,26 +1287,15 @@ void ShowAssertDialog(const wxChar *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 ); -#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()); } #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 @@ -770,5 +1309,4 @@ void ShowAssertDialog(const wxChar *szFile, } } -#endif // __WXDEBUG__ - +#endif // wxDEBUG_LEVEL