src/common/appcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/appcmn.cpp
// Purpose:     wxAppConsole and wxAppBase methods common to all platforms
// Author:      Vadim Zeitlin
// Modified by:
// Created:     18.10.99
// RCS-ID:      $Id$
// Copyright:   (c) Vadim Zeitlin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if defined(__BORLANDC__)
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/window.h"
    #include "wx/bitmap.h"
    #include "wx/log.h"
    #include "wx/msgdlg.h"
    #include "wx/confbase.h"
    #include "wx/utils.h"
    #include "wx/wxcrtvararg.h"
#endif

#include "wx/apptrait.h"
#include "wx/cmdline.h"
#include "wx/msgout.h"
#include "wx/thread.h"
#include "wx/vidmode.h"

#ifdef __WXDEBUG__
    #if wxUSE_STACKWALKER
        #include "wx/stackwalk.h"
    #endif // wxUSE_STACKWALKER
#endif // __WXDEBUG__

#if defined(__WXMSW__)
    #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
#endif

#if wxUSE_FONTMAP
    #include "wx/fontmap.h"
#endif // wxUSE_FONTMAP

// DLL options compatibility check:
#include "wx/build.h"
WX_CHECK_BUILD_OPTIONS("wxCore")

WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete;

// ============================================================================
// wxAppBase implementation
// ============================================================================

// ----------------------------------------------------------------------------
// initialization
// ----------------------------------------------------------------------------

wxAppBase::wxAppBase()
{
    m_topWindow = (wxWindow *)NULL;

    m_useBestVisual = false;
    m_forceTrueColour = false;

    m_isActive = true;

    // We don't want to exit the app if the user code shows a dialog from its
    // OnInit() -- but this is what would happen if we set m_exitOnFrameDelete
    // to Yes initially as this dialog would be the last top level window.
    // OTOH, if we set it to No initially we'll have to overwrite it with Yes
    // when we enter our OnRun() because we do want the default behaviour from
    // then on. But this would be a problem if the user code calls
    // SetExitOnFrameDelete(false) from OnInit().
    //
    // So we use the special "Later" value which is such that
    // GetExitOnFrameDelete() returns false for it but which we know we can
    // safely (i.e. without losing the effect of the users SetExitOnFrameDelete
    // call) overwrite in OnRun()
    m_exitOnFrameDelete = Later;
}

bool wxAppBase::Initialize(int& argcOrig, wxChar **argvOrig)
{
    if ( !wxAppConsole::Initialize(argcOrig, argvOrig) )
        return false;

    wxInitializeStockLists();

    wxBitmap::InitStandardHandlers();

    return true;
}

// ----------------------------------------------------------------------------
// cleanup
// ----------------------------------------------------------------------------

wxAppBase::~wxAppBase()
{
    // this destructor is required for Darwin
}

void wxAppBase::CleanUp()
{
    // clean up all the pending objects
    DeletePendingObjects();

    // and any remaining TLWs (they remove themselves from wxTopLevelWindows
    // when destroyed, so iterate until none are left)
    while ( !wxTopLevelWindows.empty() )
    {
        // do not use Destroy() here as it only puts the TLW in pending list
        // but we want to delete them now
        delete wxTopLevelWindows.GetFirst()->GetData();
    }

    // undo everything we did in Initialize() above
    wxBitmap::CleanUpHandlers();

    wxStockGDI::DeleteAll();

    wxDeleteStockLists();

    delete wxTheColourDatabase;
    wxTheColourDatabase = NULL;

#if wxUSE_THREADS
    #if wxUSE_VALIDATORS
        // If we don't do the following, we get an apparent memory leak.
        ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
    #endif // wxUSE_VALIDATORS
#endif // wxUSE_THREADS

    wxAppConsole::CleanUp();
}

// ----------------------------------------------------------------------------
// various accessors
// ----------------------------------------------------------------------------

wxWindow* wxAppBase::GetTopWindow() const
{
    wxWindow* window = m_topWindow;
    if (window == NULL && wxTopLevelWindows.GetCount() > 0)
        window = wxTopLevelWindows.GetFirst()->GetData();
    return window;
}

wxVideoMode wxAppBase::GetDisplayMode() const
{
    return wxVideoMode();
}

