src/motif/app.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/motif/app.cpp
// Purpose:     wxApp
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __VMS
#define XtParent XTPARENT
#define XtDisplay XTDISPLAY
#endif

#include "wx/app.h"

#ifndef WX_PRECOMP
    #include "wx/hash.h"
    #include "wx/intl.h"
    #include "wx/log.h"
    #include "wx/utils.h"
    #include "wx/memory.h"
    #include "wx/font.h"
#endif

#include "wx/evtloop.h"

#if wxUSE_THREADS
    #include "wx/thread.h"
#endif

#ifdef __VMS__
    #pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>
#include <X11/Xatom.h>
#ifdef __VMS__
    #pragma message enable nosimpint
#endif

#include "wx/motif/private.h"

#include <string.h>

struct wxPerDisplayData
{
    wxPerDisplayData()
    {
        m_visualInfo = NULL;
        m_topLevelWidget = NULL;
        m_topLevelRealizedWidget = NULL;
    }

    wxXVisualInfo* m_visualInfo;
    Widget         m_topLevelWidget, m_topLevelRealizedWidget;
};

static void wxTLWidgetDestroyCallback(Widget w, XtPointer clientData,
                                      XtPointer ptr);
static WXWidget wxCreateTopLevelWidget( WXDisplay* display );

extern bool wxAddIdleCallback();

wxHashTable *wxWidgetHashTable = NULL;

IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

#ifdef __WXDEBUG__
extern "C"
{
    typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
}

XErrorHandlerFunc gs_pfnXErrorHandler = 0;

extern "C"
{

static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
{
    // just forward to the default handler for now
    return gs_pfnXErrorHandler(dpy, xevent);
}

}
#endif // __WXDEBUG__

bool wxApp::Initialize(int& argcOrig, wxChar **argvOrig)
{
#if wxUSE_INTL
    wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif

    if ( !wxAppBase::Initialize(argcOrig, argvOrig) )
        return false;

    wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);

    return true;
}

void wxApp::CleanUp()
{
    wxAppBase::CleanUp();

    delete wxWidgetHashTable;
    wxWidgetHashTable = NULL;

    delete m_mainLoop;

    for( wxPerDisplayDataMap::iterator it  = m_perDisplayData->begin(),
                                       end = m_perDisplayData->end();
         it != end; ++it )
    {
        delete it->second->m_visualInfo;
        // On Solaris 10 calling XtDestroyWidget on the top level widget
        // dumps core if the locale is set to something other than "C"
#ifndef __SUN__
        XtDestroyWidget( it->second->m_topLevelWidget );
#endif
        delete it->second;
    }
}

void wxApp::Exit()
{
    wxApp::CleanUp();

    wxAppConsole::Exit();
}

// ============================================================================
// wxApp
// ============================================================================

wxApp::wxApp()
{
    argc = 0;
    argv = NULL;

    m_mainLoop = new wxEventLoop;
    m_mainColormap = (WXColormap) NULL;
    m_appContext = (WXAppContext) NULL;
    m_initialDisplay = (WXDisplay*) 0;
    m_perDisplayData = new wxPerDisplayDataMap;
}

wxApp::~wxApp()
{
    delete m_perDisplayData;
}

int wxApp::MainLoop()
{
    /*
    * Sit around forever waiting to process X-events. Property Change
    * event are handled special, because they have to refer to
    * the root window rather than to a widget. therefore we can't
    * use an Xt-eventhandler.
    */

    XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
        XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
        PropertyChangeMask);

    m_mainLoop->Run();

    return 0;
}

// This should be redefined in a derived class for
// handling property change events for XAtom IPC.
void wxApp::HandlePropertyChange(WXEvent *event)
{
    // by default do nothing special
    XtDispatchEvent((XEvent*) event); /* let Motif do the work */
}

