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"
#include "wx/utils.h"
#include "wx/module.h"
#include "wx/memory.h"
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/evtloop.h"
#include "wx/hash.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 wxList wxPendingDelete;
extern bool wxAddIdleCallback();

wxHashTable *wxWidgetHashTable = NULL;

IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
    EVT_IDLE(wxAppBase::OnIdle)
END_EVENT_TABLE()

#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 ( !wxAppBase::Initialize(argcOrig, argvOrig) )
        return false;

    wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);

#if wxUSE_INTL
    wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif

    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;
    }

    delete m_perDisplayData;
}

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()
{
    wxApp::SetInstance(NULL);
}

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