wxLayoutDirection wxAppBase::GetLayoutDirection() const
{
#if wxUSE_INTL
    const wxLocale *const locale = wxGetLocale();
    if ( locale )
    {
        const wxLanguageInfo *const
            info = wxLocale::GetLanguageInfo(locale->GetLanguage());

        if ( info )
            return info->LayoutDirection;
    }
#endif // wxUSE_INTL

    // we don't know
    return wxLayout_Default;
}

#if wxUSE_CMDLINE_PARSER

// ----------------------------------------------------------------------------
// GUI-specific command line options handling
// ----------------------------------------------------------------------------

#define OPTION_THEME   _T("theme")
#define OPTION_MODE    _T("mode")

void wxAppBase::OnInitCmdLine(wxCmdLineParser& parser)
{
    // first add the standard non GUI options
    wxAppConsole::OnInitCmdLine(parser);

    // the standard command line options
    static const wxCmdLineEntryDesc cmdLineGUIDesc[] =
    {
#ifdef __WXUNIVERSAL__
        {
            wxCMD_LINE_OPTION,
            wxEmptyString,
            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,
            wxEmptyString,
            OPTION_MODE,
            gettext_noop("specify display mode to use (e.g. 640x480-16)"),
            wxCMD_LINE_VAL_STRING,
            0x0
        },
#endif // __WXMGL__

        // terminator
        {
            wxCMD_LINE_NONE,
            wxEmptyString,
            wxEmptyString,
            wxEmptyString,
            wxCMD_LINE_VAL_NONE,
            0x0
        }
    };

    parser.SetDesc(cmdLineGUIDesc);
}

bool wxAppBase::OnCmdLineParsed(wxCmdLineParser& parser)
{
#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(wxVideoMode(w, h, bpp)) )
            return false;
    }
#endif // __WXMGL__

    return wxAppConsole::OnCmdLineParsed(parser);
}

#endif // wxUSE_CMDLINE_PARSER

// ----------------------------------------------------------------------------
// OnXXX() hooks
// ----------------------------------------------------------------------------

bool wxAppBase::OnInitGui()
{
#ifdef __WXUNIVERSAL__
    if ( !wxTheme::Get() && !wxTheme::CreateDefault() )
        return false;
#endif // __WXUNIVERSAL__

    return true;
}

int wxAppBase::OnRun()
{
    // see the comment in ctor: if the initial value hasn't been changed, use
    // the default Yes from now on
    if ( m_exitOnFrameDelete == Later )
    {
        m_exitOnFrameDelete = Yes;
    }
    //else: it has been changed, assume the user knows what he is doing

    return wxAppConsole::OnRun();
}

int wxAppBase::OnExit()
{
#ifdef __WXUNIVERSAL__
    delete wxTheme::Set(NULL);
#endif // __WXUNIVERSAL__

    return wxAppConsole::OnExit();
}

wxAppTraits *wxAppBase::CreateTraits()
{
    return new wxGUIAppTraits;
}

// ----------------------------------------------------------------------------
// misc
// ----------------------------------------------------------------------------

void wxAppBase::SetActive(bool active, wxWindow * WXUNUSED(lastFocus))
{
    if ( active == m_isActive )
        return;

    m_isActive = active;

    wxActivateEvent event(wxEVT_ACTIVATE_APP, active);
    event.SetEventObject(this);

    (void)ProcessEvent(event);
}

// ----------------------------------------------------------------------------
// idle handling
// ----------------------------------------------------------------------------

void wxAppBase::DeletePendingObjects()
{
    wxList::compatibility_iterator node = wxPendingDelete.GetFirst();
    while (node)
    {
        wxObject *obj = node->GetData();

        // remove it from the list first so that if we get back here somehow
        // during the object deletion (e.g. wxYield called from its dtor) we
        // wouldn't try to delete it the second time
        if ( wxPendingDelete.Member(obj) )
            wxPendingDelete.Erase(node);

        delete obj;

        // Deleting one object may have deleted other pending
        // objects, so start from beginning of list again.
        node = wxPendingDelete.GetFirst();
    }
}