static char *fallbackResources[] = {
    // better defaults for CDE under Irix
    //
    // TODO: do something similar for the other systems, the hardcoded defaults
    //       below are ugly
#ifdef __SGI__
    wxMOTIF_STR("*sgiMode: True"),
    wxMOTIF_STR("*useSchemes: all"),
#else // !__SGI__
#if !wxMOTIF_USE_RENDER_TABLE
    wxMOTIF_STR("*.fontList: -*-helvetica-medium-r-normal-*-*-120-*-*-*-*-*-*"),
#else
    wxMOTIF_STR("*wxDefaultRendition.fontName: -*-helvetica-medium-r-normal-*-*-120-*-*-*-*-*-*"),
    wxMOTIF_STR("*wxDefaultRendition.fontType: FONT_IS_FONTSET"),
    wxMOTIF_STR("*.renderTable: wxDefaultRendition"),
#endif
    wxMOTIF_STR("*listBox.background: white"),
    wxMOTIF_STR("*text.background: white"),
    wxMOTIF_STR("*comboBox.Text.background: white"),
    wxMOTIF_STR("*comboBox.List.background: white"),
#endif // __SGI__/!__SGI__
    NULL
};

// Create an application context
bool wxApp::OnInitGui()
{
    if( !wxAppBase::OnInitGui() )
        return false;

#ifdef __HPUX__
    // under HP-UX creating XmFontSet fails when the system locale is C and
    // we're using a remote DISPLAY, presumably because HP-UX uses its own
    // names for C and ISO locales (roman8 and iso8859n respectively) and so
    // its Motif libraries have troubles with non-HP X server
    //
    // whatever the reason, the fact is that without this hack any wxMotif
    // program crashes on startup because it can't create any font (HP programs
    // still work but they do spit out messages about failing to create font
    // sets and failing back on "fixed" font too)
    //
    // notice that calling setlocale() here is not enough because X(m) init
    // functions call setlocale() later so we really have to change environment
    bool fixAll = false; // tweak LC_ALL (or just LC_CTYPE)?
    const char *loc = getenv("LC_CTYPE");
    if ( !loc )
    {
        loc = getenv("LC_ALL");
        if ( loc )
            fixAll = true;
    }

    if ( !loc ||
            (loc[0] == 'C' && loc[1] == '\0') ||
                strcmp(loc, "POSIX") == 0 )
    {
        // we're using C locale, "fix" it
        wxLogDebug(_T("HP-UX fontset hack: forcing locale to en_US.iso88591"));
        putenv(fixAll ? "LC_ALL=en_US.iso88591" : "LC_CTYPE=en_US.iso88591");
    }
#endif // __HPUX__

    XtSetLanguageProc(NULL, NULL, NULL);
    XtToolkitInitialize() ;
    wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext();
    XtAppSetFallbackResources((XtAppContext) wxTheApp->m_appContext, fallbackResources);

    // we shouldn't pass empty application/class name as it results in
    // immediate crash inside XOpenIM() (if XIM is used) under IRIX
    wxString appname = wxTheApp->GetAppName();
    if ( appname.empty() )
        appname = _T("wxapp");
    wxString clsname = wxTheApp->GetClassName();
    if ( clsname.empty() )
        clsname = _T("wx");

    Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
        (String)NULL,
        appname.c_str(),
        clsname.c_str(),
        NULL, 0,    // no options
# if XtSpecificationRelease < 5
        (Cardinal*) &argc,
# else
        &argc,
# endif
        argv);

    if (!dpy) {
         // if you don't log to stderr, nothing will be shown...
        delete wxLog::SetActiveTarget(new wxLogStderr);
        wxString className(wxTheApp->GetClassName());
        wxLogError(_("wxWidgets could not open display for '%s': exiting."),
                   className.c_str());
        exit(-1);
    }
    m_initialDisplay = (WXDisplay*) dpy;

#ifdef __WXDEBUG__
    // install the X error handler
    gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
#endif // __WXDEBUG__

    // Add general resize proc
    XtActionsRec rec;
    rec.string = wxMOTIF_STR("resize");
    rec.proc = (XtActionProc)wxWidgetResizeProc;
    XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);

    GetMainColormap(dpy);

    wxAddIdleCallback();

    return true;
}

