///////////////////////////////////////////////////////////////////////////////
// Name: src/common/appbase.cpp
-// Purpose: implements wxAppConsole class
+// Purpose: implements wxAppConsoleBase class
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.06.2003 (extracted from common/appcmn.cpp)
#include "wx/evtloop.h"
#include "wx/filename.h"
#include "wx/msgout.h"
-#include "wx/ptr_scpd.h"
+#include "wx/scopedptr.h"
#include "wx/tokenzr.h"
+#include "wx/thread.h"
+#if wxUSE_EXCEPTIONS && wxUSE_STL
+ #include <exception>
+ #include <typeinfo>
+#endif
+
+#ifndef __WXPALMOS5__
#if !defined(__WXMSW__) || defined(__WXMICROWIN__)
#include <signal.h> // for SIGTRAP used by wxTrap()
#endif //Win/Unix
#include <locale.h>
+#endif // ! __WXPALMOS5__
#if wxUSE_FONTMAP
#include "wx/fontmap.h"
#endif // wxUSE_FONTMAP
-#if defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
- // For MacTypes.h for Debugger function
- #include <CoreFoundation/CFBase.h>
-#endif
-
-#if defined(__WXMAC__)
- #ifdef __DARWIN__
- #include <CoreServices/CoreServices.h>
- #else
- #include "wx/mac/private.h" // includes mac headers
- #endif
-#endif // __WXMAC__
-
#ifdef __WXDEBUG__
#if wxUSE_STACKWALKER
#include "wx/stackwalk.h"
#include "wx/msw/debughlp.h"
#endif
#endif // wxUSE_STACKWALKER
+
+ #include "wx/recguard.h"
#endif // __WXDEBUG__
// wxABI_VERSION can be defined when compiling applications but it should be
// 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 *szFunc,
- 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 wxAppConsoleBase::ms_appInitFn = NULL;
-wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
+wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
// ----------------------------------------------------------------------------
// wxEventLoopPtr
// ----------------------------------------------------------------------------
// this defines wxEventLoopPtr
-wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoop)
+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 = static_cast<wxAppConsole *>(this);
#ifdef __WXDEBUG__
SetTraceMasks();
#endif
}
-wxAppConsole::~wxAppConsole()
+wxAppConsoleBase::~wxAppConsoleBase()
{
delete m_traits;
}
// ----------------------------------------------------------------------------
-// initilization/cleanup
+// initialization/cleanup
// ----------------------------------------------------------------------------
-bool wxAppConsole::Initialize(int& argcOrig, wxChar **argvOrig)
+bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **argv)
{
#if wxUSE_INTL
GetTraits()->SetLocale();
#endif // wxUSE_INTL
- // remember the command line arguments
- argc = argcOrig;
- argv = argvOrig;
-
-#if wxUSE_THREADS
- wxPendingEventsLocker = new wxCriticalSection;
-#endif
-
- //create port specific main loop
- m_mainLoop = CreateMainLoop();
-
#ifndef __WXPALMOS__
- if ( m_appName.empty() && argv )
+ if ( m_appName.empty() && argv && argv[0] )
{
// the application name is, by default, the name of its executable file
wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
return true;
}
-wxEventLoop *wxAppConsole::CreateMainLoop()
+wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
{
return GetTraits()->CreateEventLoop();
}
-void wxAppConsole::CleanUp()
+void wxAppConsoleBase::CleanUp()
{
- delete wxPendingEvents;
- wxPendingEvents = NULL;
-
-#if wxUSE_THREADS
- delete wxPendingEventsLocker;
- wxPendingEventsLocker = NULL;
-#endif // wxUSE_THREADS
+ if ( m_mainLoop )
+ {
+ delete m_mainLoop;
+ m_mainLoop = NULL;
+ }
}
// ----------------------------------------------------------------------------
// OnXXX() callbacks
// ----------------------------------------------------------------------------
-bool wxAppConsole::OnInit()
+bool wxAppConsoleBase::OnInit()
{
#if wxUSE_CMDLINE_PARSER
wxCmdLineParser parser(argc, argv);
return true;
}
-int wxAppConsole::OnRun()
+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()
// because Get() could create a new config object)
- delete wxConfigBase::Set((wxConfigBase *) NULL);
+ delete wxConfigBase::Set(NULL);
#endif // wxUSE_CONFIG
return 0;
}
-void wxAppConsole::Exit()
+void wxAppConsoleBase::Exit()
{
if (m_mainLoop != NULL)
ExitMainLoop();
// 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;
}
+/* static */
+wxAppTraits *wxAppConsoleBase::GetTraitsIfExists()
+{
+ wxAppConsole * const app = GetInstance();
+ return app ? app->GetTraits() : NULL;
+}
+
// ----------------------------------------------------------------------------
-// event processing
+// wxEventLoop redirection
// ----------------------------------------------------------------------------
-int wxAppConsole::MainLoop()
+int wxAppConsoleBase::MainLoop()
{
- wxEventLoopTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
+ wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
return m_mainLoop ? m_mainLoop->Run() : -1;
}
-void wxAppConsole::ExitMainLoop()
+void wxAppConsoleBase::ExitMainLoop()
{
// we should exit from the main event loop, not just any currently active
// (e.g. modal dialog) event loop
}
}
-bool wxAppConsole::Pending()
+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
- wxEventLoop * const loop = wxEventLoopBase::GetActive();
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
return loop && loop->Pending();
}
-bool wxAppConsole::Dispatch()
+bool wxAppConsoleBase::Dispatch()
{
// see comment in Pending()
- wxEventLoop * const loop = wxEventLoopBase::GetActive();
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
return loop && loop->Dispatch();
}
-bool wxAppConsole::HasPendingEvents() const
+bool wxAppConsoleBase::HasPendingEvents() const
{
- // ensure that we're the only thread to modify the pending events list
- wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- if ( !wxPendingEvents )
- {
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
- return false;
- }
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
- return true;
-};
+ return loop && loop->HasPendingEvents();
+}
-void wxAppConsole::ProcessPendingEvents()
+void wxAppConsoleBase::SuspendProcessingOfPendingEvents()
{
-#if wxUSE_THREADS
- if ( !wxPendingEventsLocker )
- return;
-#endif
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- if ( !HasPendingEvents() )
- return;
+ if (loop) loop->SuspendProcessingOfPendingEvents();
+}
- // iterate until the list becomes empty
- wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
- while (node)
- {
- wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
- wxPendingEvents->Erase(node);
+void wxAppConsoleBase::ResumeProcessingOfPendingEvents()
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- // In ProcessPendingEvents(), new handlers might be add
- // and we can safely leave the critical section here.
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+ if (loop) loop->ResumeProcessingOfPendingEvents();
+}
- handler->ProcessPendingEvents();
+void wxAppConsoleBase::ProcessPendingEvents()
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- wxENTER_CRIT_SECT( *wxPendingEventsLocker );
+ if (loop) loop->ProcessPendingEvents();
+}
- node = wxPendingEvents->GetFirst();
- }
+bool wxAppConsoleBase::Yield(bool onlyIfNeeded)
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
+ return loop && loop->Yield(onlyIfNeeded);
}
-void wxAppConsole::WakeUpIdle()
+void wxAppConsoleBase::WakeUpIdle()
{
if ( m_mainLoop )
m_mainLoop->WakeUp();
}
-bool wxAppConsole::ProcessIdle()
+bool wxAppConsoleBase::ProcessIdle()
{
- wxIdleEvent event;
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- event.SetEventObject(this);
- ProcessEvent(event);
- return event.MoreRequested();
+ return loop && loop->ProcessIdle();
}
-int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
+// ----------------------------------------------------------------------------
+// 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 -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);
}
+void wxAppConsoleBase::CallEventHandler(wxEvtHandler *handler,
+ wxEventFunctor& functor,
+ wxEvent& event) const
+{
+ // If the functor holds a method then, for backward compatibility, call
+ // HandleEvent():
+ wxEventFunction eventFunction = functor.GetMethod();
+
+ 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
// ----------------------------------------------------------------------------
-#if wxUSE_EXCEPTIONS
-
-bool wxAppConsole::OnExceptionInMainLoop()
+bool wxAppConsoleBase::OnExceptionInMainLoop()
{
throw;
#endif
}
-#endif // wxUSE_EXCEPTIONS
-
-
#endif // wxUSE_EXCEPTIONS
// ----------------------------------------------------------------------------
#if wxUSE_CMDLINE_PARSER
-#define OPTION_VERBOSE _T("verbose")
+#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
#if wxUSE_LOG
{
wxCMD_LINE_SWITCH,
- wxEmptyString,
+ NULL,
OPTION_VERBOSE,
gettext_noop("generate verbose log messages"),
wxCMD_LINE_VAL_NONE,
#endif // wxUSE_LOG
// terminator
- {
- wxCMD_LINE_NONE,
- wxEmptyString,
- wxEmptyString,
- wxEmptyString,
- 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) )
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",
// normally wxLogFatalError doesn't return
return false;
}
-#undef wxCMP
return true;
}
#ifdef __WXDEBUG__
-void wxAppConsole::OnAssertFailure(const wxChar *file,
- int line,
- const wxChar *func,
- 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 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)
{
OnAssertFailure(file, line, NULL, cond, msg);
}
// nothing to do
}
-#if wxUSE_SOCKETS
-GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
-{
- return NULL;
-}
-#endif
-
// ----------------------------------------------------------------------------
// wxAppTraits
// ----------------------------------------------------------------------------
#if wxUSE_INTL
void wxAppTraitsBase::SetLocale()
{
- setlocale(LC_ALL, "");
+ wxSetlocale(LC_ALL, "");
wxUpdateLocaleIsUtf8();
}
#endif
+#if wxUSE_THREADS
+void wxMutexGuiEnterImpl();
+void wxMutexGuiLeaveImpl();
+
+void wxAppTraitsBase::MutexGuiEnter()
+{
+ wxMutexGuiEnterImpl();
+}
+
+void wxAppTraitsBase::MutexGuiLeave()
+{
+ wxMutexGuiLeaveImpl();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiEnter()
+{
+ wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+ if ( traits )
+ traits->MutexGuiEnter();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiLeave()
+{
+ wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
+ if ( traits )
+ traits->MutexGuiLeave();
+}
+#endif // wxUSE_THREADS
+
#ifdef __WXDEBUG__
bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
{
#if defined(__WXMSW__) && !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__)
}
// this function is called when an assert fails
-void wxOnAssert(const wxChar *szFile,
- int nLine,
- const char *szFunc,
- 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 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;
-
- // __FUNCTION__ is always in ASCII, convert it to wide char if needed
- const wxString strFunc = wxString::FromAscii(szFunc);
-
if ( !wxTheApp )
{
// by default, show the assert dialog box -- we can't customize this
// behaviour
- ShowAssertDialog(szFile, nLine, strFunc, szCond, szMsg);
+ ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg);
}
else
{
// let the app process it as it wants
- wxTheApp->OnAssertFailure(szFile, nLine, strFunc, 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__
// ============================================================================
#endif // wxUSE_LOG
}
+static
bool DoShowAssertDialog(const wxString& msg)
{
// under MSW we can show the dialog even in the console mode
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 *szFunc,
- 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
msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
// add the function name, if any
- if ( szFunc && *szFunc )
+ if ( !szFunc.empty() )
msg << _T(" in ") << szFunc << _T("()");
// and the message itself
- if ( szMsg )
+ if ( !szMsg.empty() )
{
msg << _T(": ") << szMsg;
}
#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());
projects / wxWidgets.git / blobdiff