// Returns true if more time is needed.
bool wxAppBase::ProcessIdle()
{
    // process pending wx events before sending idle events
    ProcessPendingEvents();

    wxIdleEvent event;
    bool needMore = false;
    wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
    while (node)
    {
        wxWindow* win = node->GetData();
        if (SendIdleEvents(win, event))
            needMore = true;
        node = node->GetNext();
    }

    if (wxAppConsole::ProcessIdle())
        needMore = true;

    // 'Garbage' collection of windows deleted with Close().
    DeletePendingObjects();

#if wxUSE_LOG
    // flush the logged messages if any
    wxLog::FlushActive();
#endif

    wxUpdateUIEvent::ResetUpdateTime();

    return needMore;
}

// Send idle event to window and all subwindows
bool wxAppBase::SendIdleEvents(wxWindow* win, wxIdleEvent& event)
{
    bool needMore = false;

    win->OnInternalIdle();

    // should we send idle event to this window?
    if ( wxIdleEvent::GetMode() == wxIDLE_PROCESS_ALL ||
            win->HasExtraStyle(wxWS_EX_PROCESS_IDLE) )
    {
        event.SetEventObject(win);
        win->GetEventHandler()->ProcessEvent(event);

        if (event.MoreRequested())
            needMore = true;
    }
    wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
    while ( node )
    {
        wxWindow *child = node->GetData();
        if (SendIdleEvents(child, event))
            needMore = true;

        node = node->GetNext();
    }

    return needMore;
}

// ----------------------------------------------------------------------------
// wxGUIAppTraitsBase
// ----------------------------------------------------------------------------

#if wxUSE_LOG

wxLog *wxGUIAppTraitsBase::CreateLogTarget()
{
#if wxUSE_LOGGUI
    return new wxLogGui;
#else
    // we must have something!
    return new wxLogStderr;
#endif
}

#endif // wxUSE_LOG

wxMessageOutput *wxGUIAppTraitsBase::CreateMessageOutput()
{
    // The standard way of printing help on command line arguments (app --help)
    // is (according to common practice):
    //     - console apps: to stderr (on any platform)
    //     - GUI apps: stderr on Unix platforms (!)
    //                 message box under Windows and others
#ifdef __UNIX__
    return new wxMessageOutputStderr;
#else // !__UNIX__
    // wxMessageOutputMessageBox doesn't work under Motif
    #ifdef __WXMOTIF__
        return new wxMessageOutputLog;
    #else
        return new wxMessageOutputMessageBox;
    #endif
#endif // __UNIX__/!__UNIX__
}

#if wxUSE_FONTMAP

wxFontMapper *wxGUIAppTraitsBase::CreateFontMapper()
{
    return new wxFontMapper;
}

#endif // wxUSE_FONTMAP

wxRendererNative *wxGUIAppTraitsBase::CreateRenderer()
{
    // use the default native renderer by default
    return NULL;
}

#ifdef __WXDEBUG__

bool wxGUIAppTraitsBase::ShowAssertDialog(const wxString& msg)
{
#if defined(__WXMSW__) || !wxUSE_MSGDLG
    // under MSW we prefer to use the base class version using ::MessageBox()
    // even if wxMessageBox() is available because it has less chances to
    // double fault our app than our wxMessageBox()
    return wxAppTraitsBase::ShowAssertDialog(msg);
#else // wxUSE_MSGDLG
    wxString msgDlg = msg;

#if wxUSE_STACKWALKER
    // 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);

    const wxString stackTrace = GetAssertStackTrace();
    if ( !stackTrace.empty() )
        msgDlg << _T("\n\nCall stack:\n") << stackTrace;
#endif // wxUSE_STACKWALKER

    // this message is intentionally not translated -- it is for
    // developpers only
    msgDlg += wxT("\nDo you want to stop the program?\n")
              wxT("You can also choose [Cancel] to suppress ")
              wxT("further warnings.");

    switch ( wxMessageBox(msgDlg, wxT("wxWidgets Debug Alert"),
                          wxYES_NO | wxCANCEL | wxICON_STOP ) )
    {
        case wxYES:
            wxTrap();
            break;

        case wxCANCEL:
            // no more asserts
            return true;

        //case wxNO: nothing to do
    }

    return false;
#endif // !wxUSE_MSGDLG/wxUSE_MSGDLG
}

#endif // __WXDEBUG__