WXColormap wxApp::GetMainColormap(WXDisplay* display)
{
    if (!display) /* Must be called first with non-NULL display */
        return m_mainColormap;

    int defaultScreen = DefaultScreen((Display*) display);
    Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);

    Colormap c = DefaultColormapOfScreen(screen);

    if (!m_mainColormap)
        m_mainColormap = (WXColormap) c;

    return (WXColormap) c;
}

static inline wxPerDisplayData& GetOrCreatePerDisplayData
    ( wxPerDisplayDataMap& m, WXDisplay* display )
{
    wxPerDisplayDataMap::iterator it = m.find( display );
    if( it != m.end() && it->second != NULL )
        return *(it->second);

    wxPerDisplayData* nData = new wxPerDisplayData();
    m[display] = nData;

    return *nData;
}

wxXVisualInfo* wxApp::GetVisualInfo( WXDisplay* display )
{
    wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
                                                        display );
    if( data.m_visualInfo )
        return data.m_visualInfo;

    wxXVisualInfo* vi = new wxXVisualInfo;
    wxFillXVisualInfo( vi, (Display*)display );

    data.m_visualInfo = vi;

    return vi;
}

static void wxTLWidgetDestroyCallback(Widget w, XtPointer WXUNUSED(clientData),
                                      XtPointer WXUNUSED(ptr))
{
    if( wxTheApp )
    {
        wxTheApp->SetTopLevelWidget( (WXDisplay*)XtDisplay(w),
                                     (WXWidget)NULL );
        wxTheApp->SetTopLevelRealizedWidget( (WXDisplay*)XtDisplay(w),
                                             (WXWidget)NULL );
    }
}

WXWidget wxCreateTopLevelWidget( WXDisplay* display )
{
    Widget tlw = XtAppCreateShell( (String)NULL,
                                   wxTheApp->GetClassName().c_str(),
                                   applicationShellWidgetClass,
                                   (Display*)display,
                                   NULL, 0 );
    XtVaSetValues( tlw,
                   XmNoverrideRedirect, True,
                   NULL );

    XtAddCallback( tlw, XmNdestroyCallback,
                   (XtCallbackProc)wxTLWidgetDestroyCallback,
                   (XtPointer)NULL );

    return (WXWidget)tlw;
}

WXWidget wxCreateTopLevelRealizedWidget( WXDisplay* WXUNUSED(display) )
{
    Widget rTlw = XtVaCreateWidget( "dummy_widget", topLevelShellWidgetClass,
                                    (Widget)wxTheApp->GetTopLevelWidget(),
                                     NULL );
    XtSetMappedWhenManaged( rTlw, False );
    XtRealizeWidget( rTlw );

    return (WXWidget)rTlw;
}

WXWidget wxApp::GetTopLevelWidget()
{
    WXDisplay* display = wxGetDisplay();
    wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
                                                        display );
    if( data.m_topLevelWidget )
        return (WXWidget)data.m_topLevelWidget;

    WXWidget tlw = wxCreateTopLevelWidget( display );
    SetTopLevelWidget( display, tlw );

    return tlw;
}

WXWidget wxApp::GetTopLevelRealizedWidget()
{
    WXDisplay* display = wxGetDisplay();
    wxPerDisplayDataMap::iterator it = m_perDisplayData->find( display );

    if( it != m_perDisplayData->end() && it->second->m_topLevelRealizedWidget )
        return (WXWidget)it->second->m_topLevelRealizedWidget;

    WXWidget rTlw = wxCreateTopLevelRealizedWidget( display );
    SetTopLevelRealizedWidget( display, rTlw );

    return rTlw;
}

void wxApp::SetTopLevelWidget(WXDisplay* display, WXWidget widget)
{
    GetOrCreatePerDisplayData( *m_perDisplayData, display )
        .m_topLevelWidget = (Widget)widget;
}

void wxApp::SetTopLevelRealizedWidget(WXDisplay* display, WXWidget widget)
{
    GetOrCreatePerDisplayData( *m_perDisplayData, display )
        .m_topLevelRealizedWidget = (Widget)widget;
}

// Yield to other processes