bool wxGUIAppTraitsBase::HasStderr()
{
    // we consider that under Unix stderr always goes somewhere, even if the
    // user doesn't always see it under GUI desktops
#ifdef __UNIX__
    return true;
#else
    return false;
#endif
}

void wxGUIAppTraitsBase::ScheduleForDestroy(wxObject *object)
{
    if ( !wxPendingDelete.Member(object) )
        wxPendingDelete.Append(object);
}

void wxGUIAppTraitsBase::RemoveFromPendingDelete(wxObject *object)
{
    wxPendingDelete.DeleteObject(object);
}

#if wxUSE_SOCKETS

#if defined(__WINDOWS__)
    #include "wx/msw/gsockmsw.h"
#elif defined(__UNIX__) || defined(__DARWIN__) || defined(__OS2__)
    #include "wx/unix/gsockunx.h"
#elif defined(__WXMAC__)
    #include <MacHeaders.c>
    #define OTUNIXERRORS 1
    #include <OpenTransport.h>
    #include <OpenTransportProviders.h>
    #include <OpenTptInternet.h>

    #include "wx/mac/gsockmac.h"
#else
    #error "Must include correct GSocket header here"
#endif

GSocketGUIFunctionsTable* wxGUIAppTraitsBase::GetSocketGUIFunctionsTable()
{
#if defined(__WXMAC__) && !defined(__DARWIN__)
    // NB: wxMac CFM does not have any GUI-specific functions in gsocket.c and
    //     so it doesn't need this table at all
    return NULL;
#else // !__WXMAC__ || __DARWIN__
    static GSocketGUIFunctionsTableConcrete table;
    return &table;
#endif // !__WXMAC__ || __DARWIN__
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/appcmn.cpp
	3	// Purpose: wxAppConsole and wxAppBase methods common to all platforms
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 18.10.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Vadim Zeitlin
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ---------------------------------------------------------------------------
	17	// headers
	18	// ---------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#if defined(__BORLANDC__)
	24	#pragma hdrstop
	25	#endif
	26
	27	#ifndef WX_PRECOMP
	28	#include "wx/app.h"
	29	#include "wx/window.h"
	30	#include "wx/bitmap.h"
	31	#include "wx/log.h"
	32	#include "wx/msgdlg.h"
	33	#include "wx/confbase.h"
	34	#include "wx/utils.h"
	35	#include "wx/wxcrtvararg.h"
	36	#endif
	37
	38	#include "wx/apptrait.h"
	39	#include "wx/cmdline.h"
	40	#include "wx/msgout.h"
	41	#include "wx/thread.h"
	42	#include "wx/vidmode.h"
	43
	44	#ifdef __WXDEBUG__
	45	#if wxUSE_STACKWALKER
	46	#include "wx/stackwalk.h"
	47	#endif // wxUSE_STACKWALKER
	48	#endif // __WXDEBUG__
	49
	50	#if defined(__WXMSW__)
	51	#include "wx/msw/private.h" // includes windows.h for LOGFONT
	52	#endif
	53
	54	#if wxUSE_FONTMAP
	55	#include "wx/fontmap.h"
	56	#endif // wxUSE_FONTMAP
	57
	58	// DLL options compatibility check:
	59	#include "wx/build.h"
	60	WX_CHECK_BUILD_OPTIONS("wxCore")
	61
	62	WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete;
	63
	64	// ============================================================================
	65	// wxAppBase implementation
	66	// ============================================================================
	67
	68	// ----------------------------------------------------------------------------
	69	// initialization
	70	// ----------------------------------------------------------------------------
	71
	72	wxAppBase::wxAppBase()
	73	{
	74	m_topWindow = (wxWindow *)NULL;
	75
	76	m_useBestVisual = false;
	77	m_forceTrueColour = false;
	78
	79	m_isActive = true;
	80
	81	// We don't want to exit the app if the user code shows a dialog from its
	82	// OnInit() -- but this is what would happen if we set m_exitOnFrameDelete
	83	// to Yes initially as this dialog would be the last top level window.
	84	// OTOH, if we set it to No initially we'll have to overwrite it with Yes
	85	// when we enter our OnRun() because we do want the default behaviour from
	86	// then on. But this would be a problem if the user code calls
	87	// SetExitOnFrameDelete(false) from OnInit().
	88	//
	89	// So we use the special "Later" value which is such that
	90	// GetExitOnFrameDelete() returns false for it but which we know we can
	91	// safely (i.e. without losing the effect of the users SetExitOnFrameDelete
	92	// call) overwrite in OnRun()
	93	m_exitOnFrameDelete = Later;
	94	}
	95
	96	bool wxAppBase::Initialize(int& argcOrig, wxChar **argvOrig)
	97	{
	98	if ( !wxAppConsole::Initialize(argcOrig, argvOrig) )
	99	return false;
	100
	101	wxInitializeStockLists();
	102
	103	wxBitmap::InitStandardHandlers();
	104
	105	return true;
	106	}
	107
	108	// ----------------------------------------------------------------------------
	109	// cleanup
	110	// ----------------------------------------------------------------------------
	111
	112	wxAppBase::~wxAppBase()
	113	{
	114	// this destructor is required for Darwin
	115	}
	116
	117	void wxAppBase::CleanUp()
	118	{
	119	// clean up all the pending objects
	120	DeletePendingObjects();
	121
	122	// and any remaining TLWs (they remove themselves from wxTopLevelWindows
	123	// when destroyed, so iterate until none are left)
	124	while ( !wxTopLevelWindows.empty() )
	125	{
	126	// do not use Destroy() here as it only puts the TLW in pending list
	127	// but we want to delete them now
	128	delete wxTopLevelWindows.GetFirst()->GetData();
	129	}
	130
	131	// undo everything we did in Initialize() above
	132	wxBitmap::CleanUpHandlers();
	133
	134	wxStockGDI::DeleteAll();
	135
	136	wxDeleteStockLists();
	137
	138	delete wxTheColourDatabase;
	139	wxTheColourDatabase = NULL;
	140
	141	#if wxUSE_THREADS
	142	#if wxUSE_VALIDATORS
	143	// If we don't do the following, we get an apparent memory leak.
	144	((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
	145	#endif // wxUSE_VALIDATORS
	146	#endif // wxUSE_THREADS
	147
	148	wxAppConsole::CleanUp();
	149	}
	150
	151	// ----------------------------------------------------------------------------
	152	// various accessors
	153	// ----------------------------------------------------------------------------
	154
	155	wxWindow* wxAppBase::GetTopWindow() const
	156	{
	157	wxWindow* window = m_topWindow;
	158	if (window == NULL && wxTopLevelWindows.GetCount() > 0)
	159	window = wxTopLevelWindows.GetFirst()->GetData();
	160	return window;
	161	}
	162
	163	wxVideoMode wxAppBase::GetDisplayMode() const
	164	{
	165	return wxVideoMode();
	166	}
	167
	168	wxLayoutDirection wxAppBase::GetLayoutDirection() const
	169	{
	170	#if wxUSE_INTL
	171	const wxLocale *const locale = wxGetLocale();
	172	if ( locale )
	173	{
	174	const wxLanguageInfo *const
	175	info = wxLocale::GetLanguageInfo(locale->GetLanguage());
	176
	177	if ( info )
	178	return info->LayoutDirection;
	179	}
	180	#endif // wxUSE_INTL
	181
	182	// we don't know
	183	return wxLayout_Default;
	184	}
	185
	186	#if wxUSE_CMDLINE_PARSER
	187
	188	// ----------------------------------------------------------------------------
	189	// GUI-specific command line options handling
	190	// ----------------------------------------------------------------------------
	191
	192	#define OPTION_THEME _T("theme")
	193	#define OPTION_MODE _T("mode")
	194
	195	void wxAppBase::OnInitCmdLine(wxCmdLineParser& parser)
	196	{
	197	// first add the standard non GUI options
	198	wxAppConsole::OnInitCmdLine(parser);
	199
	200	// the standard command line options
	201	static const wxCmdLineEntryDesc cmdLineGUIDesc[] =
	202	{
	203	#ifdef __WXUNIVERSAL__
	204	{
	205	wxCMD_LINE_OPTION,
	206	wxEmptyString,
	207	OPTION_THEME,
	208	gettext_noop("specify the theme to use"),
	209	wxCMD_LINE_VAL_STRING,
	210	0x0
	211	},
	212	#endif // __WXUNIVERSAL__
	213
	214	#if defined(__WXMGL__)
	215	// VS: this is not specific to wxMGL, all fullscreen (framebuffer) ports
	216	// should provide this option. That's why it is in common/appcmn.cpp
	217	// and not mgl/app.cpp
	218	{
	219	wxCMD_LINE_OPTION,
	220	wxEmptyString,
	221	OPTION_MODE,
	222	gettext_noop("specify display mode to use (e.g. 640x480-16)"),
	223	wxCMD_LINE_VAL_STRING,
	224	0x0
	225	},
	226	#endif // __WXMGL__
	227
	228	// terminator
	229	{
	230	wxCMD_LINE_NONE,
	231	wxEmptyString,
	232	wxEmptyString,
	233	wxEmptyString,
	234	wxCMD_LINE_VAL_NONE,
	235	0x0
	236	}
	237	};
	238
	239	parser.SetDesc(cmdLineGUIDesc);
	240	}
	241
	242	bool wxAppBase::OnCmdLineParsed(wxCmdLineParser& parser)
	243	{
	244	#ifdef __WXUNIVERSAL__
	245	wxString themeName;
	246	if ( parser.Found(OPTION_THEME, &themeName) )
	247	{
	248	wxTheme *theme = wxTheme::Create(themeName);
	249	if ( !theme )
	250	{
	251	wxLogError(_("Unsupported theme '%s'."), themeName.c_str());
	252	return false;
	253	}
	254
	255	// Delete the defaultly created theme and set the new theme.
	256	delete wxTheme::Get();
	257	wxTheme::Set(theme);
	258	}
	259	#endif // __WXUNIVERSAL__
	260
	261	#if defined(__WXMGL__)
	262	wxString modeDesc;
	263	if ( parser.Found(OPTION_MODE, &modeDesc) )
	264	{
	265	unsigned w, h, bpp;
	266	if ( wxSscanf(modeDesc.c_str(), _T("%ux%u-%u"), &w, &h, &bpp) != 3 )
	267	{
	268	wxLogError(_("Invalid display mode specification '%s'."), modeDesc.c_str());
	269	return false;
	270	}
	271
	272	if ( !SetDisplayMode(wxVideoMode(w, h, bpp)) )
	273	return false;
	274	}
	275	#endif // __WXMGL__
	276
	277	return wxAppConsole::OnCmdLineParsed(parser);
	278	}
	279
	280	#endif // wxUSE_CMDLINE_PARSER
	281
	282	// ----------------------------------------------------------------------------
	283	// OnXXX() hooks
	284	// ----------------------------------------------------------------------------
	285
	286	bool wxAppBase::OnInitGui()
	287	{
	288	#ifdef __WXUNIVERSAL__
	289	if ( !wxTheme::Get() && !wxTheme::CreateDefault() )
	290	return false;
	291	#endif // __WXUNIVERSAL__
	292
	293	return true;
	294	}
	295
	296	int wxAppBase::OnRun()
	297	{
	298	// see the comment in ctor: if the initial value hasn't been changed, use
	299	// the default Yes from now on
	300	if ( m_exitOnFrameDelete == Later )
	301	{
	302	m_exitOnFrameDelete = Yes;
	303	}
	304	//else: it has been changed, assume the user knows what he is doing
	305
	306	return wxAppConsole::OnRun();
	307	}
	308
	309	int wxAppBase::OnExit()
	310	{
	311	#ifdef __WXUNIVERSAL__
	312	delete wxTheme::Set(NULL);
	313	#endif // __WXUNIVERSAL__
	314
	315	return wxAppConsole::OnExit();
	316	}
	317
	318	wxAppTraits *wxAppBase::CreateTraits()
	319	{
	320	return new wxGUIAppTraits;
	321	}
	322
	323	// ----------------------------------------------------------------------------
	324	// misc
	325	// ----------------------------------------------------------------------------
	326
	327	void wxAppBase::SetActive(bool active, wxWindow * WXUNUSED(lastFocus))
	328	{
	329	if ( active == m_isActive )
	330	return;
	331
	332	m_isActive = active;
	333
	334	wxActivateEvent event(wxEVT_ACTIVATE_APP, active);
	335	event.SetEventObject(this);
	336
	337	(void)ProcessEvent(event);
	338	}
	339
	340	// ----------------------------------------------------------------------------
	341	// idle handling
	342	// ----------------------------------------------------------------------------
	343
	344	void wxAppBase::DeletePendingObjects()
	345	{
	346	wxList::compatibility_iterator node = wxPendingDelete.GetFirst();
	347	while (node)
	348	{
	349	wxObject *obj = node->GetData();
	350
	351	// remove it from the list first so that if we get back here somehow
	352	// during the object deletion (e.g. wxYield called from its dtor) we
	353	// wouldn't try to delete it the second time
	354	if ( wxPendingDelete.Member(obj) )
	355	wxPendingDelete.Erase(node);
	356
	357	delete obj;
	358
	359	// Deleting one object may have deleted other pending
	360	// objects, so start from beginning of list again.
	361	node = wxPendingDelete.GetFirst();
	362	}
	363	}
	364
	365	// Returns true if more time is needed.
	366	bool wxAppBase::ProcessIdle()
	367	{
	368	// process pending wx events before sending idle events
	369	ProcessPendingEvents();
	370
	371	wxIdleEvent event;
	372	bool needMore = false;
	373	wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
	374	while (node)
	375	{
	376	wxWindow* win = node->GetData();
	377	if (SendIdleEvents(win, event))
	378	needMore = true;
	379	node = node->GetNext();
	380	}
	381
	382	if (wxAppConsole::ProcessIdle())
	383	needMore = true;
	384
	385	// 'Garbage' collection of windows deleted with Close().
	386	DeletePendingObjects();
	387
	388	#if wxUSE_LOG
	389	// flush the logged messages if any
	390	wxLog::FlushActive();
	391	#endif
	392
	393	wxUpdateUIEvent::ResetUpdateTime();
	394
	395	return needMore;
	396	}
	397
	398	// Send idle event to window and all subwindows
	399	bool wxAppBase::SendIdleEvents(wxWindow* win, wxIdleEvent& event)
	400	{
	401	bool needMore = false;
	402
	403	win->OnInternalIdle();
	404
	405	// should we send idle event to this window?
	406	if ( wxIdleEvent::GetMode() == wxIDLE_PROCESS_ALL \|\|
	407	win->HasExtraStyle(wxWS_EX_PROCESS_IDLE) )
	408	{
	409	event.SetEventObject(win);
	410	win->GetEventHandler()->ProcessEvent(event);
	411
	412	if (event.MoreRequested())
	413	needMore = true;
	414	}
	415	wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
	416	while ( node )
	417	{
	418	wxWindow *child = node->GetData();
	419	if (SendIdleEvents(child, event))
	420	needMore = true;
	421
	422	node = node->GetNext();
	423	}
	424
	425	return needMore;
	426	}
	427
	428	// ----------------------------------------------------------------------------
	429	// wxGUIAppTraitsBase
	430	// ----------------------------------------------------------------------------
	431
	432	#if wxUSE_LOG
	433
	434	wxLog *wxGUIAppTraitsBase::CreateLogTarget()
	435	{
	436	#if wxUSE_LOGGUI
	437	return new wxLogGui;
	438	#else
	439	// we must have something!
	440	return new wxLogStderr;
	441	#endif
	442	}
	443
	444	#endif // wxUSE_LOG
	445
	446	wxMessageOutput *wxGUIAppTraitsBase::CreateMessageOutput()
	447	{
	448	// The standard way of printing help on command line arguments (app --help)
	449	// is (according to common practice):
	450	// - console apps: to stderr (on any platform)
	451	// - GUI apps: stderr on Unix platforms (!)
	452	// message box under Windows and others
	453	#ifdef __UNIX__
	454	return new wxMessageOutputStderr;
	455	#else // !__UNIX__
	456	// wxMessageOutputMessageBox doesn't work under Motif
	457	#ifdef __WXMOTIF__
	458	return new wxMessageOutputLog;
	459	#else
	460	return new wxMessageOutputMessageBox;
	461	#endif
	462	#endif // __UNIX__/!__UNIX__
	463	}
	464
	465	#if wxUSE_FONTMAP
	466
	467	wxFontMapper *wxGUIAppTraitsBase::CreateFontMapper()
	468	{
	469	return new wxFontMapper;
	470	}
	471
	472	#endif // wxUSE_FONTMAP
	473
	474	wxRendererNative *wxGUIAppTraitsBase::CreateRenderer()
	475	{
	476	// use the default native renderer by default
	477	return NULL;
	478	}
	479
	480	#ifdef __WXDEBUG__
	481
	482	bool wxGUIAppTraitsBase::ShowAssertDialog(const wxString& msg)
	483	{
	484	#if defined(__WXMSW__) \|\| !wxUSE_MSGDLG
	485	// under MSW we prefer to use the base class version using ::MessageBox()
	486	// even if wxMessageBox() is available because it has less chances to
	487	// double fault our app than our wxMessageBox()
	488	return wxAppTraitsBase::ShowAssertDialog(msg);
	489	#else // wxUSE_MSGDLG
	490	wxString msgDlg = msg;
	491
	492	#if wxUSE_STACKWALKER
	493	// on Unix stack frame generation may take some time, depending on the
	494	// size of the executable mainly... warn the user that we are working
	495	wxFprintf(stderr, wxT("[Debug] Generating a stack trace... please wait"));
	496	fflush(stderr);
	497
	498	const wxString stackTrace = GetAssertStackTrace();
	499	if ( !stackTrace.empty() )
	500	msgDlg << _T("\n\nCall stack:\n") << stackTrace;
	501	#endif // wxUSE_STACKWALKER
	502
	503	// this message is intentionally not translated -- it is for
	504	// developpers only
	505	msgDlg += wxT("\nDo you want to stop the program?\n")
	506	wxT("You can also choose [Cancel] to suppress ")
	507	wxT("further warnings.");
	508
	509	switch ( wxMessageBox(msgDlg, wxT("wxWidgets Debug Alert"),
	510	wxYES_NO \| wxCANCEL \| wxICON_STOP ) )
	511	{
	512	case wxYES:
	513	wxTrap();
	514	break;
	515
	516	case wxCANCEL:
	517	// no more asserts
	518	return true;
	519
	520	//case wxNO: nothing to do
	521	}
	522
	523	return false;
	524	#endif // !wxUSE_MSGDLG/wxUSE_MSGDLG
	525	}
	526
	527	#endif // __WXDEBUG__
	528
	529	bool wxGUIAppTraitsBase::HasStderr()
	530	{
	531	// we consider that under Unix stderr always goes somewhere, even if the
	532	// user doesn't always see it under GUI desktops
	533	#ifdef __UNIX__
	534	return true;
	535	#else
	536	return false;
	537	#endif
	538	}
	539
	540	void wxGUIAppTraitsBase::ScheduleForDestroy(wxObject *object)
	541	{
	542	if ( !wxPendingDelete.Member(object) )
	543	wxPendingDelete.Append(object);
	544	}
	545
	546	void wxGUIAppTraitsBase::RemoveFromPendingDelete(wxObject *object)
	547	{
	548	wxPendingDelete.DeleteObject(object);
	549	}
	550
	551	#if wxUSE_SOCKETS
	552
	553	#if defined(__WINDOWS__)
	554	#include "wx/msw/gsockmsw.h"
	555	#elif defined(__UNIX__) \|\| defined(__DARWIN__) \|\| defined(__OS2__)
	556	#include "wx/unix/gsockunx.h"
	557	#elif defined(__WXMAC__)
	558	#include <MacHeaders.c>
	559	#define OTUNIXERRORS 1
	560	#include <OpenTransport.h>
	561	#include <OpenTransportProviders.h>
	562	#include <OpenTptInternet.h>
	563
	564	#include "wx/mac/gsockmac.h"
	565	#else
	566	#error "Must include correct GSocket header here"
	567	#endif
	568
	569	GSocketGUIFunctionsTable* wxGUIAppTraitsBase::GetSocketGUIFunctionsTable()
	570	{
	571	#if defined(__WXMAC__) && !defined(__DARWIN__)
	572	// NB: wxMac CFM does not have any GUI-specific functions in gsocket.c and
	573	// so it doesn't need this table at all
	574	return NULL;
	575	#else // !__WXMAC__ \|\| __DARWIN__
	576	static GSocketGUIFunctionsTableConcrete table;
	577	return &table;
	578	#endif // !__WXMAC__ \|\| __DARWIN__
	579	}
	580
	581	#endif