bool wxApp::Yield(bool onlyIfNeeded)
{
    static bool s_inYield = false;

    if ( s_inYield )
    {
        if ( !onlyIfNeeded )
        {
            wxFAIL_MSG( wxT("wxYield called recursively" ) );
        }

        return false;
    }

    s_inYield = true;

    while (wxTheApp && wxTheApp->Pending())
        wxTheApp->Dispatch();

    s_inYield = false;

    return true;
}

// ----------------------------------------------------------------------------
// accessors for C modules
// ----------------------------------------------------------------------------

extern "C" XtAppContext wxGetAppContext()
{
    return (XtAppContext)wxTheApp->GetAppContext();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/motif/app.cpp
	3	// Purpose: wxApp
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __VMS
	16	#define XtParent XTPARENT
	17	#define XtDisplay XTDISPLAY
	18	#endif
	19
	20	#include "wx/app.h"
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/hash.h"
	24	#include "wx/intl.h"
	25	#include "wx/log.h"
	26	#include "wx/utils.h"
	27	#include "wx/memory.h"
	28	#include "wx/font.h"
	29	#endif
	30
	31	#include "wx/evtloop.h"
	32
	33	#if wxUSE_THREADS
	34	#include "wx/thread.h"
	35	#endif
	36
	37	#ifdef __VMS__
	38	#pragma message disable nosimpint
	39	#endif
	40	#include <Xm/Xm.h>
	41	#include <X11/Xlib.h>
	42	#include <X11/Xutil.h>
	43	#include <X11/Xresource.h>
	44	#include <X11/Xatom.h>
	45	#ifdef __VMS__
	46	#pragma message enable nosimpint
	47	#endif
	48
	49	#include "wx/motif/private.h"
	50
	51	#include <string.h>
	52
	53	struct wxPerDisplayData
	54	{
	55	wxPerDisplayData()
	56	{
	57	m_visualInfo = NULL;
	58	m_topLevelWidget = NULL;
	59	m_topLevelRealizedWidget = NULL;
	60	}
	61
	62	wxXVisualInfo* m_visualInfo;
	63	Widget m_topLevelWidget, m_topLevelRealizedWidget;
	64	};
	65
	66	static void wxTLWidgetDestroyCallback(Widget w, XtPointer clientData,
	67	XtPointer ptr);
	68	static WXWidget wxCreateTopLevelWidget( WXDisplay* display );
	69
	70	extern bool wxAddIdleCallback();
	71
	72	wxHashTable *wxWidgetHashTable = NULL;
	73
	74	IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
	75
	76	#ifdef __WXDEBUG__
	77	extern "C"
	78	{
	79	typedef int (XErrorHandlerFunc)(Display , XErrorEvent *);
	80	}
	81
	82	XErrorHandlerFunc gs_pfnXErrorHandler = 0;
	83
	84	extern "C"
	85	{
	86
	87	static int wxXErrorHandler(Display dpy, XErrorEvent xevent)
	88	{
	89	// just forward to the default handler for now
	90	return gs_pfnXErrorHandler(dpy, xevent);
	91	}
	92
	93	}
	94	#endif // __WXDEBUG__
	95
	96	bool wxApp::Initialize(int& argcOrig, wxChar **argvOrig)
	97	{
	98	#if wxUSE_INTL
	99	wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
	100	#endif
	101
	102	if ( !wxAppBase::Initialize(argcOrig, argvOrig) )
	103	return false;
	104
	105	wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
	106
	107	return true;
	108	}
	109
	110	void wxApp::CleanUp()
	111	{
	112	wxAppBase::CleanUp();
	113
	114	delete wxWidgetHashTable;
	115	wxWidgetHashTable = NULL;
	116
	117	delete m_mainLoop;
	118
	119	for( wxPerDisplayDataMap::iterator it = m_perDisplayData->begin(),
	120	end = m_perDisplayData->end();
	121	it != end; ++it )
	122	{
	123	delete it->second->m_visualInfo;
	124	// On Solaris 10 calling XtDestroyWidget on the top level widget
	125	// dumps core if the locale is set to something other than "C"
	126	#ifndef __SUN__
	127	XtDestroyWidget( it->second->m_topLevelWidget );
	128	#endif
	129	delete it->second;
	130	}
	131	}
	132
	133	void wxApp::Exit()
	134	{
	135	wxApp::CleanUp();
	136
	137	wxAppConsole::Exit();
	138	}
	139
	140	// ============================================================================
	141	// wxApp
	142	// ============================================================================
	143
	144	wxApp::wxApp()
	145	{
	146	argc = 0;
	147	argv = NULL;
	148
	149	m_mainLoop = new wxEventLoop;
	150	m_mainColormap = (WXColormap) NULL;
	151	m_appContext = (WXAppContext) NULL;
	152	m_initialDisplay = (WXDisplay*) 0;
	153	m_perDisplayData = new wxPerDisplayDataMap;
	154	}
	155
	156	wxApp::~wxApp()
	157	{
	158	delete m_perDisplayData;
	159	}
	160
	161	int wxApp::MainLoop()
	162	{
	163	/*
	164	* Sit around forever waiting to process X-events. Property Change
	165	* event are handled special, because they have to refer to
	166	* the root window rather than to a widget. therefore we can't
	167	* use an Xt-eventhandler.
	168	*/
	169
	170	XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
	171	XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
	172	PropertyChangeMask);
	173
	174	m_mainLoop->Run();
	175
	176	return 0;
	177	}
	178
	179	// This should be redefined in a derived class for
	180	// handling property change events for XAtom IPC.
	181	void wxApp::HandlePropertyChange(WXEvent *event)
	182	{
	183	// by default do nothing special
	184	XtDispatchEvent((XEvent) event); / let Motif do the work */
	185	}
	186
	187	static char *fallbackResources[] = {
	188	// better defaults for CDE under Irix
	189	//
	190	// TODO: do something similar for the other systems, the hardcoded defaults
	191	// below are ugly
	192	#ifdef __SGI__
	193	wxMOTIF_STR("*sgiMode: True"),
	194	wxMOTIF_STR("*useSchemes: all"),
	195	#else // !__SGI__
	196	#if !wxMOTIF_USE_RENDER_TABLE
	197	wxMOTIF_STR(".fontList: --helvetica-medium-r-normal---120------"),
	198	#else
	199	wxMOTIF_STR("wxDefaultRendition.fontName: --helvetica-medium-r-normal---120------"),
	200	wxMOTIF_STR("*wxDefaultRendition.fontType: FONT_IS_FONTSET"),
	201	wxMOTIF_STR("*.renderTable: wxDefaultRendition"),
	202	#endif
	203	wxMOTIF_STR("*listBox.background: white"),
	204	wxMOTIF_STR("*text.background: white"),
	205	wxMOTIF_STR("*comboBox.Text.background: white"),
	206	wxMOTIF_STR("*comboBox.List.background: white"),
	207	#endif // __SGI__/!__SGI__
	208	NULL
	209	};
	210
	211	// Create an application context
	212	bool wxApp::OnInitGui()
	213	{
	214	if( !wxAppBase::OnInitGui() )
	215	return false;
	216
	217	#ifdef __HPUX__
	218	// under HP-UX creating XmFontSet fails when the system locale is C and
	219	// we're using a remote DISPLAY, presumably because HP-UX uses its own
	220	// names for C and ISO locales (roman8 and iso8859n respectively) and so
	221	// its Motif libraries have troubles with non-HP X server
	222	//
	223	// whatever the reason, the fact is that without this hack any wxMotif
	224	// program crashes on startup because it can't create any font (HP programs
	225	// still work but they do spit out messages about failing to create font
	226	// sets and failing back on "fixed" font too)
	227	//
	228	// notice that calling setlocale() here is not enough because X(m) init
	229	// functions call setlocale() later so we really have to change environment
	230	bool fixAll = false; // tweak LC_ALL (or just LC_CTYPE)?
	231	const char *loc = getenv("LC_CTYPE");
	232	if ( !loc )
	233	{
	234	loc = getenv("LC_ALL");
	235	if ( loc )
	236	fixAll = true;
	237	}
	238
	239	if ( !loc \|\|
	240	(loc[0] == 'C' && loc[1] == '\0') \|\|
	241	strcmp(loc, "POSIX") == 0 )
	242	{
	243	// we're using C locale, "fix" it
	244	wxLogDebug(_T("HP-UX fontset hack: forcing locale to en_US.iso88591"));
	245	putenv(fixAll ? "LC_ALL=en_US.iso88591" : "LC_CTYPE=en_US.iso88591");
	246	}
	247	#endif // __HPUX__
	248
	249	XtSetLanguageProc(NULL, NULL, NULL);
	250	XtToolkitInitialize() ;
	251	wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext();
	252	XtAppSetFallbackResources((XtAppContext) wxTheApp->m_appContext, fallbackResources);
	253
	254	// we shouldn't pass empty application/class name as it results in
	255	// immediate crash inside XOpenIM() (if XIM is used) under IRIX
	256	wxString appname = wxTheApp->GetAppName();
	257	if ( appname.empty() )
	258	appname = _T("wxapp");
	259	wxString clsname = wxTheApp->GetClassName();
	260	if ( clsname.empty() )
	261	clsname = _T("wx");
	262
	263	Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
	264	(String)NULL,
	265	appname.c_str(),
	266	clsname.c_str(),
	267	NULL, 0, // no options
	268	# if XtSpecificationRelease < 5
	269	(Cardinal*) &argc,
	270	# else
	271	&argc,
	272	# endif
	273	argv);
	274
	275	if (!dpy) {
	276	// if you don't log to stderr, nothing will be shown...
	277	delete wxLog::SetActiveTarget(new wxLogStderr);
	278	wxString className(wxTheApp->GetClassName());
	279	wxLogError(_("wxWidgets could not open display for '%s': exiting."),
	280	className.c_str());
	281	exit(-1);
	282	}
	283	m_initialDisplay = (WXDisplay*) dpy;
	284
	285	#ifdef __WXDEBUG__
	286	// install the X error handler
	287	gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
	288	#endif // __WXDEBUG__
	289
	290	// Add general resize proc
	291	XtActionsRec rec;
	292	rec.string = wxMOTIF_STR("resize");
	293	rec.proc = (XtActionProc)wxWidgetResizeProc;
	294	XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);
	295
	296	GetMainColormap(dpy);
	297
	298	wxAddIdleCallback();
	299
	300	return true;
	301	}
	302
	303	WXColormap wxApp::GetMainColormap(WXDisplay* display)
	304	{
	305	if (!display) /* Must be called first with non-NULL display */
	306	return m_mainColormap;
	307
	308	int defaultScreen = DefaultScreen((Display*) display);
	309	Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
	310
	311	Colormap c = DefaultColormapOfScreen(screen);
	312
	313	if (!m_mainColormap)
	314	m_mainColormap = (WXColormap) c;
	315
	316	return (WXColormap) c;
	317	}
	318
	319	static inline wxPerDisplayData& GetOrCreatePerDisplayData
	320	( wxPerDisplayDataMap& m, WXDisplay* display )
	321	{
	322	wxPerDisplayDataMap::iterator it = m.find( display );
	323	if( it != m.end() && it->second != NULL )
	324	return *(it->second);
	325
	326	wxPerDisplayData* nData = new wxPerDisplayData();
	327	m[display] = nData;
	328
	329	return *nData;
	330	}
	331
	332	wxXVisualInfo* wxApp::GetVisualInfo( WXDisplay* display )
	333	{
	334	wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
	335	display );
	336	if( data.m_visualInfo )
	337	return data.m_visualInfo;
	338
	339	wxXVisualInfo* vi = new wxXVisualInfo;
	340	wxFillXVisualInfo( vi, (Display*)display );
	341
	342	data.m_visualInfo = vi;
	343
	344	return vi;
	345	}
	346
	347	static void wxTLWidgetDestroyCallback(Widget w, XtPointer WXUNUSED(clientData),
	348	XtPointer WXUNUSED(ptr))
	349	{
	350	if( wxTheApp )
	351	{
	352	wxTheApp->SetTopLevelWidget( (WXDisplay*)XtDisplay(w),
	353	(WXWidget)NULL );
	354	wxTheApp->SetTopLevelRealizedWidget( (WXDisplay*)XtDisplay(w),
	355	(WXWidget)NULL );
	356	}
	357	}
	358
	359	WXWidget wxCreateTopLevelWidget( WXDisplay* display )
	360	{
	361	Widget tlw = XtAppCreateShell( (String)NULL,
	362	wxTheApp->GetClassName().c_str(),
	363	applicationShellWidgetClass,
	364	(Display*)display,
	365	NULL, 0 );
	366	XtVaSetValues( tlw,
	367	XmNoverrideRedirect, True,
	368	NULL );
	369
	370	XtAddCallback( tlw, XmNdestroyCallback,
	371	(XtCallbackProc)wxTLWidgetDestroyCallback,
	372	(XtPointer)NULL );
	373
	374	return (WXWidget)tlw;
	375	}
	376
	377	WXWidget wxCreateTopLevelRealizedWidget( WXDisplay* WXUNUSED(display) )
	378	{
	379	Widget rTlw = XtVaCreateWidget( "dummy_widget", topLevelShellWidgetClass,
	380	(Widget)wxTheApp->GetTopLevelWidget(),
	381	NULL );
	382	XtSetMappedWhenManaged( rTlw, False );
	383	XtRealizeWidget( rTlw );
	384
	385	return (WXWidget)rTlw;
	386	}
	387
	388	WXWidget wxApp::GetTopLevelWidget()
	389	{
	390	WXDisplay* display = wxGetDisplay();
	391	wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
	392	display );
	393	if( data.m_topLevelWidget )
	394	return (WXWidget)data.m_topLevelWidget;
	395
	396	WXWidget tlw = wxCreateTopLevelWidget( display );
	397	SetTopLevelWidget( display, tlw );
	398
	399	return tlw;
	400	}
	401
	402	WXWidget wxApp::GetTopLevelRealizedWidget()
	403	{
	404	WXDisplay* display = wxGetDisplay();
	405	wxPerDisplayDataMap::iterator it = m_perDisplayData->find( display );
	406
	407	if( it != m_perDisplayData->end() && it->second->m_topLevelRealizedWidget )
	408	return (WXWidget)it->second->m_topLevelRealizedWidget;
	409
	410	WXWidget rTlw = wxCreateTopLevelRealizedWidget( display );
	411	SetTopLevelRealizedWidget( display, rTlw );
	412
	413	return rTlw;
	414	}
	415
	416	void wxApp::SetTopLevelWidget(WXDisplay* display, WXWidget widget)
	417	{
	418	GetOrCreatePerDisplayData( *m_perDisplayData, display )
	419	.m_topLevelWidget = (Widget)widget;
	420	}
	421
	422	void wxApp::SetTopLevelRealizedWidget(WXDisplay* display, WXWidget widget)
	423	{
	424	GetOrCreatePerDisplayData( *m_perDisplayData, display )
	425	.m_topLevelRealizedWidget = (Widget)widget;
	426	}
	427
	428	// Yield to other processes
	429
	430	bool wxApp::Yield(bool onlyIfNeeded)
	431	{
	432	static bool s_inYield = false;
	433
	434	if ( s_inYield )
	435	{
	436	if ( !onlyIfNeeded )
	437	{
	438	wxFAIL_MSG( wxT("wxYield called recursively" ) );
	439	}
	440
	441	return false;
	442	}
	443
	444	s_inYield = true;
	445
	446	while (wxTheApp && wxTheApp->Pending())
	447	wxTheApp->Dispatch();
	448
	449	s_inYield = false;
	450
	451	return true;
	452	}
	453
	454	// ----------------------------------------------------------------------------
	455	// accessors for C modules
	456	// ----------------------------------------------------------------------------
	457
	458	extern "C" XtAppContext wxGetAppContext()
	459	{
	460	return (XtAppContext)wxTheApp->GetAppContext();
	461	}